我有一系列初始化,如:

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

这样可以正常工作。但有些警告:

  1. 从asList返回的列表具有固定大小。因此,如果您希望能够在代码中添加或删除返回列表中的元素,则需要将其包装在新的ArrayList中。否则你会得到UnsupportedOperationException
  2. asList()返回的列表由原始数组支持。如果修改原始数组,则也会修改列表。这可能会令人惊讶。

(旧线程,但只有2美分,因为没有提到番石榴或其他库和其他一些细节)

如果可以,请使用番石榴

值得指出的是番石榴方式,这极大地简化了这些恶作剧:

用法

对于不可变列表

使用 <= > 类及其 ImmutableList of() 工厂方法(元素不能为空)

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

对于可变列表

使用 <= > 类及其 copyOf() 工厂方法:

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

确保myArrayT的类型相同。例如,如果您尝试从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 <*>

我喜欢使用CollectionsArrays或番石榴。但如果它不适合,或者你感觉不适合,那就改写另一条不优雅的线。

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

你可以转换成使用不同的方法

  1. List<Element> list = Arrays.asList(array);

  2. List<Element> list = new ArrayList();
    Collections.addAll(list, array);

  3. 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());
}
  1. 如果我们看到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传递。

  2. 这个问题也可能有另一个答案。
    如果您看到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))
许可以下: CC-BY-SA归因
不隶属于 StackOverflow
scroll top