给定一个 Element[]
类型的数组:
Element[] array = {new Element(1), new Element(2), new Element(3)};
如何将此数组转换为 ArrayList<Element>
类型的对象?
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() 返回的列表由原始数组支持。如果修改原始数组,列表也会被修改。这可能令人惊讶。
Arrays.asList()
创建了一个 java.util.Arrays.ArrayList
(java.util.Arrays
中的静态嵌套类),而不是 java.util.ArrayList
。
(旧线程,但只有 2 美分,因为没有提到番石榴或其他库和其他一些细节)
如果可以,请使用番石榴
值得指出的是 Guava 方式,它极大地简化了这些恶作剧:
用法
对于不可变列表
使用 ImmutableList
类及其 of()
和 copyOf()
工厂方法(元素不能为空):
List<String> il = ImmutableList.of("string", "elements"); // from varargs
List<String> il = ImmutableList.copyOf(aStringArray); // from array
对于可变列表
使用 Lists
类及其 newArrayList()
工厂方法:
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
另请注意其他类中其他数据结构的类似方法,例如 Sets
。
为什么是番石榴?
主要的吸引力可能是减少由于类型安全泛型导致的混乱,因为使用 Guava factory methods 允许在大多数时间推断类型。然而,自从 Java 7 与新的菱形运算符一起出现以来,这个论点就不那么成立了。
但这不是唯一的原因(Java 7 还不是无处不在):速记语法也非常方便,并且方法初始化器(如上所示)允许编写更具表现力的代码。您可以在一个 Guava 调用中执行当前 Java 集合需要 2 的操作。
如果你不能...
对于不可变列表
使用 JDK 的 Arrays
类及其 asList()
工厂方法,用 Collections.unmodifiableList()
包装:
List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));
请注意,asList()
的返回类型是使用具体 ArrayList
实现的 List
,但 它不是 java.util.ArrayList
。它是一种内部类型,它模拟 ArrayList
但实际上直接引用传递的数组并使其“写入”(修改反映在数组中)。
它通过简单地扩展 AbstractList
来禁止通过某些 List
API 方法进行修改(因此,不支持添加或删除元素),但它允许调用 set()
来覆盖元素。因此,这个列表并不是真正不可变的,对 asList()
的调用应该用 Collections.unmodifiableList()
包装。
如果您需要可变列表,请参阅下一步。
对于可变列表
与上面相同,但用实际的 java.util.ArrayList
包裹:
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);
}
Arrays.asList
返回的 List
是可变的,因为您仍然可以 set
元素 - 它只是不可调整大小。对于没有 Guava 的不可变列表,您可能会提到 Collections.unmodifiableList
。
由于这个问题已经很老了,令我惊讶的是,还没有人提出最简单的形式:
List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));
从 Java 5 开始,Arrays.asList()
采用可变参数,您不必显式构造数组。
List<String> a = Arrays.asList("first","second","third")
new ArrayList<T>(Arrays.asList(myArray));
确保 myArray
与 T
的类型相同。例如,如果您尝试从 int
数组创建 List<Integer>
,则会出现编译器错误。
另一种方式(虽然在性能方面基本上等同于 new ArrayList(Arrays.asList(array))
解决方案:
Collections.addAll(arraylist, array);
爪哇 9
在 Java 9 中,您可以使用 List.of
静态工厂方法来创建 List
文字。类似于以下内容:
List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));
这将返回一个包含三个元素的 immutable 列表。如果您想要一个 mutable 列表,请将该列表传递给 ArrayList
构造函数:
new ArrayList<>(List.of(// elements vararg))
JEP 269:集合的便利工厂方法
JEP 269 为 Java Collections API 提供了一些便利的工厂方法。这些不可变的静态工厂方法内置于 Java 9 及更高版本的 List
、Set
和 Map
接口中。
您可能只需要一个列表,而不是一个 ArrayList。在这种情况下,您可以这样做:
List<Element> arraylist = Arrays.asList(array);
set
方法),但不能更改列表的大小(不是 add
或 remove
元素)!
另一个更新,即将于 2014 年结束,您也可以使用 Java 8:
ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));
如果这可能只是一个 List
,则会保存一些字符
List<Element> list = Stream.of(myArray).collect(Collectors.toList());
Collectors.toList()
实际上会返回一个 ArrayList
。
如果您使用:
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
}
....
}
危险的一面是,如果你改变了初始数组,你就改变了 List !你确定你想要那个吗?可能是可能不是。
如果没有,最容易理解的方法是这样做:
ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
list.add(element);
}
或者如@glglgl 所说,您可以使用以下命令创建另一个独立的 ArrayList:
new ArrayList<T>(Arrays.asList(myArray));
我喜欢使用 Collections
、Arrays
或 Guava。但如果它不合适,或者你没有感觉,那就写另一条不雅的行来代替。
new ArrayList<T>(Arrays.asList(myArray));
部分之间的根本区别。两者的作用完全相同,并且具有相同的复杂性。
new ArrayList<T>(Arrays.asList(myArray));
做同样的事情,它将 asList
复制到 ArrayList
...
在 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);
从 Java 8 开始,有一种更简单的转换方法:
import java.util.List;
import static java.util.stream.Collectors.toList;
public static <T> List<T> fromArray(T[] array) {
return Arrays.stream(array).collect(toList());
}
您可以使用不同的方法进行转换
列表<元素> 列表 = Arrays.asList(array); List<元素> list = new ArrayList(); Collections.addAll(list, array); Arraylist 列表 = 新的 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 支持的新的空 observable 列表。 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());
Collectors.toList()
将返回一个 ArrayList
。但是,这在 java 的未来版本中可能会有所不同。如果您想要特定类型的集合,请使用 Collectors.toCollection()
代替,您可以在其中指定要创建的确切集合类型。
如果我们看到 Arrays.asList() 方法的定义,你会得到如下内容: public static
如果数组是原始类型,则给定的答案将不起作用。但从 Java 8 开始,您可以使用:
int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());
char
数组。
另一种简单的方法是使用 for-each 循环将数组中的所有元素添加到新的 ArrayList 中。
ArrayList<Element> list = new ArrayList<>();
for(Element e : array)
list.add(e);
即使这个问题有很多完美的书面答案,我也会添加我的输入。
假设您有 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
更多关于数组 link 的列表表示。
最简单的方法是添加以下代码。久经考验。
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());
ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));
我们可以轻松地将数组转换为 ArrayList
。我们使用 Collection 接口的 addAll()
方法将内容从一个列表复制到另一个列表。
Arraylist arr = new Arraylist();
arr.addAll(Arrays.asList(asset));
ArrayList
的构造函数之一接受 ? extends Collection<T>
参数,从而使对 addAll
的调用变得多余。
使用以下代码将元素数组转换为 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]);
}
给定对象数组:
Element[] array = {new Element(1), new Element(2), new Element(3) , new Element(2)};
将数组转换为列表:
List<Element> list = Arrays.stream(array).collect(Collectors.toList());
将数组转换为 ArrayList
ArrayList<Element> arrayList = Arrays.stream(array)
.collect(Collectors.toCollection(ArrayList::new));
将数组转换为链表
LinkedList<Element> linkedList = Arrays.stream(array)
.collect(Collectors.toCollection(LinkedList::new));
打印清单:
list.forEach(element -> {
System.out.println(element.i);
});
输出
1
2
3
每个人都已经为您的问题提供了足够好的答案。现在从所有建议中,您需要确定哪个适合您的要求。您需要了解两种类型的集合。一个是未修改的集合,另一个是允许您稍后修改对象的集合。
因此,在这里我将给出两个用例的简短示例。
不可变集合创建 :: 当你不想在创建后修改集合对象时 List
可变集合创建 :: 当您可能希望在创建后修改已创建的集合对象时。 List
Arrays.asList
返回的 List
只是原始数组的包装,并允许通过 get
和 set
访问和修改各个项目。您可能应该澄清您的意思是“不添加或删除元素”而不是“不可变”,这意味着根本不改变。
Java 8 的 Arrays 类提供了一个 stream() 方法,该方法具有接受原始数组和对象数组的重载版本。
/**** Converting a Primitive 'int' Array to List ****/
int intArray[] = {1, 2, 3, 4, 5};
List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());
/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/
List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());
/**** Converting an 'Integer' Array to List ****/
Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());
您还可以在调用 Arrays 接口时使用多态性来声明 ArrayList,如下所示:
List<Element> arraylist = new ArrayList<Integer>(Arrays.asList(array));
例子:
Integer[] array = {1}; // autoboxing
List<Integer> arraylist = new ArrayList<Integer>(Arrays.asList(array));
这应该像一个魅力。
new ArrayList
调用也是不必要的。List<ClassName> list = Arrays.asList(array)
Arrays.asList(array)
而不将其传递给新的ArrayList
对象将修复列表的大小。使用ArrayList
的更常见原因之一是能够动态更改其大小,而您的建议会阻止这种情况。