I have an sample program as shown.
I want my ArrayList
symbolsPresent
to be initialized with some predefined symbols: ONE, TWO, THREE, and FOUR.
symbolsPresent.add("ONE");
symbolsPresent.add("TWO");
symbolsPresent.add("THREE");
symbolsPresent.add("FOUR");
import java.util.ArrayList;
public class Test {
private ArrayList<String> symbolsPresent = new ArrayList<String>();
public ArrayList<String> getSymbolsPresent() {
return symbolsPresent;
}
public void setSymbolsPresent(ArrayList<String> symbolsPresent) {
this.symbolsPresent = symbolsPresent;
}
public static void main(String args[]) {
Test t = new Test();
System.out.println("Symbols Present is" + t.symbolsPresent);
}
}
Is that possible?
This question is related to
java
Personnaly I like to do all the initialisations in the constructor
public Test()
{
symbolsPresent = new ArrayList<String>();
symbolsPresent.add("ONE");
symbolsPresent.add("TWO");
symbolsPresent.add("THREE");
symbolsPresent.add("FOUR");
}
Edit : It is a choice of course and others prefer to initialize in the declaration. Both are valid, I have choosen the constructor because all type of initialitions are possible there (if you need a loop or parameters, ...). However I initialize the constants in the declaration on the top on the source.
The most important is to follow a rule that you like and be consistent in our classes.
You can also use the varargs syntax to make your code cleaner:
Use the overloaded constructor:
ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c"));
Subclass ArrayList in a utils module:
public class MyArrayList<T> extends ArrayList<T> {
public MyArrayList(T... values) {
super(Arrays.asList(values));
}
}
ArrayList<String> list = new MyArrayList<String>("a", "b", "c");
Or have a static factory method (my preferred approach):
public class Utils {
public static <T> ArrayList<T> asArrayList(T... values) {
return new ArrayList<T>(Arrays.asList(values));
}
}
ArrayList<String> list = Utils.asArrayList("a", "b", "c");
import com.google.common.collect.Lists;
...
ArrayList<String> getSymbolsPresent = Lists.newArrayList("item 1", "item 2");
...
Double brace initialization is an option:
List<String> symbolsPresent = new ArrayList<String>() {{
add("ONE");
add("TWO");
add("THREE");
add("FOUR");
}};
Note that the String
generic type argument is necessary in the assigned expression as indicated by JLS ยง15.9
It is a compile-time error if a class instance creation expression declares an anonymous class using the "<>" form for the class's type arguments.
I would suggest to use Arrays.asList() for single line initialization. For different ways of declaring and initializing a List you can also refer Initialization of ArrayList in Java
try this
new String[] {"One","Two","Three","Four"};
or
List<String> places = Arrays.asList("One", "Two", "Three");
If you just want to initialize outside of any method then use the initializer blocks :
import java.util.ArrayList;
public class Test {
private ArrayList<String> symbolsPresent = new ArrayList<String>();
// All you need is this block.
{
symbolsPresent = new ArrayList<String>();
symbolsPresent.add("ONE");
symbolsPresent.add("TWO");
symbolsPresent.add("THREE");
symbolsPresent.add("FOUR");
}
public ArrayList<String> getSymbolsPresent() {
return symbolsPresent;
}
public void setSymbolsPresent(ArrayList<String> symbolsPresent) {
this.symbolsPresent = symbolsPresent;
}
public static void main(String args[]) {
Test t = new Test();
System.out.println("Symbols Present is" + t.symbolsPresent);
}
}
public static final List<String> permissions = new ArrayList<String>() {{
add("public_profile");
add("email");
add("user_birthday");
add("user_about_me");
add("user_location");
add("user_likes");
add("user_posts");
}};
Java 9 allows you to create an unmodifiable list with a single line of code using List.of
factory:
public class Main {
public static void main(String[] args) {
List<String> examples = List.of("one", "two", "three");
System.out.println(examples);
}
}
Output:
[one, two, three]
I use a generic class that inherit from ArrayList and implement a constructor with a parameter with variable number or arguments :
public class MyArrayList<T> extends ArrayList<T> {
public MyArrayList(T...items){
for (T item : items) {
this.add(item);
}
}
}
Example:
MyArrayList<String>myArrayList=new MyArrayList<String>("s1","s2","s2");
How about using overloaded ArrayList constructor.
private ArrayList<String> symbolsPresent = new ArrayList<String>(Arrays.asList(new String[] {"One","Two","Three","Four"}));
You can use Java 8 Stream API.
You can create a Stream of objects and collect them as a List.
private List<String> symbolsPresent = Stream.of("ONE", "TWO", "THREE", "FOUR")
.collect(Collectors.toList());
Also, if you want to enforce the List to be read-only (throws a UnsupportedOperationException if modified):
List<String> places = Collections.unmodifiableList(Arrays.asList("One", "Two", "Three"));
Source: Stackoverflow.com