Java'da yeni bir liste nasıl oluşturulur

Şu şekilde bir oluşturuyoruz Set:

Set myset = new HashSet()

ListJava'da nasıl oluştururuz ?

List myList = new ArrayList();

veya jeneriklerle ( Java 7 veya üzeri)

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

veya jeneriklerle (Eski java sürümleri)

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

Ayrıca, içinde bir şeyler olan bir liste oluşturmak istiyorsanız (sabit boyutta olsa da):

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

Özetleyeyim ve bir şeyler ekleyeyim:

JDK

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

Guava

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

Değişmez Liste

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

Boş değişmez liste

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

Karakter Listesi

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

Tamsayıların Listesi

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

Java 8'de

Boş olmayan sabit boyutlu bir liste oluşturmak için (toplama, kaldırma vb. İşlemler desteklenmez):

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

Boş olmayan değiştirilebilir bir liste oluşturmak için:

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

Java 9'da

Yeni bir List.of(...)statik fabrika yöntemleri kullanarak :

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

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

Java 10'da

Yerel Değişken Türü Çıkarımını Kullanma :

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

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

var list3 = new ArrayList<String>();

Ve en iyi uygulamaları takip edin ...

Ham türleri kullanma

Java 5'ten beri, jenerikler dilin bir parçası olmuştur - bunları kullanmalısınız:

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

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

Arayüzlere program

Örneğin, Listarabirime programlayın :

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

Onun yerine:

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

İlk okuma bu , o zaman okumak bu ve bu . 10 üzerinden 9 kez bu iki uygulamadan birini kullanacaksınız.

Aslında, Sun'ın Koleksiyonlar Çerçevesi Kılavuzunu okuyun .

//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'den , genel örnek oluşturma için yazım çıkarımınız olduğundan, atamanın sağ tarafında genel parametreleri çoğaltmaya gerek yoktur:

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

Sabit boyutlu bir liste şu şekilde tanımlanabilir:

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

Değişmez listeler için Guava kütüphanesini kullanabilirsiniz :

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

Liste sadece Set gibi bir arayüzdür .

HashSet, performans eklemek / aramak / kaldırmak için belirli özelliklere sahip bir Set uygulaması gibi, ArrayList bir Listenin çıplak uygulamasıdır.

İlgili arayüzlerin belgelerine bir göz attıysanız "Bilinen Tüm Uygulayıcı Sınıflar" ı bulacaksınız ve hangisinin ihtiyaçlarınız için daha uygun olduğuna karar verebilirsiniz.

Muhtemelen ArrayList olmasıdır .

Listgibi bir arayüz Setvardır ve ArrayListve LinkedListşekilde genel amaçlı uygulamaları .

Listeyi şu şekilde oluşturabiliriz:

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

Ayrıca sabit boyutlu bir liste de oluşturabiliriz:

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

Neredeyse her zaman uygulamaya ArrayListkarşı LinkedListçıkardık:

1. LinkedList nesneler için çok fazla alan kullanır ve çok sayıda öğemiz olduğunda kötü performans gösterir.
2. Endekslenen herhangi bir işlem, LinkedListO (1)ArrayList .
3. Daha fazla bilgi için bu bağlantıyı kontrol edin .

Tarafından oluşturulan liste Arrays.asListYukarıda yapısal olarak değiştirilemez, ancak elemanları yine de değiştirilebilir.

Java 8

Doc başına , yöntemCollections.unmodifiableList , belirtilen liste degistiremeyeceginiz görünüm verir. Gibi alabiliriz:

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

Java 9

Java 9 kullanmamız durumunda :

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

Java 10

Java 10'da olmamız durumunda, yöntem Collectors.unmodifiableListJava 9'da tanıtılan gerçekten değiştirilemez listenin bir örneğini döndürür . Java 10'daki vs arasındaki fark hakkında daha fazla bilgi için bu yanıtı kontrol edin .Collections.unmodifiableListCollectors.unmodifiableList

