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?

3

13 Answers

try this

new String[] {"One","Two","Three","Four"};

or

List<String> places = Arrays.asList("One", "Two", "Three");

ARRAYS

4

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.

7

How about using overloaded ArrayList constructor.

 private ArrayList<String> symbolsPresent = new ArrayList<String>(Arrays.asList(new String[] {"One","Two","Three","Four"}));
4

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"); ...

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());
1
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]

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.

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"));

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

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");

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); } }