我们创建Set
为:
Set myset = new HashSet()
我们如何List
用Java 创建一个?
我们创建Set
为:
Set myset = new HashSet()
我们如何List
用Java 创建一个?
Answers:
List myList = new ArrayList();
或使用泛型(Java 7或更高版本)
List<MyType> myList = new ArrayList<>();
或带有泛型(旧的Java版本)
List<MyType> myList = new ArrayList<MyType>();
此外,如果您想创建一个包含所有内容的列表(尽管它将是固定大小的):
List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");
让我总结一下并添加一些内容:
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)
)。“不可变字符列表”的第二个示例也不是不变的(我将删除该行)。
要创建固定大小的非空列表(不支持诸如添加,删除等操作):
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));
使用局部变量类型推断:
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!
首先阅读这个,然后读这个和这个。十分之九的您将使用这两种实现之一。
实际上,只需阅读Sun的Collections指南框架。
ArrayList
。如果我只使用列表的末尾,则它是双端队列(或队列),并且我使用ArrayDeque
实现。原因是,即使基于数组的实现可能会在空插槽上浪费一些内存(当我无法预测必要的容量时),对于小型集合,这可以与链表中所有节点实例的开销进行比较(或双端队列)。作为回报,我获得了随机访问权。LinkedList
提供什么独特的好处?
//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具有用于通用实例创建的类型推断,因此无需在分配的右侧重复通用参数:
List<String> list = new ArrayList<>();
固定大小的列表可以定义为:
List<String> list = Arrays.asList("foo", "bar");
对于不可变列表,可以使用Guava库:
List<String> list = ImmutableList.of("foo", "bar");
就像HashSet是Set的实现一样,它具有添加/查找/删除性能方面的某些属性,ArrayList是List的裸露实现。
如果您查看各个接口的文档,则会发现“所有已知的实现类”,并且可以决定哪种接口更适合您的需求。
可能是ArrayList。
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
实现:
LinkedList
为对象使用大量空间,并且当我们有很多元素时性能很差。LinkedList
与中的O(1)相比,中的任何索引操作都需要O(n)时间ArrayList
。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.检查这个答案,获取有关差异的详细信息Collections.unmodifiableList
VS Collectors.unmodifiableList
中的Java 10。
用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));
作为一种选择,您可以在此处使用双括号初始化:
List<String> list = new ArrayList<String>(){
{
add("a");
add("b");
}
};
有很多方法可以创建集合和列表。HashSet和ArrayList只是两个示例。如今,将泛型与集合一起使用也很普遍。我建议你看看它们是什么
这是Java内置集合的很好的介绍。http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html
List arrList = new ArrayList();
最好按照以下建议使用泛型:
List<String> arrList = new ArrayList<String>();
arrList.add("one");
如果您使用LinkedList。
List<String> lnkList = new LinkedList<String>();
使用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的提交者。
以下是创建列表的一些方法。
这将创建一个具有固定大小的列表,无法添加/删除元素,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<>();
Arrays.asList("Male", "Female")
。
尝试这个:
List<String> messages = Arrays.asList("bla1", "bla2", "bla3");
要么:
List<String> list1 = Lists.mutable.empty(); // Empty
List<String> list2 = Lists.mutable.of("One", "Two", "Three");
正如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();