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?

10/5/2019 9:57:47 AM

Accepted Answer

List myList = new ArrayList();

or with generics (Java 7 or later)

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

or with generics (Old java versions)

List<MyType> myList = new ArrayList<MyType>();
6/14/2018 2:28:21 PM

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
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

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

In Java 10

Using the Local Variable Type Inference:

var list1 = List.of(1, 2);

var list2 = new ArrayList<>(List.of(3, 4));

var list3 = new ArrayList<String>();

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!

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



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

Licensed under: CC-BY-SA with attribution
Not affiliated with: Stack Overflow
Email: [email protected]