ฉันมีอาร์เรย์ที่เริ่มต้นเช่น:

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

ฉันต้องการแปลงอาเรย์นี้เป็นวัตถุของArrayListคลาส

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 เซ็นต์ไม่มีใครพูดถึง Guava หรือ libs อื่น ๆ และรายละเอียดอื่น ๆ )}

ถ้าทำได้ให้ใช้ฝรั่ง

มันคุ้มค่าที่จะชี้ให้เห็นวิธีของ Guava ซึ่งทำให้ shenanigans เหล่านี้ง่ายขึ้นมาก:

การใช้

สำหรับรายการที่ไม่เปลี่ยนรูป

ใช้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 ทำให้สามารถสรุปประเภทส่วนใหญ่ได้ตลอดเวลา อย่างไรก็ตามอาร์กิวเมนต์นี้เก็บน้ำน้อยลงตั้งแต่ Java 7 มาถึงพร้อมกับตัวดำเนินการเพชรใหม่

แต่ไม่ใช่เหตุผลเดียว (และ Java 7 ยังไม่เกิดขึ้นทุกที่): ชวเลขไวยากรณ์นั้นมีประโยชน์มากและเมธอด initializers ดังที่เห็นด้านบนอนุญาตให้เขียนโค้ดที่แสดงออกได้มากกว่า คุณทำสิ่งหนึ่งในการเรียก Guava สิ่งที่เกิดขึ้น 2 กับ Java Collections ปัจจุบัน

หากคุณไม่สามารถ ...

สำหรับรายการที่ไม่เปลี่ยนรูป

ใช้Arraysคลาสของ JDK และasList()วิธีการของโรงงานห่อด้วยCollections.unmodifiableList():

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

โปรดทราบว่าชนิดกลับมาasList()เป็นListใช้คอนกรีตArrayListการดำเนินงาน แต่มันไม่ได้เป็น java.util.ArrayListมันเป็นประเภทภายในซึ่งเลียนแบบArrayListแต่จริงๆแล้วอ้างอิงโดยตรงกับอาร์เรย์ที่ส่งผ่านและทำให้ "เขียนผ่าน" (การแก้ไขจะแสดงในอาร์เรย์)

มันห้ามการแก้ไขด้วยวิธีการบางอย่างของListAPI ด้วยการขยายAbstractList(ดังนั้นการเพิ่มหรือลบองค์ประกอบที่ไม่ได้รับการสนับสนุน) อย่างไรก็ตามมันช่วยให้การเรียกไป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+

เพื่อจุดประสงค์ด้านการศึกษา: The Good ol 'Manual Way

// 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>จาก array ของintตัวอย่างเช่น

อีกวิธีหนึ่ง (แม้ว่าโดยพื้นฐานแล้วเทียบเท่ากับnew ArrayList(Arrays.asList(array))วิธีแก้ปัญหาประสิทธิภาพ:

Collections.addAll(arraylist, array);

Java 9

ในJava 9คุณสามารถใช้List.ofวิธีการคงที่จากโรงงานเพื่อสร้างListตัวอักษร สิ่งต่อไปนี้:

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

นี่จะส่งคืนรายการที่ไม่เปลี่ยนรูปซึ่งมีองค์ประกอบสามอย่าง หากคุณต้องการรายการที่ไม่แน่นอนให้ส่งผ่านรายการนั้นไปยังตัวArrayListสร้าง:

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

JEP 269: วิธีการอำนวยความสะดวกในโรงงานสำหรับการสะสม

JEP 269มีวิธีโรงงานที่สะดวกสำหรับJava Collections API วิธีการเปลี่ยนรูปแบบคงที่โรงงานเหล่านี้จะถูกสร้างขึ้นในList, SetและMapอินเตอร์เฟซในชวา 9 และต่อมา

คุณอาจแค่ต้องการรายชื่อไม่ใช่ 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[])ทำได้ดีมาก มันสร้างชนิดของ ArrayList ชื่อ Arrays.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));

ฉันรักที่จะใช้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); 

คุณสามารถแปลงโดยใช้วิธีการต่าง ๆ

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 ... ) สร้างรายการอาเรย์ที่สามารถสังเกตได้ใหม่โดยเพิ่มไอเท็มเข้าไป

อัปเดต Java 9

ด้วยใน Java 9 มันง่ายนิด ๆ หน่อย ๆ :

List<String> list = List.of("element 1", "element 2", "element 3");

ตั้งแต่ 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()); 

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

อีกวิธีง่ายๆคือการเพิ่มองค์ประกอบทั้งหมดจากอาร์เรย์ไปยัง 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());

คุณสามารถทำได้ใน java 8 ดังต่อไปนี้

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

เราสามารถแปลงอาเรArrayListย์เป็น เราใช้addAll()วิธีการรวบรวมข้อมูลเพื่อวัตถุประสงค์ในการคัดลอกเนื้อหาจากรายการหนึ่งไปยังอีกรายการหนึ่ง

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));

แม้ว่าจะมีคำตอบที่เขียนไว้อย่างสมบูรณ์แบบสำหรับคำถามนี้ฉันจะเพิ่มอินพุตของฉัน

สมมติว่าคุณมี Element[] array = { new Element(1), new Element(2), new Element(3) };

New 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 เท่านั้นไม่ใช่ 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 (ตรงข้ามกับรายการ) นั่นคือสามารถลบองค์ประกอบได้

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

ผลผลิตคือ ...
สวัสดีชาว
โลก

ใช้รหัสต่อไปนี้เพื่อแปลงอาร์เรย์องค์ประกอบเป็น 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]);
}

ทุกคนได้ให้คำตอบที่ดีสำหรับปัญหาของคุณแล้ว ตอนนี้จากข้อเสนอแนะทั้งหมดคุณต้องตัดสินใจเลือกซึ่งจะเหมาะกับความต้องการของคุณ คอลเลกชันมีสองประเภทที่คุณต้องรู้ หนึ่งคือคอลเล็กชันที่ไม่มีการแก้ไขและอีกหนึ่งคอลเล็กชันที่จะอนุญาตให้คุณแก้ไขวัตถุในภายหลัง

ดังนั้นที่นี่ฉันจะให้ตัวอย่างสั้น ๆ สำหรับการใช้งานสองกรณี

• การสร้างคอลเลกชันที่ไม่เปลี่ยนรูปแบบ :: เมื่อคุณไม่ต้องการแก้ไขวัตถุคอลเลกชันหลังจากการสร้าง

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

• การสร้างคอลเลกชันที่ไม่แน่นอน :: เมื่อคุณอาจต้องการแก้ไขวัตถุคอลเลกชันที่สร้างขึ้นหลังจากการสร้าง

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

รับวัตถุอาร์เรย์:

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

แปลง Array เป็น List:

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

แปลง Array เป็น ArrayList

    ArrayList<Element> arrayList = Arrays.stream(array)
                                       .collect(Collectors.toCollection(ArrayList::new));

แปลง Array เป็น LinkedList

    LinkedList<Element> linkedList = Arrays.stream(array)
                     .collect(Collectors.toCollection(LinkedList::new));

รายการพิมพ์:

    list.forEach(element -> {
        System.out.println(element.i);
    });

เอาท์พุท

1

2

3

คลาส Arrays ของ Java 8 จัดเตรียมเมธอดสตรีม () ซึ่งมีเวอร์ชันที่โอเวอร์โหลดซึ่งยอมรับทั้งอาร์เรย์ดั้งเดิมและอาร์เรย์อ็อบเจ็กต์

/**** 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());

รหัสด้านล่างดูเหมือนจะเป็นวิธีที่ดีในการทำเช่นนี้

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