Immutable List in Java

Course Curriculum

Immutable List in Java

Immutable List in Java

  • ImmutableList, as suggested by the name, is a type of List which is immutable. It means that the content of the List are fixed or constant after declaration, that is, they are read-only.
  • If any attempt made to add, delete and update elements in the List, UnsupportedOperationException is thrown.
    An ImmutableList does not allow null element either.
  • If any attempt made to create an ImmutableList with null element, NullPointerException is thrown. If any
  • attempt is made to add null element in List, UnsupportedOperationException is thrown.

Advantages of ImmutableList

  • They are thread safe.
  • They are memory efficient.
  • Since they are immutable, hence they can be passed over to third party libraries without any problem.
  • Note that it is an immutable collection, not collection of immutable objects, so the objects inside it can be modified.

Class Declaration:

@GwtCompatible(serializable=true,
emulated=true)
public abstract class ImmutableList
extends ImmutableCollection
implements List, RandomAccess
Class hierarchy:

java.lang.Object
↳ java.util.AbstractCollection
↳ com.google.common.collect.ImmutableCollection
↳ com.google.common.collect.ImmutableList
Creating ImmutableList
ImmutableList can be created by various methods. These include:

From existing List using copyOf() function of Guava

// Below is the Java program to create ImmutableList

import com.google.common.collect.ImmutableList;
import java.util.*;

class P_AI {

// Function to create ImmutableList from List
public static <T> void iList(List<T> list)
{
// Create ImmutableMap from Map using copyOf()
ImmutableList<T> immutableList =
ImmutableList.copyOf(list);

// Print the ImmutableMap
System.out.println(immutableList);
}

public static void main(String[] args)
{
List<String> list = new ArrayList<>(
Arrays.asList("Prutor", "Ai", "Prutor"));

iList(list);
}
}
result:

[Prutor, Ai, Prutor]
New ImmutableList using of() function from Guava

// Below is the Java program to create ImmutableList

import com.google.common.collect.ImmutableList;
import java.util.*;

class P_AI {

// Function to create ImmutableList
public static void iList()
{
// Create ImmutableList using of()
ImmutableList<String> immutableList =
ImmutableList.of("Prutor", "Ai", "Prutor");

// Print the ImmutableMap
System.out.println(immutableList);
}

public static void main(String[] args)
{
iList();
}
}
result:

[Prutor, Ai, Prutor]
Using Java 9 Factory Of() method
In Java, use of() with Set, Map or List to create an Immutable List.

Please Note: The programs below are of Java 9. Hence you would need a Java 9 compiler to run them.

// Java code illustrating of() method to
// create a ImmutableSet
import java.util.*;
import com.google.common.collect.ImmutableList;

class P_AI {
public static void main(String args[])
{
// non-empty immutable set
List<String> list = List.of("Prutor", "Ai", "Prutor");

// Let's print the list
System.out.println(list);
}
}
result:

[Prutor, Ai, Prutor]

Using Builder() from ImmutableList
In Guava, ImmnutableList class provides a function Builder(). Through this function, a new ImmutableList can be created, or
an ImmutableList can be created from an existing List or both.

Creating a new ImmutableList

// Java code illustrating of() method to
// create a ImmutableList
import java.util.*;
import com.google.common.collect.ImmutableList;

class P_AI {
public static void main(String args[])
{
// non-empty immutable set
ImmutableList<String> iList = ImmutableList.<String>builder()
.add("Prutor", "Ai", "Prutor")
.build();

// Let's print the List
System.out.println(iList);
}
}
result:

[Prutor, Ai, Prutor]
Creating an ImmutableList from existing List

// Java code illustrating of() method to
// create a ImmutableList
import java.util.*;
import com.google.common.collect.ImmutableList;

class P_AI {
public static void main(String args[])
{
// non-empty immutable set
List<String> list = List.of("Prutor", "Ai", "Prutor");
ImmutableList<String> iList = ImmutableList.<String>builder()
.addAll(list)
.build();

// Let's print the List
System.out.println(iList);
}
}
result:

[Prutor, Ai, Prutor]
Creating a new ImmutableList including the existing List

// Java code illustrating of() method to
// create a ImmutableList
import java.util.*;
import com.google.common.collect.ImmutableList;

class P_AI {
public static void main(String args[])
{
// non-empty immutable set
List<String> list = List.of("Prutor", "Ai", "Prutor");
ImmutableList<String> iList = ImmutableList.<String>builder()
.addAll(list)
.add("Computer", "Portal", )
.build();

// Let's print the set
System.out.println(iList);
}
}
result:

[Prutor, Ai, Prutor, Computer, Portal]

Try to change ImmutableList

As mentioned earlier, the below program will throw UnsupportedOperationException.

// Java code to show that UnsupportedOperationException
// will be thrown when ImmutableList is modified.
import java.util.*;

class P_AI {
public static void main(String args[])
{
// empty immutable map
List<String> list = List.of();

// Lets try adding element in List
List.add("Prutor");
}
}
Output :

Exception in thread "main" java.lang.UnsupportedOperationException
at com.google.common.collect.ImmutableCollection.add(ImmutableCollection.java:218)
at ImmutableListDemo.main(Main.java:16)

How is it different from Collections.unmodifiableList()?

Collections.unmodifiableList creates a wrapper around the same existing List such that the wrapper cannot be used to modify it. However we can still change original List.

// Java program to demonstrate that a List created using
// Collections.unmodifiableList() can be modified indirectly.
import java.io.*;
import java.util.*;

class P_AI {
public static void main(String[] args)
{
List<String> list = new ArrayList<>();
list.add("Prutor");

// Create ImmutableList from List using copyOf()
List<String> iList = Collections.unmodifiableList(list);

// We change List and the changes reflect in iList.
list.add("Ai");
list.add("Prutor");

System.out.println(iList);
}
}

result:

[Prutor, Ai, Prutor]

If we create an ImmutableList from an existing List and change the existing List, the ImmutableList does not change because a copy is created.

// Below is a Java program for
// Creating an immutable List using copyOf()
// and modifying original List.
import java.io.*;
import java.util.*;
import com.google.common.collect.ImmutableList;

class P_AI {
public static void main(String[] args)
{
List<String> list = new ArrayList<>();
list.add("Prutor");

// Create ImmutableList from List using copyOf()
ImmutableList<String> iList = ImmutableList.copyOf(list);

// We change List and the changes wont reflect in iList.
list.add("Ai");
list.add("Prutor");

System.out.println(iList);
}
}
Output :

[Prutor]

 

(Next Lesson) How to start learning Java