-
03-07-2019 - |
题
我有一系列初始化,如:
Element[] array = {new Element(1), new Element(2), new Element(3)};
我想把这列入一个目的。级。
ArrayList<Element> arraylist = ???;
解决方案
new ArrayList<>(Arrays.asList(array))
其他提示
假设:
Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };
最简单的答案是:
List<Element> list = Arrays.asList(array);
这样可以正常工作。但有些警告:
- 从asList返回的列表具有固定大小。因此,如果您希望能够在代码中添加或删除返回列表中的元素,则需要将其包装在新的
ArrayList
中。否则你会得到UnsupportedOperationException
。 - 从
asList()
返回的列表由原始数组支持。如果修改原始数组,则也会修改列表。这可能会令人惊讶。
醇>
(旧线程,但只有2美分,因为没有提到番石榴或其他库和其他一些细节)
如果可以,请使用番石榴
值得指出的是番石榴方式,这极大地简化了这些恶作剧:
用法
对于不可变列表
使用 <= > 类及其 ImmutableList
和 of()
工厂方法(元素不能为空):
List<String> il = ImmutableList.of("string", "elements"); // from varargs
List<String> il = ImmutableList.copyOf(aStringArray); // from array
对于可变列表
List<String> l1 = Lists.newArrayList(anotherListOrCollection); // from collection
List<String> l2 = Lists.newArrayList(aStringArray); // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs
请注意其他类中其他数据结构的类似方法,例如 Lists
。
为何选择Guava?
使用Guava 工厂方法允许在大多数时间推断类型。然而,自从Java 7与新的钻石操作员一起到达以来,这个论点含有较少的水。
但这不是唯一的原因(并且Java 7还没有到处):简写语法也非常方便,如上所示,方法初始化程序允许编写更具表现力的代码。你在一个Guava调用中执行当前Java集合需要2个。
如果你不能......
对于不可变列表
使用JDK的 newArrayList()
class及其 < => 工厂方法,用 Sets
:
List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));
请注意,Arrays
的返回类型是asList()
使用具体的Collections.unmodifiableList()
实现,但不是 List
。它是一个内部类型,它模拟ArrayList
但实际上直接引用传递的数组并使其成为<!>“;通过<!>引用; (修改反映在数组中)。
它禁止通过一些java.util.ArrayList
API的方法进行修改,只需扩展AbstractList
(因此,不支持添加或删除元素),但是它允许调用set()
来覆盖元素。因此,此列表不是真正不可变的,并且对<=>的调用应该用<=>包装。
如果您需要可变列表,请参阅下一步。
对于可变列表
与上述相同,但包含实际的<=>:
List<String> l1 = new ArrayList<String>(Arrays.asList(array)); // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array)); // Java 1.7+
List<String> l2 = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b")); // Java 1.7+
用于教育目的:良好的'手动方式
// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
final List<T> l = new ArrayList<T>(array.length);
for (final T s : array) {
l.add(s);
}
return (l);
}
// for Java < 1.5 (no generics, no compile-time type-safety, boo!)
static List arrayToList(final Object[] array) {
final List l = new ArrayList(array.length);
for (int i = 0; i < array.length; i++) {
l.add(array[i]);
}
return (l);
}
由于这个问题已经很久了,所以没有人提出最简单的表格让我感到惊讶:
List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));
从Java 5开始,Arrays.asList()
采用varargs参数,您不必显式构造数组。
new ArrayList<T>(Arrays.asList(myArray));
确保myArray
与T
的类型相同。例如,如果您尝试从List<Integer>
数组创建int
,则会出现编译器错误。
另一种方式(虽然基本上等同于new ArrayList(Arrays.asList(array))
解决方案性能方面:
Collections.addAll(arraylist, array);
Java9
在 Java9, 你可以使用 List.of
静态工厂的方法,以便创建一个 List
文字。喜欢的东西如下:
List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));
这将返回 不可改变的 列表,包含三个要素。如果你想要一个 可变 名单,通过该列表中的 ArrayList
构造:
new ArrayList<>(List.of(// elements vararg))
JEP269:便利工厂的方法,用于收藏
JEP269 提供了某些便利工厂的方法 Java集合 API。这些不可改变的静态工厂的方法是建立进入 List
, Set
, , Map
接口在Java9和后。
你可能只需要一个List,而不是一个ArrayList。在这种情况下,您可以这样做:
List<Element> arraylist = Arrays.asList(array);
另一个更新,即将结束的2014年,您也可以使用Java 8:
ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));
如果这只是List
List<Element> list = Stream.of(myArray).collect(Collectors.toList());
如果您使用:
new ArrayList<T>(Arrays.asList(myArray));
你可以创建并填写两个列表!填写两次大清单正是您不想做的事情,因为每次需要扩展容量时它会创建另一个Object[]
数组。
幸运的是JDK实现很快,而且Arrays.asList(a[])
做得很好。它创建了一种名为Arrays.ArrayList的ArrayList,其中Object []数据直接指向数组。
// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>
private final E[] a;
ArrayList(E[] array) {
a = array; // you point to the previous array
}
....
}
危险的一面是如果更改初始数组,则更改列表!您确定要这样吗?也许是的,也许不是。
如果没有,最容易理解的方法是:
ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
list.add(element);
}
或者如所述@glglgl,您可以使用:
创建另一个独立的ArrayList <*>我喜欢使用Collections
,Arrays
或番石榴。但如果它不适合,或者你感觉不适合,那就改写另一条不优雅的线。
在Java 9
中,您可以使用:
List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);
根据问题,使用java 1.7的答案是:
ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));
但最好总是使用界面:
List<Element> arraylist = Arrays.<Element>asList(array);
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray);
你可以转换成使用不同的方法
List<Element> list = Arrays.asList(array);
List<Element> list = new ArrayList();
Collections.addAll(list, array);Arraylist list = new Arraylist();
list.addAll(Arrays.asList(array));
更多的细节可以参考 http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html
正如所有人所说的那样会这样做
new ArrayList<>(Arrays.asList("1","2","3","4"));
创建数组的常用最新方法是 observableArrays
ObservableList:允许侦听器在发生变化时跟踪变化的列表。
对于Java SE,您可以尝试
FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));
根据 Oracle Docs
observableArrayList() 创建一个由arraylist支持的新的空可观察列表。 observableArrayList(E ... items) 创建一个新的可观察数组列表,其中添加了项目。
更新Java 9
同样在Java 9中它有点简单:
List<String> list = List.of("element 1", "element 2", "element 3");
您也可以使用Java 8中的流来完成。
List<Element> elements = Arrays.stream(array).collect(Collectors.toList());
从Java 8开始,有一种更简单的转换方法:
public static <T> List<T> fromArray(T[] array) {
return Arrays.stream(array).collect(toList());
}
-
如果我们看到
Arrays.asList()
方法的定义,您将得到类似的内容:public static <T> List<T> asList(T... a) //varargs are of T type.
所以,您可以像这样初始化
arraylist
:List<Element> arraylist = Arrays.asList(new Element(1),new Element(2),new Element(3));
注意:每个
new Element(int args)
都将被视为单个对象,可以作为var-args
传递。 -
这个问题也可能有另一个答案。
如果您看到java.util.Collections.addAll()
方法的声明,您将得到如下内容:public static <T> boolean addAll(Collection<? super T> c, T... a);
所以,这段代码也很有用
Collections.addAll(arraylist, array);
醇>
另一种简单的方法是使用for-each循环将数组中的所有元素添加到新的ArrayList中。
ArrayList<Element> list = new ArrayList<>();
for(Element e : array)
list.add(e);
如果数组是基本类型,则给定的答案将不起作用。但是从Java 8开始,你可以使用:
int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());
我们可以轻松地将数组转换为ArrayList
。
我们使用Collection接口的addAll()
方法将内容从一个列表复制到另一个列表。
Arraylist arr = new Arraylist();
arr.addAll(Arrays.asList(asset));
即使这个问题有很多完美的书面答案,我也会加入我的输入。
假设你有Element[] array = { new Element(1), new Element(2), new Element(3) };
可以通过以下方式创建新的ArrayList
ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));
// Add through a collection
ArrayList<Element> arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);
他们非常支持ArrayList的所有操作
arraylist_1.add(new Element(4)); // or remove(): Success
arraylist_2.add(new Element(4)); // or remove(): Success
arraylist_3.add(new Element(4)); // or remove(): Success
但是以下操作只返回ArrayList的List视图而不是实际的ArrayList。
// Returns a List view of array and not actual ArrayList
List<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));
因此,他们在尝试进行一些ArrayList操作时会出错
listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error
更多关于数组链接的列表表示。
最简单的方法是添加以下代码。尝试和测试。
String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));
另一个Java8解决方案(我可能已经错过了大集合中的答案。如果是这样,我的道歉)。这会创建一个ArrayList(而不是List),即可以删除元素
package package org.something.util;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Junk {
static <T> ArrayList<T> arrToArrayList(T[] arr){
return Arrays.asList(arr)
.stream()
.collect(Collectors.toCollection(ArrayList::new));
}
public static void main(String[] args) {
String[] sArr = new String[]{"Hello", "cruel", "world"};
List<String> ret = arrToArrayList(sArr);
// Verify one can remove an item and print list to verify so
ret.remove(1);
ret.stream()
.forEach(System.out::println);
}
}
输出是......
你好
世界
您可以在java 8中执行以下操作
ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
已经是每个人都有提供足够的良好回答你的问题。现在从所有建议,则需要决定,这将配合您的要求。有两种类型的收集这你需要知道的。一个是未经修改的收集和另一个收集这将允许修改的对象后面。
所以,在这里我会给短的例子两个使用情况。
不可改变的收集创造::当你不想要修改收集目之后创建
List<Element> elementList = Arrays.asList(array)
可变收集创造::当你可能需要修改的创造收集目之后创建。
List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));
使用以下代码将元素数组转换为ArrayList。
Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element>elementArray=new ArrayList();
for(int i=0;i<array.length;i++) {
elementArray.add(array[i]);
}
您可以使用 Cactoos (我是其中一位开发人员)创建ArrayList
:
List<String> names = new StickyList<>(
"Scott Fitzgerald", "Fyodor Dostoyevsky"
);
无法保证对象实际上属于<=>类。如果您需要这种保证,请执行以下操作:
ArrayList<String> list = new ArrayList<>(
new StickyList<>(
"Scott Fitzgerald", "Fyodor Dostoyevsky"
)
);
使用以下代码
Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element> list = (ArrayList) Arrays.asList(array);
这是一个明确的方法
ArrayList<Element> arraylist = new ArrayList<>(Arrays.asList(array))