Initializing a List in Java

The Java.util.List is a kid interface of Collection. It is an arranged assortment of items wherein copy esteems can be put away. Since List safeguards the addition request, it permits positional access and inclusion of components. List Interface is carried out by ArrayList, LinkedList, Vector and Stack classes.

This Java List Tutorial Explains How to Create, Initialize and Print Lists in Java. The instructional exercise likewise Explains List of Lists with Complete Code Example: This instructional exercise will acquaint you with the information structure ‘list’ which is one of the fundamental constructions in the Java Collection Interface. A rundown in Java is a succession of components as per a request. The List interface of java.util bundle is the one that executes this grouping of items requested in a specific manner called List.

Java program to Create and introduce List in one line

Since we know how to make and instate the rundown at a similar line, how about we see an illustration of how to utilize this stunt in a Java program. Here is a Java program that makes and instates List in one line utilizing Array.

The Arrays.asList() strategy is utilized to introduce List in one line and it takes an Array which you can make at the hour of calling this technique itself. It likewise utilizes Generics to give type-security and this model can be composed utilizing Generics also.

However, the disadvantage is that it returns a decent size ArrayList which implies you can’t add and eliminate components assuming you need. You can defeat that constraint by making one more ArrayList by duplicating values from this rundown utilizing duplicate constructor as displayed beneath.

To become familiar with the Collection and ArrayList class, see Java Fundamentals: Collections seminar on Pluralsight, one of the particular seminar on Collections.

Example

import java.util.List;import java.util.Arrays;

/**
How to create and initialize List in the same line,
* Similar to Array in Java.
* Arrays.asList() method is used to initialize a List
* from Array but List returned by this method is a
* fixed-size List and you can not change its size.
* Which means adding and deleting elements from the
* List is not allowed.
*
* @author Javin Paul
*/
public class ListExample {

public static void main(String args[]) {

//declaring and initializing array in one line
String[] oldValues = new String[] {“list” , “set” , “map”};
String[] values = {“abc”,”bcd”, “def”};

//initializing list with an array in java
List init = Arrays.asList(values);
System.out.println(“size: ” + init.size()
+” list: ” + init);

//initializing List in one line in Java
List oneLiner = Arrays.asList(“one” , “two”, “three”);
System.out.println(“size: ” + init.size()
+” list: ” + oneLiner);

// List returned by Arrays.asList is fixed size
// and doesn’t support add or remove


      // This will throw java.lang.UnsupportedOperationException
      oneLiner.add(“four”);

      // This also throws java.lang.UnsupportedOperationException
      //oneLiner.remove(“one”); 
}
}

Output:
size: 3 list: [abc, bcd, def]
size: 3 list: [one, two, three]
Exception in thread “main” java.lang.UnsupportedOperationException
at java.util.AbstractList.add(AbstractList.java:131)
at java.util.AbstractList.add(AbstractList.java:91)
at test.ExceptionTest.main(ExceptionTest.java:32)

In this quick tutorial, we’ll investigate how to initialize a List using one-liners.

Create From an Array

We can create a List from an array. And thanks to array literals, we can initialize them in one line:

List<String> list = Arrays.asList(new String[]{"foo", "bar"});

We can trust the varargs mechanism to handle the array creation. With that, we can write more concise and readable code:

@Test
public void givenArraysAsList_thenInitialiseList() {
    List<String> list = Arrays.asList("foo", "bar");

    assertTrue(list.contains("foo"));
}

The result instance of this code implements the List interface, but it isn’t a java.util.ArrayList or a LinkedList. Instead, it’s a List backed by the original array, which has two implications that we’ll look at in the rest of this section.

Although the class’s name happens to be ArrayList, it’s in the java.util.Arrays package.

The result instance from Arrays.asList will have a fixed size:

@Test(expected = UnsupportedOperationException.class)
public void givenArraysAsList_whenAdd_thenUnsupportedException() {
    List<String> list = Arrays.asList("foo", "bar");

    list.add("baz");
}

Shared Reference

The original array and the list share the same references to the objects:

@Test
public void givenArraysAsList_whenCreated_thenShareReference(){
    String[] array = {"foo", "bar"};
    List<String> list = Arrays.asList(array);
    array[0] = "baz";
 
    assertEquals("baz", list.get(0));
}

Create From a Stream (Java 8)

We can easily convert a Stream into any kind of Collection.

Therefore, with the factory methods for Streams, we can create and initialize lists in one line:

@Test
public void givenStream_thenInitializeList(){
    List<String> list = Stream.of("foo", "bar")
      .collect(Collectors.toList());
		
    assertTrue(list.contains("foo"));
}

We should note here that Collectors.toList() doesn’t guarantee the exact implementation of the returned List.

There’s no general contract about the mutability, serializability or thread safety of the returned instance. So, our code shouldn’t rely on any of these properties.

Some sources highlight that Stream.of(…).collect(…) may have a larger memory and performance footprint than Arrays.asList(). But in almost all cases, it’s such a micro-optimization that there is little difference.

Factory Methods (Java 9)

JDK 9 introduces several convenient factory methods for collections:

List<String> list = List.of("foo", "bar", "baz");
Set<String> set = Set.of("foo", "bar", "baz");

One important detail is that the returned instances are immutable. Beyond that, the factory methods have several advantages in space efficiency and thread safety.

Double-Brace Initialization

In several places, we can find a method called double-brace initialization, which looks like this:

@Test
public void givenAnonymousInnerClass_thenInitialiseList() {
    List<String> cities = new ArrayList() {{
        add("New York");
        add("Rio");
        add("Tokyo");
    }};

    assertTrue(cities.contains("New York"));
}

The name “double-brace initialization” is quite misleading. While the syntax may look compact and elegant, it dangerously hides what is going on under the hood.

There isn’t actually a double-brace syntax element in Java; those are two blocks formatted intentionally this way.

With the outer braces, we declare an anonymous inner class that will be a subclass of the ArrayList. We can declare the details of our subclass inside these braces.

As usual, we can use instance initializer blocks, and that is where the inner pair of braces comes from.

The brevity of this syntax is tempting. However, it’s considered an anti-pattern.

To read more about double-brace initialization, have a look at our article here.

Conclusion

Modern Java offers several options to create a Collection in one line. The method we choose is almost entirely down to personal preference rather than technical reasoning.

Also Read: How to create a link in JavaScript ?

Leave a Reply

Your email address will not be published.