วิธีการสร้างรายชื่อใหม่ใน Java

เราสร้างSetเป็น:

Set myset = new HashSet()

เราจะสร้างListใน Java ได้อย่างไร

List myList = new ArrayList();

หรือกับ generics ( Java 7หรือใหม่กว่า)

List<MyType> myList = new ArrayList<>();

หรือกับ generics (เวอร์ชัน java เก่า)

List<MyType> myList = new ArrayList<MyType>();

นอกจากนี้หากคุณต้องการสร้างรายการที่มีสิ่งต่าง ๆ อยู่ (แม้ว่ามันจะเป็นขนาดคงที่):

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");

ให้ฉันสรุปและเพิ่มบางสิ่ง:

JDK

1. new ArrayList<String>();
2. Arrays.asList("A", "B", "C")

ฝรั่ง

1. Lists.newArrayList("Mike", "John", "Lesly");
2. Lists.asList("A","B", new String [] {"C", "D"});

รายการไม่เปลี่ยนรูป

1. Collections.unmodifiableList(new ArrayList<String>(Arrays.asList("A","B")));
2. ImmutableList.builder()                                      // Guava
            .add("A")
            .add("B").build();
3. ImmutableList.of("A", "B");                                  // Guava
4. ImmutableList.copyOf(Lists.newArrayList("A", "B", "C"));     // Guava

รายการที่ไม่เปลี่ยนรูปที่ว่างเปล่า

1. Collections.emptyList();
2. Collections.EMPTY_LIST;

รายชื่อตัวละคร

1. Lists.charactersOf("String")                                 // Guava
2. Lists.newArrayList(Splitter.fixedLength(1).split("String"))  // Guava

รายชื่อจำนวนเต็ม

Ints.asList(1,2,3);                                             // Guava

ใน Java 8

หากต้องการสร้างรายการขนาดคงที่แบบไม่ว่างเปล่า (ไม่รองรับการดำเนินการเช่นเพิ่มลบออก ฯลฯ ):

List<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported

ในการสร้างรายการที่ไม่แน่นอนที่ไม่ว่างเปล่าให้ทำดังนี้

List<Integer> list = new ArrayList<>(Arrays.asList(3, 4));

ใน Java 9

การใช้วิธีการใหม่จากList.of(...)โรงงานแบบคงที่:

List<Integer> immutableList = List.of(1, 2);

List<Integer> mutableList = new ArrayList<>(List.of(3, 4));

ใน Java 10

ใช้การอนุมานประเภท Local Variable :

var list1 = List.of(1, 2);

var list2 = new ArrayList<>(List.of(3, 4));

var list3 = new ArrayList<String>();

และปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุด ...

อย่าใช้ประเภทดิบ

ตั้งแต่ Java 5, generics เป็นส่วนหนึ่งของภาษา - คุณควรใช้มัน:

List<String> list = new ArrayList<>(); // Good, List of String

List list = new ArrayList(); // Bad, don't do that!

โปรแกรมไปยังส่วนต่อประสาน

ตัวอย่างเช่นโปรแกรมไปยังListอินเตอร์เฟส:

List<Double> list = new ArrayList<>();

แทน:

ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!

ครั้งแรกที่อ่านนี้แล้วอ่านนี้และนี้ 9 ครั้งจาก 10 คุณจะใช้หนึ่งในสองการใช้งาน

ในความเป็นจริงเพียงแค่อ่านคู่มือของดวงอาทิตย์ไปยังกรอบคอลเลกชัน

//simple example creating a list form a string array

String[] myStrings = new String[] {"Elem1","Elem2","Elem3","Elem4","Elem5"};

List mylist = Arrays.asList(myStrings );

//getting an iterator object to browse list items

Iterator itr= mylist.iterator();

System.out.println("Displaying List Elements,");

while(itr.hasNext())

  System.out.println(itr.next());

เนื่องจาก Java 7 คุณมีข้อสรุปชนิดสำหรับการสร้างอินสแตนซ์ทั่วไปดังนั้นจึงไม่จำเป็นต้องทำซ้ำพารามิเตอร์ทั่วไปทางด้านขวามือของการมอบหมาย:

List<String> list = new ArrayList<>();

รายการขนาดคงที่สามารถกำหนดเป็น:

List<String> list = Arrays.asList("foo", "bar");

สำหรับรายการที่ไม่เปลี่ยนคุณสามารถใช้ไลบรารีGuava :

List<String> list = ImmutableList.of("foo", "bar");

รายการเป็นเพียงส่วนต่อประสานเช่นเดียวกับที่ตั้งไว้

