java - Een nieuwe lijst maken in Java

We maken een Setals:

Set myset = new HashSet()

Hoe maken we een Listin Java?

Antwoord 1, autoriteit 100%

List myList = new ArrayList();

of met generieke geneesmiddelen (Java 7of hoger )

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

of met generieke geneesmiddelen (oude java-versies)

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

Antwoord 2, autoriteit 48%

Bovendien, als u een lijst wilt maken met dingen erin (hoewel deze een vaste grootte heeft):

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

Antwoord 3, autoriteit 18%

Laat me samenvatten en iets toevoegen:

JDK

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

Guave

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

Onveranderlijke lijst

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

lege onveranderlijke lijst

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

lijst met tekens

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

lijst met gehele getallen

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

4, Autoriteit 7%

in Java 8

Om een niet-lege lijst met vaste formaat (bewerkingen zoals toe te voegen, verwijderen, enz. Te maken, worden niet ondersteund):

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

Om een niet-lege mutable lijst te maken:

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

in Java 9

Een nieuwe List.of(...)statische fabrieksmethoden:

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

in Java 10

Gebruik de Lokale variabele typing inferentie :

var list1 = List.of(1, 2);
var list2 = new ArrayList<>(List.of(3, 4));
var list3 = new ArrayList<String>();

en volg de beste praktijken …

Gebruik geen rauwe typen

Sinds Java 5 zijn generiek een deel van de taal geweest – u zou ze moeten gebruiken:

List<String> list = new ArrayList<>(); // Good, List of String
List list = new ArrayList(); // Bad, don't do that!

-programma voor interfaces

Programma bijvoorbeeld naar de lijst ListINTERFACE:

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

in plaats van:

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

5, Autoriteit 3%

Lees eerst dit , lees dan dit en dit . 9 van de 10 keer zul je gebruik maken van een van deze twee implementaties.

In feite, net gelezen Sun’s Guide to the Collecties framework .

6, Autoriteit 2%

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

7, Autoriteit 2%

Sinds Java 7 u type inference voor generieke bijvoorbeeld creatie , dus er is geen noodzaak om generieke parameters dupliceren aan de rechterkant van de opdracht:

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

een vaste grootte lijst kan worden gedefinieerd als:

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

Voor onveranderlijke lijsten kunt u de Guava bibliotheek te gebruiken:

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

Antwoord 8, autoriteit 2%

Lijstis slechts een interface net als Set.

Zoals HashSet een implementatie is van een Set die bepaalde eigenschappen heeft met betrekking tot het toevoegen/opzoeken/verwijderen van prestaties, is ArrayList de kale implementatie van een List.

Als u de documentatie voor de respectieve interfaces bekijkt, vindt u “Alle bekende implementatieklassen” en kunt u beslissen welke het meest geschikt is voor uw behoeften.

De kans is groot dat het ArrayList.

9

Soms – maar slechts zeer zelden – in plaats van een nieuwe arrayclist, wilt u misschien een nieuwe Linkedlist. Begin met ArrayList en als u prestatieproblemen en bewijs hebt dat de lijst het probleem is, en veel toevoegen en verwijderen in die lijst – dan – niet eerder – schakel over naar een Linkedlist en kijk of het verbeteren. Maar in de main stick met arrayclist en alles komt goed.

10

List list = new ArrayList();

Of met generieke geneesmiddelen

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

Je kunt string natuurlijk ook vervangen door elk type variabele, zoals Integer.

Antwoord 11

Eén voorbeeld:

List somelist = new ArrayList();

Je kunt de javadoc voor lijst bekijken en zoek alle bekende implementatieklassen van de List-interface die bij de Java-API zijn inbegrepen.

Antwoord 12

Met Google Collectionskunt u de volgende methoden gebruiken in de Lijstenklasse

import com.google.common.collect.Lists;
// ...
List<String> strings = Lists.newArrayList();
List<Integer> integers = Lists.newLinkedList();

Er zijn overbelastingen voor het initialiseren en initialiseren van varargs vanaf een Iterable<T>.

Het voordeel van deze methoden is dat u de generieke parameter niet expliciet hoeft op te geven zoals u zou doen bij de constructor – de compiler zal deze afleiden uit het type variabele.

Antwoord 13

Als optie kunt u hier dubbele accolades gebruiken:

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

14

Zoals verklaring van de arraylijst in Java is als

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

Er is een groot aantal manier waarop u de arraylijst in Java kunt maken en initialiseren.

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

15

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

U moet Listen ArrayListimporteren.

16

Meer opties om hetzelfde te doen met Java 8, niet beter, niet slechter, gewoon anders en als je wat extra werk wilt doen met de lijsten, Streams geeft u meer alternatieven (filter, kaart, vermindering, enz.)

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

Antwoord 17

Met Java 9 kunt u het volgende doen om een onveranderlijkeListte maken:

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

Antwoord 18

Er zijn veel manieren om een set en een lijst te maken. HashSet en ArrayList zijn slechts twee voorbeelden. Het is tegenwoordig ook vrij gebruikelijk om generieke geneesmiddelen te gebruiken bij collecties. Ik stel voor dat je eens kijkt naar wat ze zijn

Dit is een goede introductie voor de ingebouwde Java-verzamelingen. http://java.sun.com/javase/6 /docs/technotes/guides/collections/overview.html

Antwoord 19

List arrList = new ArrayList();

Het is beter dat u generieke geneesmiddelen gebruikt zoals hieronder wordt gesuggereerd:

List<String> arrList = new ArrayList<String>();
arrList.add("one");

Als u LinkedList gebruikt.

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

20

Hieronder volgen enkele manieren waarop u lijsten kunt maken.

Hiermee wordt een lijst met vaste grootte gemaakt, Toevoegen / verwijderen -elementen is niet mogelijk, het geeft een java.lang.UnsupportedOperationExceptionAls u probeert doe dat.
```
List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});
```

De volgende versie is een eenvoudige lijst waar u een aantal elementen kunt toevoegen / verwijderen.
```
List<String> list = new ArrayList<>();
```

Hieronder kunt u een LinkedListin Java maken, als u frequent insertion / verwijdering van elementen op de lijst moet doen, moet u LinkedListgebruiken van ArrayList
```
List<String> linkedList = new LinkedList<>();
```

21

Eclipse-collecties U kunt een lijst als volgt maken:

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

Als u een onveranderlijke lijst wilt:

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

U kunt automatisch boksen vermijden met het gebruik van primitieve lijsten. Hier is hoe je int lijsten hebt gemaakt:

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

Er zijn varianten voor alle 8 primitieven.

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

Opmerking:ik ben toegewijd aan Eclipse Collections.

Antwoord 22

Probeer dit:

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

Of:

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

Antwoord 23

Als u een serialiseerbare, onveranderlijke lijst met een enkele entiteit nodig heeft, kunt u het volgende gebruiken:

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

Een nieuwe lijst maken in Java