Come creare un nuovo elenco in Java

Creiamo un Setas:

Set myset = new HashSet()

Come creiamo un Listin Java?

List myList = new ArrayList();

o con generici ( Java 7 o successivi)

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

o con generici (vecchie versioni java)

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

Inoltre, se si desidera creare un elenco contenente elementi (anche se avrà dimensioni fisse):

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

Vorrei riassumere e aggiungere qualcosa:

JDK

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

Guaiava

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

Elenco immutabile

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

Elenco vuoto immutabile

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

Elenco dei personaggi

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

Elenco di numeri interi

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

In Java 8

Per creare un elenco non vuoto di dimensioni fisse (operazioni come aggiungi, rimuovi, ecc., Non sono supportate):

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

Per creare un elenco mutabile non vuoto:

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

In Java 9

Utilizzando un nuovo List.of(...)metodo statico di fabbrica:

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

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

In Java 10

Utilizzo dell'inferenza del tipo di variabile locale :

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

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

var list3 = new ArrayList<String>();

E segui le migliori pratiche ...

Non usare tipi grezzi

Da Java 5, i generici fanno parte del linguaggio - dovresti usarli:

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

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

Programma per le interfacce

Ad esempio, programma per l' Listinterfaccia:

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

Invece di:

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

Prima leggi questo , poi leggi questo e questo . 9 volte su 10 userete una di quelle due implementazioni.

In effetti, basta leggere la Guida di Sun al framework Collezioni .

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

Da Java 7 hai l' inferenza del tipo per la creazione di istanze generiche , quindi non è necessario duplicare i parametri generici sul lato destro dell'assegnazione:

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

Un elenco di dimensioni fisse può essere definito come:

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

Per elenchi immutabili puoi usare la libreria Guava :

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

Elenco è solo un'interfaccia come Set .

Come HashSet è un'implementazione di un set che ha determinate proprietà per quanto riguarda l'aggiunta / ricerca / rimozione delle prestazioni, ArrayList è la semplice implementazione di un elenco.

Se dai un'occhiata alla documentazione per le rispettive interfacce troverai "Tutte le classi di implementazione conosciute" e puoi decidere quale è più adatta alle tue esigenze.

È probabile che sia ArrayList .

Listè un'interfaccia simile Sete ha ArrayListe LinkedListcome implementazioni per scopi generali .

Possiamo creare un elenco come:

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

Possiamo anche creare un elenco di dimensioni fisse come:

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

Useremo quasi sempre in ArrayListcontrapposizione LinkedListall'implementazione:

1. LinkedList usa molto spazio per gli oggetti e si comporta male quando abbiamo molti elementi.
2. Qualsiasi operazione indicizzata in LinkedListrichiede tempo O (n) rispetto a O (1) in ArrayList.
3. Controlla questo link per maggiori informazioni.

L'elenco creato Arrays.asListsopra non può essere modificato strutturalmente ma i suoi elementi possono ancora essere modificati.

Java 8

Come da documento , il metodo Collections.unmodifiableListrestituisce una vista non modificabile dell'elenco specificato. Possiamo ottenerlo come:

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

Java 9

Nel caso in cui stiamo usando Java 9, allora:

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

Java 10

Nel caso in cui ci troviamo in Java 10, il metodo Collectors.unmodifiableListrestituirà un'istanza di un elenco davvero non modificabile introdotto in Java 9. Controlla questa risposta per ulteriori informazioni sulla differenza tra Collections.unmodifiableList vs Collectors.unmodifiableListin Java 10 .

A volte - ma solo molto raramente - invece di una nuova ArrayList, potresti desiderare una nuova LinkedList. Inizia con ArrayList e se hai problemi di prestazioni e prove che l'elenco è il problema, e molte aggiunte e cancellazioni a quell'elenco - quindi - non prima - passa a un LinkedList e vedi se le cose migliorano. Ma soprattutto, segui ArrayList e tutto andrà bene.

List list = new ArrayList();

O con generici

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

Naturalmente, puoi sostituire la stringa con qualsiasi tipo di variabile, come Integer, anche.

Un esempio:

List somelist = new ArrayList();

Puoi guardare javadoc per List e trovare tutte le classi di implementazione conosciute Listdell'interfaccia che sono incluse con l'API Java.

Utilizzando Google Collections , puoi utilizzare i seguenti metodi nella classe Elenchi

import com.google.common.collect.Lists;

// ...

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

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

Ci sono sovraccarichi per l'inizializzazione e l'inizializzazione di varargs da un Iterable<T>.

Il vantaggio di questi metodi è che non è necessario specificare esplicitamente il parametro generico come si farebbe con il costruttore: il compilatore lo inferirà dal tipo di variabile.

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

È necessario importare Liste ArrayList.

Altre opzioni per fare la stessa cosa con Java 8, non meglio, non peggio, solo diverse e se vuoi fare un lavoro extra con gli elenchi, Stream ti fornirà più alternative (filtro, mappa, riduzione, ecc.)

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

Con Java 9, è possibile effettuare le seguenti operazioni per creare un immutabile List :

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

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

Come opzione è possibile utilizzare l'inizializzazione doppia parentesi qui:

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

Esistono molti modi per creare un set e un elenco. HashSet e ArrayList sono solo due esempi. Al giorno d'oggi è anche abbastanza comune usare generici con collezioni. Ti suggerisco di dare un'occhiata a cosa sono

Questa è una buona introduzione per le collezioni integrate di Java. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

List arrList = new ArrayList();

È meglio usare generici come suggerito di seguito:

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

arrList.add("one");

Nel caso in cui si usi LinkedList.

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

Usando le raccolte Eclipse puoi creare un elenco come questo:

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

Se vuoi un elenco immutabile:

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

È possibile evitare l'auto-box utilizzando elenchi primitivi. Ecco come creare elenchi 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);

Esistono varianti per tutti e 8 i primitivi.

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

Nota: sono un committer per le raccolte Eclipse.

Di seguito sono riportati alcuni modi in cui è possibile creare elenchi.

• Questo creerà un elenco con dimensioni fisse, non è possibile aggiungere / rimuovere elementi, java.lang.UnsupportedOperationExceptionse si tenta di farlo verrà generato un .

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

• La seguente versione è un semplice elenco in cui è possibile aggiungere / rimuovere qualsiasi numero di elementi.

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

• Ecco come creare un file LinkedListin java, se devi fare frequenti inserimenti / cancellazioni di elementi nell'elenco, dovresti usare LinkedListinvece diArrayList

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

Prova questo:

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

O:

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

Se hai bisogno di un elenco serializzabile e immutabile con una singola entità puoi usare:

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

Come dichiarazione dell'elenco di array in Java è simile

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

Esistono numerosi modi per creare e inizializzare l'elenco di array in 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();