เช่นเดียวกับ HashSet คือการใช้งานชุดซึ่งมีคุณสมบัติบางอย่างที่เกี่ยวข้องกับการเพิ่ม / ค้นหา / ลบประสิทธิภาพ ArrayList เป็นการใช้งานแบบเปลือยของรายการ

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

โอกาสที่ว่ามันเป็นArrayList

Listเป็นอินเตอร์เฟซที่ชอบSetและมีArrayListและLinkedListเป็นการใช้งานอเนกประสงค์

เราสามารถสร้างรายการเป็น:

 List<String> arrayList = new ArrayList<>();
 List<String> linkedList = new LinkedList<>(); 

เรายังสามารถสร้างรายการขนาดคงที่ดังนี้:

List<String> list = Arrays.asList("A", "B", "C");

เราเกือบจะใช้ArrayListเมื่อเทียบกับLinkedListการใช้งาน:

1. LinkedList ใช้พื้นที่จำนวนมากสำหรับวัตถุและทำงานได้ไม่ดีเมื่อเรามีองค์ประกอบมากมาย
2. การดำเนินการใด ๆ ที่จัดทำดัชนีในLinkedListต้อง O (n) เวลาเมื่อเทียบกับ O (1) ArrayListใน
3. ตรวจสอบลิงค์นี้สำหรับข้อมูลเพิ่มเติม

รายการที่สร้างโดยArrays.asListข้างต้นไม่สามารถปรับเปลี่ยนโครงสร้างได้ แต่องค์ประกอบยังคงสามารถแก้ไขได้

Java 8

ตามเอกสารวิธีการCollections.unmodifiableListจะคืนค่ามุมมองที่ไม่สามารถเปลี่ยนแปลงได้ของรายการที่ระบุ เราได้รับเช่น:

Collections.unmodifiableList(Arrays.asList("A", "B", "C"));

Java 9

ในกรณีที่เราใช้Java 9 อยู่แล้ว:

List<String> list = List.of("A", "B");

Java 10

ในกรณีที่เราอยู่ที่ 10 Java แล้ววิธีการที่Collectors.unmodifiableListจะกลับมาอินสแตนซ์ของรายการ unmodifiable อย่างแท้จริงนำมาใช้ใน Java 9. ตรวจสอบนี้คำตอบสำหรับข้อมูลเพิ่มเติมเกี่ยวกับความแตกต่างในCollections.unmodifiableList VS Collectors.unmodifiableListในJava 10

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

List list = new ArrayList();

หรือด้วยยาชื่อสามัญ

List<String> list = new ArrayList<String>();

แน่นอนคุณสามารถแทนที่สตริงด้วยตัวแปรชนิดใดก็ได้เช่นจำนวนเต็มเช่นกัน

ตัวอย่างหนึ่ง:

List somelist = new ArrayList();

คุณสามารถดูjavadoc เพื่อดูรายการและค้นหาคลาสการนำไปปฏิบัติที่รู้จักทั้งหมดของListอินเตอร์เฟสที่รวมอยู่ใน java api

เมื่อใช้Google Collectionsคุณสามารถใช้วิธีการต่อไปนี้ในคลาสรายการ

import com.google.common.collect.Lists;

// ...

List<String> strings = Lists.newArrayList();

List<Integer> integers = Lists.newLinkedList();

มี overloads สำหรับ varargs เริ่มต้นและ initialising Iterable<T>จาก

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

List<Object> nameOfList = new ArrayList<Object>();

คุณจำเป็นต้องนำเข้าและListArrayList

ตัวเลือกเพิ่มเติมในการทำสิ่งเดียวกันกับ Java 8 ไม่ดีขึ้นไม่แย่ลงแตกต่างกันและถ้าคุณต้องการทำงานพิเศษกับรายการStreamsจะให้ทางเลือกเพิ่มเติมแก่คุณ (ตัวกรองแผนที่ลด ฯลฯ )

List<String> listA = Stream.of("a", "B", "C").collect(Collectors.toList());
List<Integer> listB = IntStream.range(10, 20).boxed().collect(Collectors.toList());
List<Double> listC = DoubleStream.generate(() -> { return new Random().nextDouble(); }).limit(10).boxed().collect(Collectors.toList());
LinkedList<Integer> listD = Stream.iterate(0, x -> x++).limit(10).collect(Collectors.toCollection(LinkedList::new));

ด้วย Java 9 คุณสามารถทำสิ่งต่อไปนี้เพื่อสร้างไม่เปลี่ยนรูปได้ List :

List<Integer> immutableList = List.of(1, 2, 3, 4, 5);

List<Integer> mutableList = new ArrayList<>(immutableList);

