如何在 Java 中创建一个新列表答案

【问题标题】：How to make a new List in Java如何在 Java 中创建一个新列表
【发布时间】：2010-10-25 21:45:25
【问题描述】：

我们创建一个Set 为：

Set myset = new HashSet()

我们如何在 Java 中创建List？

【问题讨论】：

标签： java list collections

【解决方案1】：

List myList = new ArrayList();

或使用泛型（Java 7 或更高版本）

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

或使用泛型（旧 java 版本）

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

【讨论】：

请注意，ArrayList 不是唯一的 List ——而且，关于这个问题，HashSet 不是唯一的 Set。
我很惊讶没有人提到您可以在Java文档中查找列表接口以获得所有实现List的类的明确列表：docs.oracle.com/javase/7/docs/api/java/util/List.html
如果您使用 IDE，您通常还可以在其中查看类型层次结构，这可能更方便。在 Eclipse 中默认快捷键是 F4，在 IDEA 中默认快捷键是 Ctrl+H。
据我了解，您不能在 C# 中将泛型与 ArrayList 一起使用MSDN
对于 Java 7 和 8，第二个显式类型参数可以只替换为。

【解决方案2】：

另外，如果你想创建一个包含东西的列表（尽管它是固定大小的）：

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");

【讨论】：

需要注意的是，这种类型的列表（由 asList() 返回的列表）是不可变的。
@Avron - 错误：它只是固定大小：你不能改变大小，但你可以改变内容（警告的警告？）
太棒了。谢谢你的简洁。
如果列表中只有一件事，我使用 Collections.singletonList() 而不是 Arrays.asList()。（但是，我想，我不知道为什么。）
@MikeB 如果你不知道为什么那么坚持使用arrays.aslist

【解决方案3】：

让我总结一下并补充一点：

JDK

1. new ArrayList<String>();
2. Arrays.asList("A", "B", "C")

Guava

1. Lists.newArrayList("Mike", "John", "Lesly");
2. Lists.asList("A","B", new String [] {"C", "D"});

不可变列表

1. Collections.unmodifiableList(new ArrayList<String>(Arrays.asList("A","B")));
2. ImmutableList.builder()                                      // Guava
            .add("A")
            .add("B").build();
3. ImmutableList.of("A", "B");                                  // Guava
4. ImmutableList.copyOf(Lists.newArrayList("A", "B", "C"));     // Guava

空的不可变列表

1. Collections.emptyList();
2. Collections.EMPTY_LIST;

人物列表

1. Lists.charactersOf("String")                                 // Guava
2. Lists.newArrayList(Splitter.fixedLength(1).split("String"))  // Guava

整数列表

Ints.asList(1,2,3);                                             // Guava

【讨论】：

Ints.asList 不会创建一个不可变列表，而是一个由给定整数数组支持的固定大小的列表（即它支持List.set(int, Object)）。 “不可变字符列表”的第二个示例也不是不可变的（我会删除该行）。
不使用泛型对于任何阅读本文的开发人员来说都是一个非常“好”的例子。

【解决方案4】：

在 Java 8 中

创建固定大小的非空列表（不支持添加、删除等操作）：

List<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported

创建一个非空的可变列表：

List<Integer> list = new ArrayList<>(Arrays.asList(3, 4));

在 Java 9 中

使用新的List.of(...) 静态工厂方法：

List<Integer> immutableList = List.of(1, 2);

List<Integer> mutableList = new ArrayList<>(List.of(3, 4));

在 Java 10 中

使用Local Variable Type Inference：

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

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

var list3 = new ArrayList<String>();

并遵循最佳实践...

Don't use raw types

自 Java 5 以来，泛型已成为该语言的一部分 - 您应该使用它们：

List<String> list = new ArrayList<>(); // Good, List of String

List list = new ArrayList(); // Bad, don't do that!

Program to interfaces

例如编程到List接口：

List<Double> list = new ArrayList<>();

代替：

ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!

【讨论】：

【解决方案5】：

首先阅读this，然后阅读this 和this。 10 次中有 9 次您会使用这两种实现中的一种。

其实，看Sun's Guide to the Collections framework就行了。

【讨论】：

我什至会添加“10 次中有 8 次”，您将使用 ArrayList，因为在 10 次中有 9.9 次中它根本无关紧要。
LinkedList 在语义上是合适的，当您只真正关心结尾时。
LinkedLists 非常好，如果你只是要迭代它们。在我看来，似乎链表更优雅，但也许只是因为我在 Java 之前学习了 lisp。
@Karlp 同意。我会说 ArrayList 和 LinkedList 之间的大部分时间大约是 50/50，答案并不总是与操作的复杂性有关。更多情况下，这只是手头问题的正确感觉。
我几乎总是使用ArrayList。如果我只处理列表的末尾，它是一个双端队列（或队列），我使用ArrayDeque 实现。原因是即使基于数组的实现可能在空槽上浪费一些内存（当我无法预测必要的容量时），对于小型集合来说，这与所有链表（或双端队列）中的节点实例。作为回报，我得到随机访问。 LinkedList 提供了哪些独特的好处？

