Tutorial :How to make a new List in Java


We create a Set as:

Set myset = new HashSet()  

How do we create a List in Java?


List myList = new ArrayList();  

or with generics (Java 8 or later)

List<MyType> myList = new ArrayList<>();  

or with generics (Old java versions)

List<MyType> myList = new ArrayList<MyType>();  


Additionally, if you want to create a list that has things in it (though it will be fixed size):

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");  


Let me summarize and add something:


1. new ArrayList<String>();  2. Arrays.asList("A", "B", "C")  


1. Lists.newArrayList("Mike", "John", "Lesly");  2. Lists.asList("A","B", new String [] {"C", "D"});  

Immutable List

1. Collections.unmodifiableList(new ArrayList<String>(Arrays.asList("A","B")));  2. ImmutableList.builder()                                      // Guava              .add("A")              .add("B").build();  3. ImmutableList.of("A", "B");                                  // Guava  4. ImmutableList.copyOf(Lists.newArrayList("A", "B", "C"));     // Guava  

Empty immutable List

1. Collections.emptyList();  2. Collections.EMPTY_LIST;  

List of Characters

1. Lists.charactersOf("String")                                 // Guava  2. Lists.newArrayList(Splitter.fixedLength(1).split("String"))  // Guava  

List of Integers

Ints.asList(1,2,3);                                             // Guava  


First read this, then read this and this. 9 times out of 10 you'll use one of those two implementations.

In fact, just read Sun's Guide to the Collections framework.


//simple example creating a list form a string array    String[] myStrings = new String[] {"Elem1","Elem2","Elem3","Elem4","Elem5"};    List mylist = Arrays.asList(myStrings );    //getting an iterator object to browse list items    Iterator itr= mylist.iterator();    System.out.println("Displaying List Elements,");    while(itr.hasNext())      System.out.println(itr.next());  


Since Java 7 you have type inference for generic instance creation, so there is no need to duplicate generic parameters on the right hand side of the assignment:

List<String> list = new ArrayList<>();  

A fixed-size list can be defined as:

List<String> list = Arrays.asList("foo", "bar");  

For immutable lists you can use the Guava library:

List<String> list = ImmutableList.of("foo", "bar");  


List is just an interface just as Set.

Like HashSet is an implementation of a Set which has certain properties in regards to add / lookup / remove performance, ArrayList is the bare implementation of a List.

If you have a look at the documentation for the respective interfaces you will find "All Known Implementing Classes" and you can decide which one is more suitable for your needs.

Chances are that it's ArrayList.


List is an interface like Set and has ArrayList and LinkedList as general purpose implementations.

We can create List as:

 List<String> arrayList = new ArrayList<>();   List<String> linkedList = new LinkedList<>();   

We can also create a fixed-size list as:

List<String> list = Arrays.asList("A", "B", "C");  

We would almost always be using ArrayList opposed to LinkedList implementation:

  1. LinkedList uses a lot of space for objects and performs badly when we have lots of elements.
  2. Any indexed operation in LinkedList requires O(n) time compared to O(1) in ArrayList.
  3. Check this link for more information.


In Java 8

To create a non-empty list of fixed size (operations like add, remove, etc., are not supported):

List<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported  

To create a non-empty mutable list:

List<Integer> list = new ArrayList<>(Arrays.asList(3, 4));  

In Java 9

Using a new List.of(...) static factory methods:

List<Integer> immutableList = List.of(1, 2);    List<Integer> mutableList = new ArrayList<>(List.of(3, 4));  

And follow best practices...

Don't use raw types

Since Java 5, generics have been a part of the language - you should use them:

List<String> list = new ArrayList<>(); // Good, List of String    List list = new ArrayList(); // Bad, don't do that!  

Program to interfaces

For example, program to the List interface:

List<Double> list = new ArrayList<>();  

Instead of:

ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!  


List list = new ArrayList();  

Or with generics

List<String> list = new ArrayList<String>();  

You can, of course, replace string with any type of variable, such as Integer, also.


Sometimes - but only very rarely - instead of a new ArrayList, you may want a new LinkedList. Start out with ArrayList and if you have performance problems and evidence that the list is the problem, and a lot of adding and deleting to that list - then - not before - switch to a LinkedList and see if things improve. But in the main, stick with ArrayList and all will be fine.


