How to convert array to List in Java? (code example)

Sometimes we need to convert the array type into a collection type, because the latter is a more powerful data structure, and java.util.List has many functions that ordinary arrays do not support. For example: we can easily detect whether the list contains a specific value through List's built-in method. Here are some examples of how to convert an array to a list.

##Convert Array to List through java.util.Arrays.asList()## The #Arrays class has a convenient method asList, which can help with conversion tasks. The following is the syntax:

public static <T> List<T> asList(T... a)

Note: The parameters do not have to be arrays, variable parameters can also be used. It can create a lis

public class Test {
   public static void main(String[] args) {
      List<string> myList = Arrays.asList("Apple");
   }
}</string>

The above code will create a collection containing an element "Apple". We can also do this:

public class Test {
   public static void main(String[] args) {
      List<string> myList = Arrays.asList("Apple", "Orange");
   }
}</string>

This will generate a set containing two elements "Apple", "Orange"

Because this is a variable parameter. We can pass an array, and the array elements are recognized as parameters. Example:

public class Test {
   public static void main(String[] args) {
      String[] myArray = { "Apple", "Banana", "Orange" };
      List<string> myList = Arrays.asList(myArray);
      for (String str : myList) {
         System.out.println(str);
      }
   }
}</string>

In this way, a String collection is created. The array myArray is added. The myList collection has three elements. The following is the output:

Apple
Banana
Orange

trapThere are some problems with this method. The array passed in must be an object. array, not an array of primitive types. For example:

public class Test {
   public static void main(String[] args) {
      int[] myArray = { 1, 2, 3 };
      List myList = Arrays.asList(myArray);
      System.out.println(myList.size());
   }
}

The code output is 1. why? Because the asList method expects a variadic parameter of an object, but the parameter passed in is an array of primitive types, it creates an array collection. So the only element of this collection is myArray. Therefore

myList.get(0)

will return the same object as myArray.

The object created by asList() is of fixed size The list object returned by the asList() method is of fixed size and cannot accommodate more There are many elements, for example:

public class Test {
   public static void main(String[] args) {
      String[] myArray = { "Apple", "Banana", "Orange" };
      List<string> myList = Arrays.asList(myArray);
      myList.add("Guava");
   }
}</string>

The output is as follows:

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.AbstractList.add(AbstractList.java:148)
    at java.util.AbstractList.add(AbstractList.java:108)
    at Test.main(Test.java:8)

Because myList has a fixed length, more elements cannot be added.

Because the List object returned by this method is not the ArrayList under the java.util package, but the ArrayList type inside Arrays. The class does not implement the add, revmove, and clear methods, so any call to modify the collection structure will fail.

Convert the basic array type to ListAs mentioned above. Passing an array of basic types to the asList method does not work. A solution without introducing a third-party library is to pass the Java8 stream. The example is as follows:

public class Test {
   public static void main(String[] args) {
      int[] intArray = { 5, 10, 21 };
      List myList = Arrays.stream(intArray).boxed()
            .collect(Collectors.toList());
   }
}

Each element of the array is converted from int to Integer type (boxing), the array is converted to List type.

Convert the array into a List that allows adding elementsAs mentioned in the trap section above, the Arrays.asList() method does not support adding Or remove the element. If you don't want to do this, here are the alternatives:

public class Test {
   public static void main(String[] args) {
      String[] myArray = { "Apple", "Banana", "Orange" };
      List<string> myList = new ArrayList<string>(Arrays.asList(myArray));
      myList.add("Guava");
   }
}</string></string>

This code explicitly creates a new ArrayList object and then adds the results of Arrays.asList to it. Because we created an ArrayList. So no removal restrictions are added, and there are four elements before the execution of the above code ends. Don't expect your code to throw exceptions when executing.

Convert Array group to List by yourself Sometimes it is better to use our own implementation solution to solve the problem. The following is a simple example of converting a java array into a List:

public class Test {
   public static void main(String[] args) {
      String[] myArray = { "Apple", "Banana", "Orange" };
      List<string> myList = new ArrayList<string>();
      for (String str : myArray) {
         myList.add(str);
      }
      System.out.println(myList.size());
   }
}</string></string>

The expected output of the code is 3. Because the collection has 3 elements after the logic is executed.

The downside of our code is that it is longer and we are reinventing the wheel. The benefit is that we can adapt and customize as our needs change. For example: In the following code, each element is added to the list twice

public class Test {
   public static void main(String[] args) {
      String[] myArray = { "Apple", "Banana", "Orange" };
      List<string> myList = new ArrayList<string>();
      for (String str : myArray) {
         myList.add(str);
         myList.add(str);
      }
      System.out.println(myList.size());
   }
}</string></string>

The output is 6, because all elements in the array are added twice. Here is another example of converting a String array to a List:

public class Test {
   public static void main(String[] args) {
      String[] myArray = { "5", "6", "7" };
      List<Integer> myList = new ArrayList<Integer>();
      for (String str : myArray) {
         myList.add(Integer.valueOf(str));
      }
   }}

Parses each String in the array and converts it to the corresponding Integer. The resulting list will contain all converted integers.

Recommended learning:

java video tutorial

The above is the detailed content of How to convert array to List in Java? (code example). For more information, please follow other related articles on the PHP Chinese website!