我们将Set创建为：
Set myset = new HashSet()
我们如何在Java中创建List？
答案 0 :(得分：874)
List myList = new ArrayList();
或使用泛型（Java 7或更高版本）
List<MyType> myList = new ArrayList<>();
或使用泛型（旧的Java版本）
List<MyType> myList = new ArrayList<MyType>();
答案 1 :(得分：412)
此外，如果你想创建一个包含内容的列表（尽管它是固定大小的）：
List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");
答案 2 :(得分：166)
让我总结并添加一些内容：
<强> 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
答案 3 :(得分：36)
创建固定大小的非空列表（不支持添加，删除等操作）：
List<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported
创建非空的可变列表：
List<Integer> list = new ArrayList<>(Arrays.asList(3, 4));
使用新的List.of(...)静态工厂方法：
List<Integer> immutableList = List.of(1, 2);
List<Integer> mutableList = new ArrayList<>(List.of(3, 4));
使用Local Variable Type Inference：
var list1 = List.of(1, 2);
var list2 = new ArrayList<>(List.of(3, 4));
var list3 = new ArrayList<String>();
并遵循最佳做法......
自Java 5以来，泛型已成为该语言的一部分 - 您应该使用它们：
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!
答案 4 :(得分：30)
答案 5 :(得分：21)
//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());
答案 6 :(得分：21)
从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");
答案 7 :(得分：20)
类似于HashSet是一个Set的实现，它具有关于添加/查找/删除性能的某些属性，ArrayList是List的裸实现。
如果您查看相应界面的文档，您将找到“所有已知的实施类”，您可以决定哪一个更适合您的需求。
可能是ArrayList。
答案 8 :(得分：16)
List是一个类似Set的界面，ArrayList和LinkedList为general purpose implementations。
我们可以将List创建为：
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）相比。上面Arrays.asList创建的列表不能在结构上进行修改，但仍可以修改其元素。
根据doc，方法Collections.unmodifiableList返回指定列表的不可修改视图。我们可以这样说：
Collections.unmodifiableList(Arrays.asList("A", "B", "C"));
如果我们使用 Java 9 ，那么：
List<String> list = List.of("A", "B");
如果我们在Java 10，那么方法Collectors.unmodifiableList将返回Java 9中引入的真正不可修改列表的实例。检查此answer以获取有关Collections.unmodifiableList中差异的更多信息 Java 10 中的vs Collectors.unmodifiableList。
答案 9 :(得分：9)
List list = new ArrayList();
或使用泛型
List<String> list = new ArrayList<String>();
当然，您也可以使用任何类型的变量替换字符串，例如Integer。
答案 10 :(得分：8)
有时 - 但很少 - 而不是新的ArrayList，您可能需要一个新的LinkedList。从ArrayList开始，如果你遇到性能问题和证据表明列表存在问题，并且大量添加和删除到该列表 - 然后 - 不是之前 - 切换到LinkedList并查看是否有所改进。但总的来说，坚持使用ArrayList，一切都会好的。
答案 11 :(得分：7)
使用Google Collections，您可以在Lists类
中使用以下方法import com.google.common.collect.Lists;
// ...
List<String> strings = Lists.newArrayList();
List<Integer> integers = Lists.newLinkedList();
varargs初始化和从Iterable<T>初始化有重载。
这些方法的优点是您不需要像使用构造函数那样显式地指定泛型参数 - 编译器将根据变量的类型推断它。
答案 12 :(得分：7)
答案 13 :(得分：6)
List<Object> nameOfList = new ArrayList<Object>();
您需要导入List和ArrayList。
答案 14 :(得分：6)
使用Java 9，您可以执行以下操作来创建不可变 List：
List<Integer> immutableList = List.of(1, 2, 3, 4, 5);
List<Integer> mutableList = new ArrayList<>(immutableList);
答案 15 :(得分：5)
创建Set和List有很多种方法。 HashSet和ArrayList只是两个例子。如今，将泛型与集合一起使用也是相当普遍的。我建议你看看它们是什么
这是java内置集合的一个很好的介绍。 http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html
答案 16 :(得分：5)
作为一个选项，你可以在这里使用双括号初始化：
List<String> list = new ArrayList<String>(){
{
add("a");
add("b");
}
};
答案 17 :(得分：5)
List arrList = new ArrayList();
如下所示，您更好地使用泛型：
List<String> arrList = new ArrayList<String>();
arrList.add("one");
请使用LinkedList。
List<String> lnkList = new LinkedList<String>();
答案 18 :(得分：5)
使用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 :(得分：4)
使用Eclipse Collections，你可以像这样创建一个List：
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的提交者。
答案 20 :(得分：4)
以下是您可以创建列表的一些方法。
这将创建一个固定大小的列表，添加/删除元素是不可能的，如果您尝试这样做，它将抛出java.lang.UnsupportedOperationException。
List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});
以下版本是一个简单的列表，您可以在其中添加/删除任意数量的元素。
List<String> list = new ArrayList<>();
这是在java中创建LinkedList的方法，如果您需要频繁插入/删除列表中的元素，则应使用LinkedList而不是ArrayList
List<String> linkedList = new LinkedList<>();
答案 21 :(得分：2)
试试这个：
List<String> messages = Arrays.asList("bla1", "bla2", "bla3");
或者：
List<String> list1 = Lists.mutable.empty(); // Empty
List<String> list2 = Lists.mutable.of("One", "Two", "Three");
答案 22 :(得分：2)
如果您需要一个具有单个实体的可序列化，不可变的列表，则可以使用：
List<String> singList = Collections.singletonList("stackoverlow");
答案 23 :(得分：0)
因为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();