Initialization of an ArrayList in one line
JavaCollectionsArraylistInitializationJava Problem Overview
I wanted to create a list of options for testing purposes. At first, I did this:
ArrayList<String> places = new ArrayList<String>();
places.add("Buenos Aires");
places.add("Córdoba");
places.add("La Plata");
Then, I refactored the code as follows:
ArrayList<String> places = new ArrayList<String>(
Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));
Is there a better way to do this?
Java Solutions
Solution 1 - Java
It would be simpler if you were to just declare it as a List
- does it have to be an ArrayList?
List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");
Or if you have only one element:
List<String> places = Collections.singletonList("Buenos Aires");
This would mean that places
is immutable (trying to change it will cause an UnsupportedOperationException
exception to be thrown).
To make a mutable list that is a concrete ArrayList
you can create an ArrayList
from the immutable list:
ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));
Solution 2 - Java
Actually, probably the "best" way to initialize the ArrayList
is the method you wrote, as it does not need to create a new List
in any way:
ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
The catch is that there is quite a bit of typing required to refer to that list
instance.
There are alternatives, such as making an anonymous inner class with an instance initializer (also known as an "double brace initialization"):
ArrayList<String> list = new ArrayList<String>() {{
add("A");
add("B");
add("C");
}};
However, I'm not too fond of that method because what you end up with is a subclass of ArrayList
which has an instance initializer, and that class is created just to create one object -- that just seems like a little bit overkill to me.
What would have been nice was if the Collection Literals proposal for Project Coin was accepted (it was slated to be introduced in Java 7, but it's not likely to be part of Java 8 either.):
List<String> list = ["A", "B", "C"];
Unfortunately it won't help you here, as it will initialize an immutable List
rather than an ArrayList
, and furthermore, it's not available yet, if it ever will be.
Solution 3 - Java
The simple answer
Java 9 or later:
List<String> strings = List.of("foo", "bar", "baz");
This will give you an immutable List
, so it cannot be changed.
Which is what you want in most cases where you're prepopulating it.
Java 8 or earlier:
List<String> strings = Arrays.asList("foo", "bar", "baz");
This will give you a List
* backed by an array, so it cannot change length.
But you can call List.set(...)
, so it's still mutable.
*
Implementation detail: It's a private nested class inside java.util.Arrays
, named ArrayList
,
which is a different class from java.util.ArrayList
, even though their simple names are the same.
Static import
You can make Java 8 Arrays.asList
even shorter with a static import:
import static java.util.Arrays.asList;
...
List<String> strings = asList("foo", "bar", "baz");
Any modern IDE* will suggest and do this for you.
I don't recommend statically importing the List.of
method as just of
, because it's confusing.
*
For example, in IntelliJ IDEA you press Alt+Enter
and select Static import method...
Stream
s
Using Why does it have to be a List
?
With Java 8 or later you can use a Stream
which is more flexible:
Stream<String> strings = Stream.of("foo", "bar", "baz");
You can concatenate Stream
s:
Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
Stream.of("baz", "qux"));
Or you can go from a Stream
to a List
:
import static java.util.stream.Collectors.toList;
...
var strings = Stream.of("foo", "bar", "baz").toList(); // Java 16
List<String> strings = Stream.of("foo", "bar", "baz").collect(toList()); // Java 8
But preferably, just use the Stream
without collecting it to a List
.
java.util.ArrayList
*
If you specifically need a If you want to both prepopulate an ArrayList
and add to it afterwards, use
List<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");
or in Java 8 or earlier:
List<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");
or using Stream
:
import static java.util.stream.Collectors.toCollection;
List<String> strings = Stream.of("foo", "bar")
.collect(toCollection(ArrayList::new));
strings.add("baz");
But again, it's better to just use the Stream
directly instead of collecting it to a List
.
*You probably don't need specifically an ArrayList
. To quote JEP 269:
> There is a small set of use cases for initializing a mutable collection instance with a predefined set of values. It's usually preferable to have those predefined values be in an immutable collection, and then to initialize the mutable collection via a copy constructor.
(emphasis mine)
Program to interfaces, not to implementations
You said you've declared the list as an ArrayList
in your code, but you should only do that if you're using some member of ArrayList
that's not in List
.
Which you are most likely not doing.
Usually you should just declare variables by the most general interface that you are going to use (e.g. Iterable
, Collection
, or List
), and initialize them with the specific implementation (e.g. ArrayList
, LinkedList
or Arrays.asList()
).
Otherwise you're limiting your code to that specific type, and it'll be harder to change when you want to.
For example, if you're passing an ArrayList
to a void method(...)
:
// Iterable if you just need iteration, for (String s : strings):
void method(Iterable<String> strings) {
for (String s : strings) { ... }
}
// Collection if you also need .size(), .isEmpty(), or .stream():
void method(Collection<String> strings) {
if (!strings.isEmpty()) { strings.stream()... }
}
// List if you also need random access, .get(index):
void method(List<String> strings) {
strings.get(...)
}
// Don't declare a specific list implementation
// unless you're sure you need it:
void method(ArrayList<String> strings) {
??? // You don't want to limit yourself to just ArrayList
}
Another example would be always declaring variable an InputStream
even though it is usually a FileInputStream
or a BufferedInputStream
, because one day soon you or somebody else will want to use some other kind of InputStream
.
Solution 4 - Java
If you need a simple list of size 1:
List<String> strings = new ArrayList<String>(Collections.singletonList("A"));
If you need a list of several objects:
List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");
Solution 5 - Java
With Guava you can write:
ArrayList<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");
In Guava there are also other useful static constructors. You can read about them here.
Solution 6 - Java
With [tag:java-9] and above, as suggested in JEP 269: Convenience Factory Methods for Collections, this could be achieved using collection literals now with -
List<String> list = List.of("A", "B", "C");
Set<String> set = Set.of("A", "B", "C");
A similar approach would apply to Map
as well -
Map<String, String> map = Map.of("k1", "v1", "k2", "v2", "k3", "v3")
which is similar to Collection Literals proposal as stated by @coobird. Further clarified in the JEP as well -
Alternatives
> Language changes have been considered several times, and rejected: > > Project Coin Proposal, 29 March 2009 > > Project Coin Proposal, 30 March 2009 > > JEP 186 discussion on lambda-dev, January-March 2014 > > The language > proposals were set aside in preference to a library-based proposal as > summarized in this message.
Solution 7 - Java
Collection literals didn't make it into Java 8, but it is possible to use the Stream API to initialize a list in one rather long line:
List<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toList());
If you need to ensure that your List
is an ArrayList
:
ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new));
Solution 8 - Java
import com.google.common.collect.ImmutableList;
....
List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
Solution 9 - Java
You could create a factory method:
public static ArrayList<String> createArrayList(String ... elements) {
ArrayList<String> list = new ArrayList<String>();
for (String element : elements) {
list.add(element);
}
return list;
}
....
ArrayList<String> places = createArrayList(
"São Paulo", "Rio de Janeiro", "Brasília");
But it's not much better than your first refactoring.
For greater flexibility, it can be generic:
public static <T> ArrayList<T> createArrayList(T ... elements) {
ArrayList<T> list = new ArrayList<T>();
for (T element : elements) {
list.add(element);
}
return list;
}
Solution 10 - Java
In Java 9 we can easily initialize an ArrayList
in a single line:
List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");
or
List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));
This new approach of Java 9 has many advantages over the previous ones:
See this post for more details -> What is the difference between List.of and Arrays.asList?
Solution 11 - Java
Simply use below code as follows.
List<String> list = new ArrayList<String>() {{
add("A");
add("B");
add("C");
}};
Solution 12 - Java
About the most compact way to do this is:
Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);
Solution 13 - Java
With Eclipse Collections you can write the following:
List<String> list = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");
You can also be more specific about the types and whether they are Mutable or Immutable.
MutableList<String> mList = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableList<String> iList = Lists.immutable.with("Buenos Aires", "Córdoba", "La Plata");
You can also do the same with Sets and Bags:
Set<String> set = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableSet<String> mSet = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet<String> iSet = Sets.immutable.with("Buenos Aires", "Córdoba", "La Plata");
Bag<String> bag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableBag<String> mBag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableBag<String> iBag = Bags.immutable.with("Buenos Aires", "Córdoba", "La Plata");
Note: I am a committer for Eclipse Collections.
Solution 14 - Java
Here is another way:
List<String> values = Stream.of("One", "Two").collect(Collectors.toList());
Solution 15 - Java
(Should be a comment, but too long, so new reply). As others have mentioned, the Arrays.asList
method is fixed size, but that's not the only issue with it. It also doesn't handle inheritance very well. For instance, suppose you have the following:
class A{}
class B extends A{}
public List<A> getAList(){
return Arrays.asList(new B());
}
The above results in a compiler error, because List<B>
(which is what is returned by Arrays.asList) is not a subclass of List<A>
, even though you can add Objects of type B to a List<A>
object. To get around this, you need to do something like:
new ArrayList<A>(Arrays.<A>asList(b1, b2, b3))
This is probably the best way to go about doing this, esp. if you need an unbounded list or need to use inheritance.
Solution 16 - Java
You can use the below statements:
Code Snippet:
String [] arr = {"Sharlock", "Homes", "Watson"};
List<String> names = Arrays.asList(arr);
Solution 17 - Java
Like Tom said:
List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");
But since you complained of wanting an ArrayList, you should firstly know that ArrayList is a subclass of List and you could simply add this line:
ArrayList<String> myPlaces = new ArrayList(places);
Although, that might make you complain of 'performance'.
In that case it doesn't make sense to me, why, since your list is predefined it wasn't defined as an array (since the size is known at time of initialisation). And if that's an option for you:
String[] places = {"Buenos Aires", "Córdoba", "La Plata"};
In case you don't care of the minor performance differences then you can also copy an array to an ArrayList very simply:
ArrayList<String> myPlaces = new ArrayList(Arrays.asList(places));
Okay, but in future you need a bit more than just the place name, you need a country code too. Assuming this is still a predefined list which will never change during run-time, then it's fitting to use an enum
set, which would require re-compilation if the list needed to be changed in the future.
enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}
would become:
enum Places {
BUENOS_AIRES("Buenos Aires",123),
CORDOBA("Córdoba",456),
LA_PLATA("La Plata",789);
String name;
int code;
Places(String name, int code) {
this.name=name;
this.code=code;
}
}
Enum's have a static values
method that returns an array containing all of the values of the enum in the order they are declared, e.g.:
for (Places p:Places.values()) {
System.out.printf("The place %s has code %d%n",
p.name, p.code);
}
In that case I guess you wouldn't need your ArrayList.
P.S. Randyaa demonstrated another nice way using the static utility method Collections.addAll.
Solution 18 - Java
Java 9 has the following method to create an immutable list:
List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");
which is easily adapted to create a mutable list, if required:
List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));
Similar methods are available for Set
and Map
.
Solution 19 - Java
List<String> names = Arrays.asList("2","@2234","21","11");
Solution 20 - Java
Yes with the help of Arrays you can initialize array list in one line,
List<String> strlist= Arrays.asList("aaa", "bbb", "ccc");
Solution 21 - Java
You can use StickyList
from Cactoos:
List<String> names = new StickyList<>(
"Scott Fitzgerald", "Fyodor Dostoyevsky"
);
Solution 22 - Java
Try with this code line:
Collections.singletonList(provider)
Solution 23 - Java
Using Arrays.asList("Buenos Aires", "Córdoba", "La Plata");
is correct. but Any calls to Arrays.asList()
with zero arguments or only one argument could be replaced with either a call to Collections.singletonList()
or Collections.emptyList()
which will save some memory.
Note: the list returned by Collections.singletonList()
is immutable, while the list returned Arrays.asList()
allows calling the set() method. This may break the code in rare cases.
Solution 24 - Java
In Java, you can't do
ArrayList<String> places = new ArrayList<String>( Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));
As was pointed out, you'd need to do a double brace initialization:
List<String> places = new ArrayList<String>() {{ add("x"); add("y"); }};
But this may force you into adding an annotation @SuppressWarnings("serial")
or generate a serial UUID which is annoying. Also most code formatters will unwrap that into multiple statements/lines.
Alternatively you can do
List<String> places = Arrays.asList(new String[] {"x", "y" });
but then you may want to do a @SuppressWarnings("unchecked")
.
Also according to javadoc you should be able to do this:
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
But I'm not able to get it to compile with JDK 1.6.
Solution 25 - Java
Collections.singletonList(messageBody)
If you'd need to have a list of one item!
Collections is from java.util package.
Solution 26 - Java
The best way to do it:
package main_package;
import java.util.ArrayList;
public class Stackkkk {
public static void main(String[] args) {
ArrayList<Object> list = new ArrayList<Object>();
add(list, "1", "2", "3", "4", "5", "6");
System.out.println("I added " + list.size() + " element in one line");
}
public static void add(ArrayList<Object> list,Object...objects){
for(Object object:objects)
list.add(object);
}
}
Just create a function that can have as many elements as you want and call it to add them in one line.
Solution 27 - Java
Here is code by AbacusUtil
// ArrayList
List<String> list = N.asList("Buenos Aires", "Córdoba", "La Plata");
// HashSet
Set<String> set = N.asSet("Buenos Aires", "Córdoba", "La Plata");
// HashMap
Map<String, Integer> map = N.asMap("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);
// Or for Immutable List/Set/Map
ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);
// The most efficient way, which is similar with Arrays.asList(...) in JDK.
// but returns a flexible-size list backed by the specified array.
List<String> set = Array.asList("Buenos Aires", "Córdoba", "La Plata");
Declaration: I'm the developer of AbacusUtil.
Solution 28 - Java
interestingly no one-liner with the other overloaded Stream::collect
method is listed
ArrayList<String> places = Stream.of( "Buenos Aires", "Córdoba", "La Plata" ).collect( ArrayList::new, ArrayList::add, ArrayList::addAll );
Solution 29 - Java
For me Arrays.asList() is the best and convenient one. I always like to initialize that way. If you are a beginner into Java Collections then I would like you to refer ArrayList initialization
Solution 30 - Java
Why not make a simple utility function that does this?
static <A> ArrayList<A> ll(A... a) {
ArrayList l = new ArrayList(a.length);
for (A x : a) l.add(x);
return l;
}
"ll
" stands for "literal list".
ArrayList<String> places = ll("Buenos Aires", "Córdoba", "La Plata");
Solution 31 - Java
Simplest way : you can use this approach to add multiple elements to any type of collection like ArrayList and HashSet
ArrayList<String> allViews = new ArrayList<String>();
Collections.addAll(allViews,"hello","world","abc","def","ghi");
Solution 32 - Java
Actually, it's possible to do it in one line:
Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})
Solution 33 - Java
public static <T> List<T> asList(T... a) {
return new ArrayList<T>(a);
}
This is the implementation of Arrays.asList
, so you could go with
ArrayList<String> arr = (ArrayList<String>) Arrays.asList("1", "2");