如何在Java中创建新列表

一个例子：

List somelist = new ArrayList();

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

List list = new ArrayList();

或者用仿制药

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

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

List myList = new ArrayList();

或者使用泛型（Java7或更高版本）

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

或泛型（旧java版本）

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

首先读取这个，然后读取这个和这个。10次中有9次您将使用这两个实现之一。

事实上，只要读Sun的集合框架指南。

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

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

//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());

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

列表只是一个接口，就像设置一样。

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

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

很可能是数组列表。

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

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

使用谷歌收藏，您可以在列表类中使用以下方法

import com.google.common.collect.Lists;
// ...
List<String> strings = Lists.newArrayList();
List<Integer> integers = Lists.newLinkedList();

varargs初始化和从Iterable<T>初始化有重载。

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

由于Java7您有泛型实例创建的类型推断，因此无需在赋值的右侧重复通用参数：

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

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

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

对于不可变列表，您可以使用番石榴库：

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

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

您需要导入List和ArrayList。

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

JDK

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

番石榴

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");                                  // Guava4. ImmutableList.copyOf(Lists.newArrayList("A", "B", "C"));     // Guava

空不可变列表

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

角色列表

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

整数列表

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

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

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

List arrList = new ArrayList();

最好使用泛型，如下所示：

List<String> arrList = new ArrayList<String>();
arrList.add("one");

如果您使用LinkedList。

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

更多的选项来做同样的事情与Java8，不是更好，不是更糟，只是不同，如果你想做一些额外的工作与列表，流将为您提供更多的选择（过滤器，映射，减少等）

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));

List是一个类似于Set的接口，ArrayList和LinkedList是通用实现。

我们可以将List创建为：

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

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

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

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

1. LinkedList为对象使用了大量空间，当我们有很多元素时表现不佳。
2. 与ArrayList中的O（1）相比，LinkedList中的任何索引操作都需要O（n）时间。
3. 查看此链接以获取更多信息。

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

Java8

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

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

Java9

如果我们使用Java9，那么：

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

Java10

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

使用Eclipse集合，您可以创建这样的列表：

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集合的提交者。

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

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

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

• 这将创建一个具有固定大小的列表，添加/删除元素是不可能的，如果您尝试这样做，它将抛出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<>();

试试这个：

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

或：

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

Java8

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

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

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

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

9Java

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

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

Java10

使用局部变量类型推断：

var list1 = List.of(1, 2);
var list2 = new ArrayList<>(List.of(3, 4));
var list3 = new ArrayList<String>();

遵循最佳实践…

不要使用原始类型

自Java5以来，泛型一直是语言的一部分-您应该使用它们：

List<String> list = new ArrayList<>(); // Good, List of String
List list = new ArrayList(); // Bad, don't do that!

接口程序

例如，编程到List接口：

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

而不是：

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

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

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

正如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();

列表可以通过多种方式创建：

1-构造函数初始化

List是一个接口，List的实例可以通过以下方式创建：

List<Integer> list=new ArrayList<Integer>();List<Integer> llist=new LinkedList<Integer>();List<Integer> stack=new Stack<Integer>();

使用Arrays.as列表（）

List<Integer> list=Arrays.asList(1, 2, 3);

3.使用集合类方法

空列表

List<Integer> list = Collections.EMPTY_LIST;

或

List<Integer> list = Collections.emptyList();
Collections.addAll(list = new ArrayList<Integer>(), 1, 2, 3, 4);

不可修改列表

List<Integer> list = Collections.unmodifiableList(Arrays.asList(1, 2, 3));

单例列表

List<Integer> list = Collections.singletonList(2);

你可以从下面的参考链接找到更多的方法。

参考：

https://www.geeksforgeeks.org/initializing-a-list-in-java/