【解决方案6】：

从 Java 7 开始你有type inference for generic instance creation，所以没有必要在赋值的右边复制泛型参数：

List<String> list = new ArrayList<>();

固定大小的列表可以定义为：

List<String> list = Arrays.asList("foo", "bar");

对于不可变列表，您可以使用Guava 库：

List<String> list = ImmutableList.of("foo", "bar");

【讨论】：

我对这个声明有疑问 List list = Arrays.asList("foo", "bar");我想知道声明中的列表是否是一个对象？

【解决方案7】：

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

while(itr.hasNext())

  System.out.println(itr.next());

【讨论】：

【解决方案8】：

List 和Set 一样只是一个接口。

就像 HashSet 是 Set 的实现，它在添加/查找/删除性能方面具有某些属性，ArrayList 是 List 的裸实现。

如果您查看各个接口的文档，您会发现“所有已知的实现类”，您可以决定哪个更适合您的需求。

很有可能是ArrayList。

【讨论】：

【解决方案9】：

List 是一个类似Set 的接口，并且有ArrayList 和LinkedList 作为general purpose implementations。

我们可以创建列表为：

 List<String> arrayList = new ArrayList<>();
 List<String> linkedList = new LinkedList<>();

我们也可以创建一个固定大小的列表：

List<String> list = Arrays.asList("A", "B", "C");

我们几乎总是使用ArrayList 而不是LinkedList 实现：

LinkedList 为对象使用了大量空间，当我们有很多元素时性能很差。
LinkedList 中的任何索引操作都需要 O(n) 时间，而 ArrayList 中的时间为 O(1)。
查看此link 了解更多信息。

上面Arrays.asList创建的列表不能在结构上修改，但它的元素仍然可以修改。

Java 8

根据doc，方法Collections.unmodifiableList 返回指定列表的不可修改视图。我们可以这样得到：

Collections.unmodifiableList(Arrays.asList("A", "B", "C"));

Java 9

如果我们使用 Java 9，那么：

List<String> list = List.of("A", "B");

Java 10

如果我们在 Java 10 中，那么方法 Collectors.unmodifiableList 将返回 Java 9 中引入的真正不可修改列表的实例。查看此 answer 以获取有关 Collections.unmodifiableList 与 Collectors.unmodifiableList 中差异的更多信息 Java 10。

【讨论】：

【解决方案10】：

List list = new ArrayList();

或者使用泛型

List<String> list = new ArrayList<String>();

当然，您也可以将字符串替换为任何类型的变量，例如整数。

【讨论】：

【解决方案11】：

由于java中数组列表的声明就像

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

您可以通过多种方式在 java 中创建和初始化数组列表。

 1) List list = new ArrayList();

 2) List<type> myList = new ArrayList<>();

 3) List<type> myList = new ArrayList<type>();

 4) Using Utility class

    List<Integer> list = Arrays.asList(8, 4);
    Collections.unmodifiableList(Arrays.asList("a", "b", "c"));

 5) Using static factory method

    List<Integer> immutableList = List.of(1, 2);


 6) Creation and initializing at a time

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});



 Again you can create different types of list. All has their own characteristics

 List a = new ArrayList();
 List b = new LinkedList();
 List c = new Vector(); 
 List d = new Stack(); 
 List e = new CopyOnWriteArrayList();

【讨论】：

【解决方案12】：

有时——但很少——而不是新的 ArrayList，您可能需要一个新的 LinkedList。从 ArrayList 开始，如果您有性能问题并且有证据表明该列表存在问题，并且对该列表进行了大量添加和删除 - 然后 - 而不是之前 - 切换到 LinkedList 并查看情况是否有所改善。但总的来说，坚持使用 ArrayList，一切都会好起来的。

【讨论】：

【解决方案13】：

以下是创建列表的一些方法。

这将创建一个固定大小的列表，添加/删除元素是不可能的，如果你尝试这样做，它会抛出一个java.lang.UnsupportedOperationException。

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});
    List<String> fixedSizeList = Arrays.asList("Male", "Female");
    List<String> fixedSizeList = List.of("Male", "Female"); //from java9

以下版本是一个简单的列表，您可以在其中添加/删除任意数量的元素。
```
 List<String> list = new ArrayList<>();
```