One example:

List somelist = new ArrayList();  

You can look at the javadoc for List and find all known implementing classes of the List interface that are included with the java api.


Using Google Collections, you could use the following methods in the Lists class

import com.google.common.collect.Lists;    // ...    List<String> strings = Lists.newArrayList();    List<Integer> integers = Lists.newLinkedList();  

There are overloads for varargs initialization and initialising from an Iterable<T>.

The advantage of these methods is that you don't need to specify the generic parameter explicitly as you would with the constructor - the compiler will infer it from the type of the variable.


List<Object> nameOfList = new ArrayList<Object>();  

You need to import List and ArrayList.


List arrList = new ArrayList();  

Its better you use generics as suggested below:

List<String> arrList = new ArrayList<String>();    arrList.add("one");  

Incase you use LinkedList.

List<String> lnkList = new LinkedList<String>();  


There are many ways to create a Set and a List. HashSet and ArrayList are just two examples. It is also fairly common to use generics with collections these days. I suggest you have a look at what they are

This is a good introduction for java's builtin collections. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html


As an option you can use double brace initialization:

List<String> list = new ArrayList<String>(){{  add("a");  add("b");  }};  


More options to do the same thing with Java 8, not better, not worse, just different and if you want to do some extra work with the lists, Streams will provide you more alternatives (filter, map, reduce, etc.)

List<String> listA = Stream.of("a", "B", "C").collect(Collectors.toList());  List<Integer> listB = IntStream.range(10, 20).boxed().collect(Collectors.toList());  List<Double> listC = DoubleStream.generate(() -> { return new Random().nextDouble(); }).limit(10).boxed().collect(Collectors.toList());  LinkedList<Integer> listD = Stream.iterate(0, x -> x++).limit(10).collect(Collectors.toCollection(LinkedList::new));  


Using Eclipse Collections you can create a List like this:

List<String> list1 = Lists.mutable.empty();  List<String> list2 = Lists.mutable.of("One", "Two", "Three");  

If you want an immutable list:

ImmutableList<String> list3 = Lists.immutable.empty();  ImmutableList<String> list4 = Lists.immutable.of("One", "Two", "Three");  

You can avoid auto-boxing by using primitive lists. Here's how you'd create int lists:

MutableIntList list5 = IntLists.mutable.empty();  MutableIntList list6 = IntLists.mutable.of(1, 2, 3);    ImmutableIntList list7 = IntLists.immutable.empty();  ImmutableIntList list8 = IntLists.immutable.of(1, 2, 3);  

There are variants for all 8 primitives.

MutableLongList longList       = LongLists.mutable.of(1L, 2L, 3L);  MutableCharList charList       = CharLists.mutable.of('a', 'b', 'c');  MutableShortList shortList     = ShortLists.mutable.of((short) 1, (short) 2, (short) 3);  MutableByteList byteList       = ByteLists.mutable.of((byte) 1, (byte) 2, (byte) 3);  MutableBooleanList booleanList = BooleanLists.mutable.of(true, false);  MutableFloatList floatList     = FloatLists.mutable.of(1.0f, 2.0f, 3.0f);  MutableDoubleList doubleList   = DoubleLists.mutable.of(1.0, 2.0, 3.0);  

Note: I am a committer for Eclipse Collections.


With Java 9, you are able to do the following to create an immutable List:

List<Integer> immutableList = List.of(1, 2, 3, 4, 5);    List<Integer> mutableList = new ArrayList<>(immutableList);  


The following are some ways you can create lists.

  • This will create a list with fixed size, adding/removing elements is not possible, it will throw a java.lang.UnsupportedOperationException if you try to do so.

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});

  • The following version is a simple list where you can add/remove any number of elements.

    List<String> list = new ArrayList<>();

  • This is how to create a LinkedList in java, If you need to do frequent insertion/deletion of elements on the list, you should use LinkedList instead of ArrayList

    List<String> linkedList = new LinkedList<>();


Try this:

List<String> messages = Arrays.asList("bla1", "bla2", "bla3");  


List<String> list1 = Lists.mutable.empty(); // Empty  List<String> list2 = Lists.mutable.of("One", "Two", "Three");  

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Next Post »