如何用Java创建新列表


762

我们创建Set为:

Set myset = new HashSet()

我们如何List用Java 创建一个?


1
在列表上的javadoc。“所有已知的实现类:AbstractList,AbstractSequentialList,ArrayList,AttributeList,CopyOnWriteArrayList,LinkedList,RoleList,RoleUnresolvedList,堆栈,矢量”
KitsuneYMG,2009年

121
这个问题是Google针对“ java创建列表”的热门命中之一,它具有非常有用的答案,所以对我来说似乎是一个足够合理的问题:-)
JosephH 2011年

52
这是一个具有良好答案的好问题。Stack Overflow的目的之一是为编程问题创建某种规范的答案,至少根据该网站的创建者而言。因此,如果您可以抵制这种诱惑,请尽量避免在以后对此类帖子投下反对票。
eggonlegs 2011年

Answers:


977
List myList = new ArrayList();

或使用泛型(Java 7或更高版本)

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

或带有泛型(旧的Java版本)

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

68
请注意,ArrayList不是唯一的List类型,就此问题而言,HashSet不是唯一的Set类型。
2013年

17
令我惊讶的是,没有人提到您可以在Java文档中查找list接口以获取实现List的所有类的明确列表:docs.oracle.com/javase/7/docs/api/java/util /List.html
David Mason

5
如果使用IDE,则通常也可以在其中查看类型层次结构,这可能更方便。在Eclipse中,默认快捷键是F4,在IDEA中,默认快捷键是Ctrl + H。
David Mason 2014年

1
据我了解,您不能在C#MSDN
中将

5
第二显式类型参数<的MyType>可以只用<>为Java 7和8来代替
Jannik

469

此外,如果您想创建一个包含所有内容的列表(尽管它将是固定大小的):

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

15
需要注意的是,这种类型的列表(由asList()返回的列表)是不可变的。
Avrom

70
@Avron-错误:它只是固定大小:您无法更改大小,但可以更改内容(警告的警告?)
user85421

太棒了 谢谢您的简洁。
R Claven 2015年

1
如果列表中只有一件事,我将使用Collections.singletonList()而不是Arrays.asList()。(但是,我想我不知道为什么。)
MikeB

@MikeB如果你不知道为什么那么坚持arrays.aslist
石羊

183

让我总结一下并添加一些内容:

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");                                  // 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不会创建不可变的列表,而是创建由给定的int数组支持的固定大小的列表(即,它支持List.set(int, Object))。“不可变字符列表”的第二个示例也不是不变的(我将删除该行)。
Xaerxess 2014年

9
对于将要阅读此内容的任何开发人员,不使用泛型都是一个非常“好的”示例。
Natix

60

在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中

使用局部变量类型推断

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!

1
嗨,您能建议我在哪里可以学习这些差异以及Java的发展吗?似乎很有趣!
shiv

31

首先阅读这个,然后读这个这个。十分之九的您将使用这两种实现之一。

实际上,只需阅读Sun的Collections指南框架


11
我甚至想补充“8次了10年”,你会使用ArrayList,只是因为它根本没关系的9.9倍出10
约阿希姆·绍尔

1
仅在真正关心目的时,LinkedList在语义上是适当的。
亚当·贾斯基维奇

如果您要遍历LinkedList,则它们是极好的选择。对我来说,似乎链表更加优雅,但这也许只是因为我在Java之前就学过Lisp。
KarlP

@Karlp同意。我会说,在ArrayList和LinkedList之间的大多数情况下,大约是50/50,答案并不总是关于操作的复杂性。通常,这只是解决当前问题的正确方法。
亚当·贾斯基维奇

1
我几乎都习惯了ArrayList。如果我只使用列表的末尾,则它是双端队列(或队列),并且我使用ArrayDeque实现。原因是,即使基于数组的实现可能会在空插槽上浪费一些内存(当我无法预测必要的容量时),对于小型集合,这可以与链表中所有节点实例的开销进行比较(或双端队列)。作为回报,我获得了随机访问权。LinkedList提供什么独特的好处?
erickson

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

21

由于Java 7具有用于通用实例创建的类型推断,因此无需在分配的右侧重复通用参数:

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

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

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

对于不可变列表,可以使用Guava库:

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

我对此声明有一个问题List <String> list = Arrays.asList(“ foo”,“ bar”); 我想知道声明中的列表是否是对象?

20

List就像Set一样只是一个接口。

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

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

可能是ArrayList


18

List是一个接口等Set,并具有ArrayListLinkedList作为一般用途的实施方式

我们可以将List创建为:

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

我们还可以创建一个固定大小的列表,如下所示:

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

我们几乎总是会使用ArrayList反对LinkedList实现:

  1. LinkedList 为对象使用大量空间,并且当我们有很多元素时性能很差。
  2. LinkedList与中的O(1)相比,中的任何索引操作都需要O(n)时间ArrayList
  3. 检查此链接以获取更多信息。

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.检查这个答案,获取有关差异的详细信息Collections.unmodifiableList VS Collectors.unmodifiableList的Java 10


9

有时(但很少)不是新的ArrayList,而是新的LinkedList。首先从ArrayList开始,如果您遇到性能问题并证明该列表是问题所在,并且对该列表进行了大量添加和删除操作-然后-而不是之前-切换到LinkedList并查看情况是否有所改善。但是基本上,坚持使用ArrayList,一切都会好起来的。


9
List list = new ArrayList();

或与泛型

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

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


7

一个例子:

List somelist = new ArrayList();

您可以查看Listjavadoc并找到Listjava api随附的接口的所有已知实现类。


7

使用Google收藏夹,您可以在Lists类中使用以下方法

import com.google.common.collect.Lists;

// ...

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

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

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

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


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

您需要导入ListArrayList


6

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

6

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

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

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

6

作为一种选择,您可以在此处使用双括号初始化:

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

2
这是一个昂贵的操作。您将在此处创建ArrayList的匿名子类。
Vikram Bodicherla

@VikramBodicherla我同意。这里更多关于语法糖。
Angry_gopher 2014年


5
List arrList = new ArrayList();

最好按照以下建议使用泛型:

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

arrList.add("one");

如果您使用LinkedList。

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

4

使用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 Collections的提交者。


4

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

  • 这将创建一个具有固定大小的列表,无法添加/删除元素,java.lang.UnsupportedOperationException如果尝试这样做将抛出一个。

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


  • 以下版本是一个简单列表,您可以在其中添加/删除任意数量的元素。

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


  • 这是LinkedList在Java中创建一个方法,如果需要频繁插入/删除列表中的元素,则应使用LinkedList而不是ArrayList

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

1
您可以使用Arrays.asList("Male", "Female")
约翰尼,

3

尝试这个:

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

要么:

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

2

如果您需要一个具有单个实体的可序列化,不可变的列表,则可以使用:

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

2

正如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();
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.