เป็นตัวเลือกคุณสามารถใช้วงเล็บปีกกาเริ่มต้นที่นี่:

List<String> list = new ArrayList<String>(){
  {
   add("a");
   add("b");
  }
};

มีหลายวิธีในการสร้างชุดและรายการ HashSet และ ArrayList เป็นเพียงสองตัวอย่าง นอกจากนี้ยังเป็นเรื่องธรรมดาที่จะใช้ยาสามัญกับชุดสะสมวันนี้ ฉันขอแนะนำให้คุณดูสิ่งที่พวกเขา

นี่คือการแนะนำที่ดีสำหรับคอลเลกชัน builtin ของ java http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

List arrList = new ArrayList();

มันดีกว่าคุณใช้ generics ตามที่แนะนำด้านล่าง:

List<String> arrList = new ArrayList<String>();

arrList.add("one");

ในกรณีที่คุณใช้ LinkedList

List<String> lnkList = new LinkedList<String>();

การใช้Eclipse Collectionsคุณสามารถสร้างรายการแบบนี้:

List<String> list1 = Lists.mutable.empty();
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

ถ้าคุณต้องการรายการที่ไม่เปลี่ยนรูปแบบ:

ImmutableList<String> list3 = Lists.immutable.empty();
ImmutableList<String> list4 = Lists.immutable.of("One", "Two", "Three");

คุณสามารถหลีกเลี่ยงการชกมวยอัตโนมัติได้โดยใช้รายการดั้งเดิม นี่คือวิธีที่คุณจะสร้างรายการ int:

MutableIntList list5 = IntLists.mutable.empty();
MutableIntList list6 = IntLists.mutable.of(1, 2, 3);

ImmutableIntList list7 = IntLists.immutable.empty();
ImmutableIntList list8 = IntLists.immutable.of(1, 2, 3);

มีตัวแปรสำหรับ 8 ดั้งเดิมทั้งหมด

MutableLongList longList       = LongLists.mutable.of(1L, 2L, 3L);
MutableCharList charList       = CharLists.mutable.of('a', 'b', 'c');
MutableShortList shortList     = ShortLists.mutable.of((short) 1, (short) 2, (short) 3);
MutableByteList byteList       = ByteLists.mutable.of((byte) 1, (byte) 2, (byte) 3);
MutableBooleanList booleanList = BooleanLists.mutable.of(true, false);
MutableFloatList floatList     = FloatLists.mutable.of(1.0f, 2.0f, 3.0f);
MutableDoubleList doubleList   = DoubleLists.mutable.of(1.0, 2.0, 3.0);

หมายเหตุ:ฉันเป็นคอมมิชชันสำหรับ Eclipse Collections

ต่อไปนี้เป็นวิธีที่คุณสามารถสร้างรายการได้

• สิ่งนี้จะสร้างรายการที่มีขนาดคงที่ไม่สามารถเพิ่มหรือลบองค์ประกอบมันจะส่ง a java.lang.UnsupportedOperationExceptionถ้าคุณพยายามทำ

  List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});

• รุ่นต่อไปนี้เป็นรายการง่าย ๆ ที่คุณสามารถเพิ่ม / ลบองค์ประกอบจำนวนเท่าใดก็ได้

  List<String> list = new ArrayList<>();

• นี่คือวิธีการสร้างLinkedListในจาวาหากคุณต้องการแทรก / ลบองค์ประกอบในรายการบ่อยครั้งคุณควรใช้LinkedListแทนArrayList

  List<String> linkedList = new LinkedList<>();

ลองสิ่งนี้:

List<String> messages = Arrays.asList("bla1", "bla2", "bla3");

หรือ:

List<String> list1 = Lists.mutable.empty(); // Empty
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

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

List<String> singList = Collections.singletonList("stackoverlow");

ในฐานะที่เป็นประกาศของรายการอาร์เรย์ใน java เป็นเหมือน

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable  

มีหลายวิธีที่คุณสามารถสร้างและเริ่มต้นรายการอาร์เรย์ใน java

 1) List list = new ArrayList();

 2) List<type> myList = new ArrayList<>();

 3) List<type> myList = new ArrayList<type>();

 4) Using Utility class

    List<Integer> list = Arrays.asList(8, 4);
    Collections.unmodifiableList(Arrays.asList("a", "b", "c"));

 5) Using static factory method

    List<Integer> immutableList = List.of(1, 2);


 6) Creation and initializing at a time

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});



 Again you can create different types of list. All has their own characteristics

 List a = new ArrayList();
 List b = new LinkedList();
 List c = new Vector(); 
 List d = new Stack(); 
 List e = new CopyOnWriteArrayList();