Jak zrobić nową listę w Javie

Tworzymy Setjako:

Set myset = new HashSet()

Jak tworzymy Listw Javie?

List myList = new ArrayList();

lub z ogólnymi ( Java 7 lub nowszy)

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

lub z ogólnymi (starsze wersje Java)

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

Dodatkowo, jeśli chcesz utworzyć listę, która zawiera rzeczy (chociaż będzie miała stały rozmiar):

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

Pozwól, że streszczę i dodam coś:

JDK

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

Guawa

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

Niezmienna lista

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

Pusta niezmienna lista

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

Lista znaków

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

Lista liczb całkowitych

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

W Javie 8

Aby utworzyć niepustą listę o stałym rozmiarze (operacje takie jak dodawanie, usuwanie itp. Nie są obsługiwane):

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

Aby utworzyć niepustą zmienną listę:

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

W Javie 9

Korzystanie z nowych List.of(...)statycznych metod fabrycznych:

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

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

W Javie 10

Korzystanie z wnioskowania o typ zmiennej lokalnej :

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

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

var list3 = new ArrayList<String>();

I postępuj zgodnie z najlepszymi praktykami ...

Nie używaj surowych typów

Od Java 5 generics są częścią języka - powinieneś ich używać:

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

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

Program do interfejsów

Na przykład program do Listinterfejsu:

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

Zamiast:

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

Najpierw przeczytaj to , a potem to i to . 9 razy na 10 skorzystasz z jednej z tych dwóch implementacji.

W rzeczywistości po prostu przeczytaj Przewodnik firmy Sun dotyczący ram kolekcji .

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

Od wersji Java 7 można wnioskować o typie dla tworzenia instancji ogólnych , więc nie ma potrzeby duplikowania ogólnych parametrów po prawej stronie przypisania:

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

Listę o stałym rozmiarze można zdefiniować jako:

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

W przypadku niezmiennych list możesz użyć biblioteki Guava :

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

Lista jest tylko interfejsem, tak jak Set .

Podobnie jak HashSet jest implementacją zestawu, który ma pewne właściwości w zakresie dodawania / wyszukiwania / usuwania wydajności, ArrayList jest samą implementacją listy.

Jeśli zajrzysz do dokumentacji odpowiednich interfejsów, znajdziesz „Wszystkie znane klasy implementacyjne” i możesz zdecydować, który jest bardziej odpowiedni dla twoich potrzeb.

Możliwe, że to ArrayList .

Listjest interfejsem podobnym Seti ma ArrayListi LinkedListjako implementacje ogólnego przeznaczenia .

Możemy stworzyć Listę jako:

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

Możemy również utworzyć listę o stałym rozmiarze jako:

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

Prawie zawsze używalibyśmy ArrayListzamiast LinkedListimplementacji:

1. LinkedList zużywa dużo miejsca na przedmioty i działa źle, gdy mamy dużo elementów.
2. Każda indeksowana operacja LinkedListwymaga czasu O (n) w porównaniu do O (1) w ArrayList.
3. Sprawdź ten link, aby uzyskać więcej informacji.

Utworzonej Arrays.asListpowyżej listy nie można modyfikować strukturalnie, ale jej elementy można nadal modyfikować.

Java 8

Zgodnie z dokumentem metoda Collections.unmodifiableListzwraca niemodyfikowalny widok podanej listy. Możemy to uzyskać w następujący sposób:

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

Java 9

W przypadku korzystania z Java 9 :

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

Java 10

Jeśli jesteśmy w Javie 10, metoda Collectors.unmodifiableListzwróci instancję naprawdę niemodyfikowalnej listy wprowadzonej w Javie 9. Sprawdź tę odpowiedź, aby uzyskać więcej informacji na temat różnicy w Collections.unmodifiableList porównaniu Collectors.unmodifiableListz Javą 10 .

Czasami - ale bardzo rzadko - zamiast nowej ArrayList, możesz chcieć nowej LinkedList. Zacznij od ArrayList, a jeśli masz problemy z wydajnością i dowody, że lista stanowi problem, i wiele dodawania i usuwania na tej liście - to - nie wcześniej - przełącz się na LinkedList i sprawdź, czy coś się poprawi. Ale w zasadzie trzymaj się ArrayList i wszystko będzie dobrze.

List list = new ArrayList();

Lub z lekami generycznymi

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

Możesz oczywiście zastąpić ciąg dowolnym rodzajem zmiennej, np. Integer.

Jeden przykład:

List somelist = new ArrayList();

Możesz zajrzeć do javadoc dla List i znaleźć wszystkie znane klasy implementujące Listinterfejs, które są zawarte w java api.

Korzystając z kolekcji Google , możesz użyć następujących metod w klasie Listy

import com.google.common.collect.Lists;

// ...

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

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

Występują przeciążenia związane z inicjowaniem vararg i inicjowaniem z Iterable<T>.

Zaletą tych metod jest to, że nie trzeba jawnie określać parametru ogólnego, tak jak w przypadku konstruktora - kompilator wywnioskuje go na podstawie typu zmiennej.

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

Musisz zaimportować Listi ArrayList.

Więcej opcji, aby zrobić to samo z Javą 8, nie lepiej, nie gorzej, po prostu inaczej i jeśli chcesz wykonać dodatkową pracę z listami, strumienie zapewnią ci więcej możliwości (filtrowanie, mapowanie, zmniejszanie itp.)

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

W Javie 9 możesz wykonać następujące czynności, aby stworzyć niezmienny List :

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

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

Opcjonalnie możesz tutaj użyć inicjowania podwójnego nawiasu klamrowego:

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

Istnieje wiele sposobów tworzenia zestawu i listy. HashSet i ArrayList to tylko dwa przykłady. W dzisiejszych czasach dość powszechne jest stosowanie leków generycznych z kolekcjami. Sugeruję, żebyś spojrzał na to, czym one są

To dobre wprowadzenie do wbudowanych kolekcji Java. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

List arrList = new ArrayList();

Lepiej jest używać ogólnych, jak sugerowano poniżej:

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

arrList.add("one");

W przypadku korzystania z LinkedList.

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

Korzystając z kolekcji Eclipse , możesz utworzyć taką listę:

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

Jeśli chcesz niezmienną listę:

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

Możesz uniknąć automatycznego boxowania, używając list prymitywnych. Oto, w jaki sposób tworzysz listy 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);

Istnieją warianty dla wszystkich 8 prymitywów.

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

Uwaga: jestem osobą odpowiedzialną za kolekcje Eclipse.

Poniżej przedstawiono niektóre sposoby tworzenia list.

• Spowoduje to utworzenie listy o ustalonym rozmiarze, dodawanie / usuwanie elementów nie jest możliwe, wyrzuci, java.lang.UnsupportedOperationExceptionjeśli spróbujesz to zrobić.

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

• Poniższa wersja to prosta lista, w której można dodawać / usuwać dowolną liczbę elementów.

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

• Oto jak utworzyć LinkedListw java. Jeśli chcesz często wstawiać / usuwać elementy z listy, powinieneś użyć LinkedListzamiastArrayList

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

Spróbuj tego:

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

Lub:

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

Jeśli potrzebujesz szeregowej, niezmiennej listy z jednym bytem, ​​możesz użyć:

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

Jak deklaracja listy tablic w java jest jak

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

Istnieje wiele sposobów tworzenia i inicjowania listy tablic w Javie.

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