Bazen - ancak çok nadiren - yeni bir ArrayList yerine yeni bir LinkedList isteyebilirsiniz. ArrayList ile başlayın ve performans sorunları ve listenin sorun olduğuna dair kanıtlarınız varsa ve o listeye çok fazla ekleme ve silme - o zaman - daha önce değil - bir LinkedList'e geçin ve işlerin iyileşip iyileşmediğine bakın. Ama anada, ArrayList ile sopa ve her şey iyi olacak.

List list = new ArrayList();

Veya jeneriklerle

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

Elbette, dizeyi Integer gibi herhangi bir değişkenle de değiştirebilirsiniz.

Bir örnek:

List somelist = new ArrayList();

Javadoc for List'e bakabilir Listve java api ile birlikte gelen arabirimin bilinen tüm uygulama sınıflarını bulabilirsiniz .

Google Koleksiyonlarını kullanarak Listeler sınıfında aşağıdaki yöntemleri kullanabilirsiniz

import com.google.common.collect.Lists;

// ...

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

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

Varargs başlatma ve başlatma için aşırı yükler vardır. Iterable<T> .

Bu yöntemlerin avantajı, genel parametreyi yapıcıda yaptığınız gibi açıkça belirtmenize gerek olmamasıdır - derleyici bunu değişkenin türünden çıkarır.

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

İçe aktarmanız Listve ArrayList.

Java 8 ile aynı şeyi yapmak için daha fazla seçenek, daha iyi değil, daha kötü değil, sadece farklı ve listelerle ekstra iş yapmak istiyorsanız, Akışlar size daha fazla alternatif sağlayacaktır (filtre, harita, azaltma vb.)

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 ile, değişmez bir şey oluşturmak için aşağıdakileri yapabilirsiniz List:

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

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

Bir seçenek olarak, burada çift ayraç başlatmayı kullanabilirsiniz:

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

Küme ve Liste oluşturmanın birçok yolu vardır. HashSet ve ArrayList sadece iki örnektir. Bu günlerde jenerik ilaçların koleksiyonlarla kullanılması da oldukça yaygındır. Onların ne olduğuna bir göz atmanı öneririm

Bu, Java'nın yerleşik koleksiyonları için iyi bir tanıtımdır. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

List arrList = new ArrayList();

Jenerikleri aşağıda önerildiği gibi kullanmanız daha iyi olur:

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

arrList.add("one");

LinkedList kullanmanız durumunda.

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

Eclipse Koleksiyonlarını kullanarak şöyle bir Liste oluşturabilirsiniz:

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

Değişmez bir liste istiyorsanız:

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

İlkel listeler kullanarak otomatik boksu önleyebilirsiniz. İnt listelerini nasıl oluşturacağınız aşağıda açıklanmıştır:

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 ilkel için de varyantlar vardır.

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

Not: Eclipse Collections için bir komisyoncuyum.

Listeler oluşturmanın bazı yolları aşağıdadır.

• Bu, sabit boyutlu bir liste oluşturur, öğe eklemek / kaldırmak mümkün değildir, bunu yapmaya java.lang.UnsupportedOperationExceptionçalışırsanız bir atar .

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

• Aşağıdaki sürüm, istediğiniz sayıda öğe ekleyebileceğiniz / kaldırabileceğiniz basit bir listedir.

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

• Java'da nasıl oluşturulacağı LinkedList, Listeye öğelerin sık sık eklenmesi / silinmesi gerekiyorsa, LinkedListbunun yerineArrayList

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

Bunu dene:

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

Veya:

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

Tek bir varlık ile serileştirilebilir, değiştirilemez bir listeye ihtiyacınız varsa kullanabilirsiniz:

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

Java'da dizi listesinin bildirimi gibi

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

Java'da dizi listesi oluşturmanın ve başlatmanın birçok yolu vardır.

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