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


How to make a new List in Java

我们创建一个Set作为：

1
Set myset = new HashSet()

我们如何在Java中创建EDCOX1 1？

相关讨论

1
List myList = new ArrayList();

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

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

或泛型(旧Java版本)

1
List<MyType> myList = new ArrayList<MyType>();
相关讨论

此外，如果要创建包含内容的列表(尽管其大小是固定的)，请执行以下操作：

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

让我总结并添加一些内容：

JDK

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

番石榴

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

不变列表

1
2
3
4
5
6
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
2
1. Collections.emptyList();
2. Collections.EMPTY_LIST;

字符列表

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

整数列表

1
Ints.asList(1,2,3);                                             // Guava
相关讨论

在Java 8中

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

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

要创建非空可变列表：

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

在Java 9中

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

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

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

在Java 10中

使用局部变量类型推断：

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

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

var list3 = new ArrayList<String>();

并遵循最佳实践…

不使用原始类型

自从Java 5以来，泛型一直是语言的一部分——你应该使用它们：

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

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

程序到接口

例如，对List接口编程：

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

而不是：

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

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

实际上，只需阅读Sun的收集框架指南。

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//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());

由于Java 7具有通用实例创建的类型推断，因此不需要在赋值的右侧复制通用参数：

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

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

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

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

1
List<String> list = ImmutableList.of("foo","bar");
相关讨论

列表只是一个与设置相同的接口。

与hashset是一个集合的实现类似，它在添加/查找/删除性能方面具有某些属性，arraylist是列表的裸实现。

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

很可能是最合理的。

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

我们可以创建如下列表：

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

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

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

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

  • LinkedList为对象使用了大量的空间，当我们有大量元素时，它的性能很差。
  • 与ArrayList中的o(1)相比，LinkedList中的任何索引操作都需要o(n)时间。
  • 有关详细信息，请查看此链接。

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

    爪哇8

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

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

    爪哇9

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

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

    爪哇10

    如果我们在Java 10，那么方法EDCOX1 OR 11将返回Java 9中引入的真正不可修改列表的实例。在Java 10中检查EDCOX1与10的EDCOX1和11之间的差异的更多信息。

    1
    List list = new ArrayList();

    或者用仿制药

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

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

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

    一个例子：

    1
    List somelist = new ArrayList();

    您可以查看JavaDoc列表，并找到包含在Java API中的所有EDCOX1 0接口的已知实现类。

    使用Google集合，可以在Lists类中使用以下方法

    1
    2
    3
    4
    5
    6
    7
    import com.google.common.collect.Lists;

    // ...

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

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

    存在用于varargs初始化和从Iterable初始化的重载。

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

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

    您需要导入List和ArrayList。

    使用Java 9，您可以执行以下操作来创建一个不可变的EDCOX1，0个：

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

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

    更多的选择用Java 8做同样的事情，不是更好，不是更坏，只是不同，如果你想做一些额外的工作与列表，流将提供更多的选择(过滤器，地图，减少等)。

    1
    2
    3
    4
    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));

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

    1
    2
    3
    4
    5
    6
    List<String> list = new ArrayList<String>(){
      {
       add("a");
       add("b");
      }
    };
    相关讨论

    1
    List arrList = new ArrayList();

    最好使用下面建议的仿制药：

    1
    2
    3
    List<String> arrList = new ArrayList<String>();

    arrList.add("one");

    如果您使用LinkedList。

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

    创建集合和列表的方法有很多种。hashset和arraylist只是两个例子。如今，在集合中使用泛型也是相当常见的。我建议你看看它们是什么

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

    使用Eclipse集合，您可以创建如下列表：

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

    如果需要不可变列表：

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

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

    1
    2
    3
    4
    5
    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个原语都有变体。

    1
    2
    3
    4
    5
    6
    7
    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集合的提交者。

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

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

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

    < BR>

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

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

    < BR>

    • 这是如何在Java中创建EDCOX1×3的方法，如果需要频繁地插入/删除列表中的元素，则应该使用EDCOX1×3×ED代替EDCOX1×2

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

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

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

    试试这个：

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

    或：

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