这是在java中创建LinkedList的方法，如果你需要频繁插入/删除列表中的元素，你应该使用LinkedList而不是ArrayList
```
 List<String> linkedList = new LinkedList<>();
```

【讨论】：

您可以使用Arrays.asList("Male", "Female")。

【解决方案14】：

一个例子：

List somelist = new ArrayList();

您可以查看javadoc for List 并找到包含在java api 中的List 接口的所有已知实现类。

【讨论】：

【解决方案15】：

使用Google Collections，您可以在Lists类中使用以下方法

import com.google.common.collect.Lists;

// ...

List<String> strings = Lists.newArrayList();

List<Integer> integers = Lists.newLinkedList();

可变参数初始化和从Iterable<T> 初始化存在重载。

这些方法的优点是您不需要像使用构造函数那样显式指定泛型参数 - 编译器会根据变量的类型推断它。

【讨论】：

【解决方案16】：

作为一个选项，您可以在此处使用双括号初始化：

List<String> list = new ArrayList<String>(){
  {
   add("a");
   add("b");
  }
};

【讨论】：

这是一项昂贵的操作。您正在此处创建 ArrayList 的匿名子类。
@VikramBodicherla 我同意。这里更多的是关于语法糖。

【解决方案17】：

List<Object> nameOfList = new ArrayList<Object>();

您需要导入List 和ArrayList。

【讨论】：

【解决方案18】：

更多选项可以用 Java 8 做同样的事情，不是更好，也不是更糟，只是不同，如果你想对列表做一些额外的工作，Streams 将为你提供更多选择（过滤器、映射、减少、等等）

List<String> listA = Stream.of("a", "B", "C").collect(Collectors.toList());
List<Integer> listB = IntStream.range(10, 20).boxed().collect(Collectors.toList());
List<Double> listC = DoubleStream.generate(() -> { return new Random().nextDouble(); }).limit(10).boxed().collect(Collectors.toList());
LinkedList<Integer> listD = Stream.iterate(0, x -> x++).limit(10).collect(Collectors.toCollection(LinkedList::new));

【讨论】：

【解决方案19】：

使用 Java 9，您可以执行以下操作来创建 不可变 List：

List<Integer> immutableList = List.of(1, 2, 3, 4, 5);

List<Integer> mutableList = new ArrayList<>(immutableList);

【讨论】：

【解决方案20】：

有很多方法可以创建 Set 和 List。 HashSet 和 ArrayList 只是两个例子。如今，将泛型与集合一起使用也相当普遍。我建议你看看它们是什么

这是对 java 的内置集合的一个很好的介绍。 http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

【讨论】：

【解决方案21】：

List arrList = new ArrayList();

最好按照下面的建议使用泛型：

List<String> arrList = new ArrayList<String>();

arrList.add("one");

如果你使用 LinkedList。

List<String> lnkList = new LinkedList<String>();

【讨论】：

【解决方案22】：

使用Eclipse Collections，您可以像这样创建一个列表：

List<String> list1 = Lists.mutable.empty();
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

如果你想要一个不可变的列表：

ImmutableList<String> list3 = Lists.immutable.empty();
ImmutableList<String> list4 = Lists.immutable.of("One", "Two", "Three");

您可以通过使用原始列表来避免自动装箱。以下是创建 int 列表的方法：

MutableIntList list5 = IntLists.mutable.empty();
MutableIntList list6 = IntLists.mutable.of(1, 2, 3);

ImmutableIntList list7 = IntLists.immutable.empty();
ImmutableIntList list8 = IntLists.immutable.of(1, 2, 3);

所有 8 个原语都有变体。

MutableLongList longList       = LongLists.mutable.of(1L, 2L, 3L);
MutableCharList charList       = CharLists.mutable.of('a', 'b', 'c');
MutableShortList shortList     = ShortLists.mutable.of((short) 1, (short) 2, (short) 3);
MutableByteList byteList       = ByteLists.mutable.of((byte) 1, (byte) 2, (byte) 3);
MutableBooleanList booleanList = BooleanLists.mutable.of(true, false);
MutableFloatList floatList     = FloatLists.mutable.of(1.0f, 2.0f, 3.0f);
MutableDoubleList doubleList   = DoubleLists.mutable.of(1.0, 2.0, 3.0);

注意：我是 Eclipse Collections 的提交者。

【讨论】：

【解决方案23】：

试试这个：

List<String> messages = Arrays.asList("bla1", "bla2", "bla3");

或者：

List<String> list1 = Lists.mutable.empty(); // Empty
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

【讨论】：

【解决方案24】：

如果您需要具有单个实体的可序列化、不可变列表，您可以使用：

List<String> singList = Collections.singletonList("stackoverlow");

【讨论】：