java - with - 從數組創建ArrayList




string array to arraylist (20)

另一個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);
    }
}

輸出是......
你好
世界

我有一個初始化的數組,如:

Element[] array = {new Element(1), new Element(2), new Element(3)};

我想將此數組轉換為ArrayList類的對象。

ArrayList<Element> arraylist = ???;

Java 9

Java 9中 ,您可以使用List.of靜態工廠方法來創建List文本。 類似於以下內容:

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

這將返回包含三個元素的immutable列表。 如果需要可變列表,請將該列表傳遞給ArrayList構造函數:

new ArrayList<>(List.of(// elements vararg))

JEP 269:收集的便利工廠方法

JEP 269Java Collections API提供了一些方便的工廠方法。 這些不可變的靜態工廠方法內置於Java 9及更高版本的ListSetMap接口中。


(舊線程,但只有2美分,因為沒有提到番石榴或其他圖書館和其他一些細節)

如果可以,請使用番石榴

值得指出的是Guava方式,它極大地簡化了這些惡作劇:

用法

對於不可變列表

使用ImmutableList類及其of()copyOf()工廠方法(元素不能為null)

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

為何選擇番石榴?

主要的吸引力可能是減少由於仿製品的類型安全造成的混亂,因為使用番石榴工廠方法允許在大多數時間推斷類型。 然而,自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);
}

要將數組轉換為ArrayList,開發人員通常會這樣做:

List<String> list = Arrays.asList(arr);// this is wrong way..

Arrays.asList()將返回一個ArrayList,它是private static class inside Arraysprivate static class inside Arrays ,它不是java.util.ArrayList類。 The java.util.Arrays.ArrayList類具有set(), get(), contains()方法,但沒有任何添加元素的方法,因此其大小是固定的。 要創建一個真正的ArrayList,您必須:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

ArrayList的構造函數可以接受Collection類型 ,它也是java.util.Arrays.ArrayList的超類型。


另一個更新,即將結束的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(Arrays.asList(array))解決方案的性能:

Collections.addAll(arraylist, array);

Java 9您可以使用:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);

如果您使用:

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:

new ArrayList<T>(Arrays.asList(myArray));

我喜歡使用CollectionsArrays或Guava。 但是如果它不適合,或者你感覺不適合,那就改寫另一條不優雅的線。


從Java 8開始,有一種更簡單的轉換方法:

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}

您也可以使用Java 8中的流來完成。

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 

您可以在java 8中執行以下操作

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());

您可能只需要一個List,而不是ArrayList。 在這種情況下,您可以這樣做:

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

最簡單的方法是添加以下代碼。 嘗試和測試。

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));

根據問題,使用java 1.7的答案是:

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

但是最好總是使用界面:

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

每個人都已為您的問題提供了足夠好的答案。 現在從所有建議中,您需要確定哪個符合您的要求。 您需要知道兩種類型的集合。 一個是未修改的集合,另一個是允許您稍後修改對象的集合。

所以,這裡我將舉兩個用例的簡短示例。

  • 不可變集合創建::當您不想在創建後修改集合對象時

    List<Element> elementList = Arrays.asList(array)

  • 可變集合創建::當您可能想要在創建後修改創建的集合對象時。

    List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));


由於這個問題已經很老了,令我驚訝的是沒有人提出最簡單的形式:

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

從Java 5開始, Arrays.asList()採用varargs參數,您不必顯式構造數組。


鑑於:

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()返回的列表由原始數組支持。 如果修改原始數組,則也會修改列表。 這可能是令人驚訝的。

雖然這個問題有很多完美的書面答案,但我會添加我的輸入。

假設您有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 List表示。


// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 

new ArrayList<>(Arrays.asList(array))




type-conversion