单行列表初始化

原文：https://www.studytonight.com/java-examples/list-initialization-in-a-single-line

列表是 Java 中的一个接口，由ArrayList和LinkedList这样的类来实现。列表接口实现了集合接口。

在本教程中，我们将学习一些在 Java 中初始化列表的单行代码。

Arrays.asList()方法

我们可以使用 asList()方法从数组创建一个列表。这个方法可以取 varargs ，所以我们甚至不需要数组来初始化列表。我们可以直接将元素传递给这个方法。

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

public class Demo
{
    public static void main(String[] args)
    {
        List<String> listOfStrings = Arrays.asList("Justin", "Jessica", "Simon", "Harry");
        System.out.print(listOfStrings);
    }
}

【贾斯汀、杰西卡、西蒙、哈利】

此方法返回的实例是由输入数组支持的列表。这使得初始化后的列表大小固定，我们无法在其中添加更多的元素。如果我们试图添加一个元素，那么我们将得到一个不支持操作异常。下面的代码演示了这个场景。

import java.util.Arrays;
import java.util.List;
public class Demo
{
    public static void main(String[] args)
    {
        List<String> listOfStrings = Arrays.asList("Justin", "Jessica", "Simon", "Harry");
        listOfStrings.add("Victor");//Error
    }
}

线程“main”Java . lang . unsupportedoperationexception 在 Java . base/Java . util . abstract list . add(abstract list . Java:153) 在 Java . base/Java . util . abstract list . add(abstract list . Java:111) 在 Demo.main(Demo.java:9)

另外需要注意的是，数组和列表将有对对象的共享引用。不会创建新对象并将其添加到列表中。我们可以通过打印对象并查看唯一的 hashcode 来验证这一点。在下面的代码输出中，数组和列表中对象的 hashcode 是相同的，这意味着它是同一个对象。

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

public class Demo
{
    public static void main(String[] args)
    {
        Object o1 = new Object();
        Object o2 = new Object();
        Object o3 = new Object();

        Object[] objectArr = {o1, o2, o3};
        List<Object> listOfObjects = Arrays.asList(objectArr);//Creating a List of Objects
        System.out.println("Object o2 from Array: " + objectArr[1]);
        System.out.println("Object o2 from List: " + listOfObjects.get(1));
    }
}

数组中的对象 O2:Java . lang . Object @ 36 BAF 30 c 列表中的对象 O2:Java . lang . Object @ 36 BAF 30 c

在 Java 中 8 流

流也可以在 Java 中初始化列表。我们可以使用 Stream.of() 方法来创建一个 Stream。接下来，我们将使用 collect() 方法收集列表中的流元素。

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Demo
{
    public static void main(String[] args)
    {
        List<String> listOfStrings = Stream.of("Justin", "Jessica", "Simon")
                                           .collect(Collectors.toList());
        System.out.print(listOfStrings);
    }
}

【贾斯汀、杰西卡、西蒙】

使用列表()方法

List.of()方法是在 Java 9 中引入的，可以在一行代码中初始化一个列表。我们需要将元素传递给这个方法，它将返回一个 List 实例。Java 9 包含该方法的几个重载版本，以提供更好的性能。它还包含一个 varargs 重载方法来处理更多的元素。

import java.util.List;

public class Demo
{
    public static void main(String[] args)
    {
        List<String> listOfStrings = List.of("Justin", "Jessica", "Simon");
        System.out.print(listOfStrings);
    }
}

【贾斯汀、杰西卡、西蒙】

请注意，返回的列表是不可变的，不能更改。如果我们尝试修改列表，我们将获得不支持操作例外。

import java.util.List;
public class Demo
{
    public static void main(String[] args)
    {
        List<String> listOfStrings = List.of("Justin", "Jessica", "Simon");
        listOfStrings.add("Victor");//Error
    }
}

线程“main”Java . lang . unsupportedoperationexception 在 Java . base/Java . util . immogratecollections . uoe(immogratecollections . Java:73) 在 Java . base/Java . util . immogratecollections $ abstractimgratecollection . add(immogratecollections . Java:77) 在 Demo.main(Demo.java:8)

双括号语法

我们可以使用双括号语法在 Java 中初始化一个列表。外部大括号用于声明扩展对象类型的匿名内部类。

内部的一对大括号称为实例初始化块，我们将使用它向列表中添加元素。

不建议使用这种方法，因为它每次都会创建一个新类。它还保存对封闭实例的隐藏引用，这可能会导致内存泄漏。

import java.util.List;
import java.util.ArrayList;

public class Demo
{
    public static void main(String[] args)
    {
        List<String> listOfStrings = new ArrayList<String>() {
            {
                add("Justin");
                add("Jessica");
                add("Simon");
            }
        };

        System.out.print(listOfStrings);
    }
}

【贾斯汀、杰西卡、西蒙】

外部库

我们可以使用番石榴或阿帕奇公共库来初始化 Java 中的列表。

使用 Apache 公共集合

我们可以使用 ListUtils 类的 unmodifiableList()方法来创建一个不可修改的列表。我们可以将现有列表传递给这个方法。或者我们可以在未修改的列表()中使用 Arrays.asList()方法。

import java.util.List;
import org.apache.commons.collections4.ListUtils;
import java.util.Arrays;

public class Demo
{
    public static void main(String[] args)
    {
        List<String> listOfStrings = ListUtils.unmodifiableList(
                                     Arrays.asList("Justin", "Jessica", "Simon", "Harry")
                                     );
        System.out.print(listOfStrings);
    }
}

【贾斯汀、杰西卡、西蒙、哈利】

这个方法并不经常使用，因为我们只需要借助 Arrays.asList()方法就可以获得同样的结果。

使用番石榴图书馆

番石榴库可以初始化一个可变和不可变的列表。List 类的 newArrayList()方法将元素作为参数，并返回一个用这些元素初始化的可变ArrayList。

import java.util.List;
import com.google.common.collect.Lists;
public class Demo
{
    public static void main(String[] args)
    {
        List<String> listOfStrings = Lists.newArrayList("Justin", "Jessica", "Simon");
        System.out.print(listOfStrings);
    }
}

【贾斯汀、杰西卡、西蒙】

为了创建一个不可变的列表，我们将使用 ImmutableList.of()方法。番石榴提供了这个方法的几个重载版本，以获得更好的性能。它还有一个 varargs 重载方法来处理更多的元素。

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

public class Demo
{
    public static void main(String[] args)
    {
        List<String> listOfStrings = ImmutableList.of("Justin", "Jessica", "Harry");
        System.out.print(listOfStrings);
    }
}

【贾斯汀、杰西卡、哈利】

摘要

在本教程中，我们学习了仅使用一行代码在 Java 中初始化列表的不同方法。我们讨论了几种创建可变和不可变列表的方法。上述任何一种方法都可以使用，因为它们都具有相当的性能。但是，不建议使用双括号方法，因为这会导致大量开销。