java list how create
Questo tutorial Java List spiega come creare, inizializzare e stampare elenchi in Java. Il tutorial spiega anche l'elenco degli elenchi con un esempio di codice completo:
Questo tutorial ti introdurrà alla struttura dei dati 'list', che è una delle strutture di base nell'interfaccia di raccolta Java.
Un elenco in Java è una sequenza di elementi secondo un ordine. L'interfaccia List del pacchetto java.util è quella che implementa questa sequenza di oggetti ordinati in un modo particolare chiamato List.
=> Controlla TUTTI i tutorial Java qui.
Proprio come gli array, è possibile accedere agli elementi della lista anche utilizzando indici con il primo indice che inizia da 0. L'indice indica un particolare elemento all'indice 'i', cioè è i elementi lontano dall'inizio della lista.
Alcune delle caratteristiche dell'elenco in Java includono:
- Gli elenchi possono avere elementi duplicati.
- L'elenco può anche contenere elementi 'null'.
- Gli elenchi supportano i generici, ovvero puoi avere elenchi generici.
- Puoi anche avere oggetti misti (oggetti di classi diverse) nello stesso elenco.
- Gli elenchi mantengono sempre l'ordine di inserzione e consentono l'accesso posizionale.
Cosa imparerai:
- Elenco in Java
- Conclusione
Elenco in Java
L'interfaccia Java List è un sottotipo dell'interfaccia Java Collection. Questa è l'interfaccia standard che eredita l'interfaccia Collection di Java.
Di seguito è riportato un diagramma delle classi dell'interfaccia Java List.
Come mostrato nel diagramma delle classi sopra, l'interfaccia dell'elenco Java si estende dall'interfaccia Collection del pacchetto java.util che a sua volta si estende dall'interfaccia Iterable del pacchetto java.util. La classe AbstractList fornisce l'implementazione scheletrica dell'interfaccia List.
Le classi LinkedList, Stack, Vector, ArrayList e CopyOnWriteArrayList sono tutte le classi di implementazione dell'interfaccia List utilizzate frequentemente dai programmatori. Quindi ci sono quattro tipi di elenchi in Java, ovvero Stack, LinkedList, ArrayList e Vector.
Quindi, quando è necessario implementare l'interfaccia elenco, è possibile implementare una qualsiasi delle classi di tipi di elenco sopra a seconda dei requisiti. Per includere la funzionalità dell'interfaccia elenco nel tuo programma, dovrai farlo importare il pacchetto java.util. * che contiene l'interfaccia elenco e altre definizioni di classi come segue:
import java.util.*;Crea e dichiara elenco
Abbiamo già affermato che List è un'interfaccia ed è implementata da classi come ArrayList, Stack, Vector e LinkedList. Quindi puoi dichiarare e creare istanze dell'elenco in uno dei seguenti modi:
List linkedlist = new LinkedList(); List arrayList = new ArrayList(); List vec_list = new Vector(); List stck_list = new Stack(); Come mostrato sopra, puoi creare un elenco con una qualsiasi delle classi precedenti e quindi inizializzare questi elenchi con i valori. Dalle affermazioni precedenti, puoi capire che l'ordine degli elementi cambierà a seconda della classe utilizzata per creare un'istanza dell'elenco.
Per esempio, per un elenco con classe stack, l'ordine è Last In, First Out (LIFO).
Inizializza elenco Java
È possibile utilizzare uno dei metodi indicati di seguito per inizializzare un oggetto elenco.
# 1) Utilizzo del metodo asList
Il metodo asList () è già trattato in dettaglio nell'argomento Arrays. È possibile creare un elenco immutabile utilizzando i valori dell'array.
La sintassi generale è:
List listname = Arrays.asList(array_name);Qui, il data_type dovrebbe corrispondere a quello dell'array.
La dichiarazione precedente crea un elenco immutabile. Se vuoi che l'elenco sia modificabile, devi creare un'istanza dell'elenco usando new e quindi assegnargli gli elementi dell'array usando il metodo asList.
Questo è come mostrato di seguito:
List listname = new ArrayList (Arrays.asList(array_name));Andiamo implementare un programma in Java che mostri la creazione e l'inizializzazione della lista utilizzando il metodo asList .
esempi di analisi della causa principale sviluppo di software
import java.util.*; public class Main { public static void main(String() args) { //array of strings String() strArray = {'Delhi', 'Mumbai', 'Kolkata', 'Chennai'}; //initialize an immutable list from array using asList method List mylist = Arrays.asList(strArray); //print the list System.out.println('Immutable list:'); for(String val : mylist){ System.out.print(val + ' '); } System.out.println('
'); //initialize a mutable list(arraylist) from array using asList method List arrayList = new ArrayList(Arrays.asList(strArray)); System.out.println('Mutable list:'); //add one more element to list arrayList.add('Pune'); //print the arraylist for(String val : arrayList){ System.out.print(val + ' '); } } Produzione:
Nel programma sopra, abbiamo creato prima l'elenco immutabile utilizzando il metodo asList. Quindi, creiamo un elenco modificabile creando un'istanza di ArrayList e quindi inizializzando questo ArrayList con i valori dell'array utilizzando il metodo asList.
Nota che poiché la seconda lista è modificabile, possiamo anche aggiungere più valori ad essa.
# 2) Utilizzo di List.add ()
Come già accennato, poiché l'elenco è solo un'interfaccia, non può essere istanziato. Ma possiamo istanziare classi che implementano questa interfaccia. Pertanto, per inizializzare le classi elenco, è possibile utilizzare i rispettivi metodi di aggiunta che è un metodo di interfaccia elenco ma implementato da ciascuna delle classi.
Se tu creare un'istanza di una classe di elenco collegato come di seguito:
List llist = new LinkedList ();Quindi, per aggiungere un elemento a un elenco, puoi utilizzare il metodo add come segue:
llist.add(3);Esiste anche una tecnica chiamata 'Inizializzazione doppia parentesi graffa' in cui l'elenco viene istanziato e inizializzato chiamando il metodo add nella stessa istruzione.
Questo viene fatto come mostrato di seguito:
List llist = new LinkedList (){{ add(1); add(3);}};La dichiarazione precedente aggiunge gli elementi 1 e 3 all'elenco.
Il seguente programma mostra il file inizializzazioni della lista utilizzando il metodo add . Utilizza anche la tecnica di inizializzazione della doppia parentesi graffa.
import java.util.*; public class Main { public static void main(String args()) { // ArrayList.add method List str_list = new ArrayList(); str_list.add('Java'); str_list.add('C++'); System.out.println('ArrayList : ' + str_list.toString()); // LinkedList.add method List even_list = new LinkedList(); even_list.add(2); even_list.add(4); System.out.println('LinkedList : ' + even_list.toString()); // double brace initialization - use add with declaration & initialization List num_stack = new Stack(){{ add(10);add(20); }}; System.out.println('Stack : ' + num_stack.toString()); } }Produzione:
Questo programma ha tre diverse dichiarazioni di elenco, ovvero ArrayList, LinkedList e Stack.
Gli oggetti ArrayList e LinkedList vengono istanziati e quindi vengono chiamati i metodi di aggiunta per aggiungere elementi a questi oggetti. Per lo stack, viene utilizzata l'inizializzazione della doppia parentesi graffa in cui il metodo add viene chiamato durante l'istanza stessa.
# 3) Utilizzo dei metodi di classe delle collezioni
La classe collections di Java dispone di vari metodi che possono essere utilizzati per inizializzare l'elenco.
Alcuni dei metodi sono:
- Aggiungi tutto
Il la sintassi generale per il metodo addAll delle raccolte è:
List listname = Collections.EMPTY_LIST; Collections.addAll(listname = new ArrayList(), values…); Qui, aggiungi valori a un elenco vuoto. Il metodo addAll prende la lista come primo parametro seguito dai valori da inserire nella lista.
- unmodifiableList ()
Il metodo 'unmodifiableList ()' restituisce un elenco immutabile a cui gli elementi non possono essere aggiunti o eliminati.
La sintassi generale di questo metodo è la seguente:
List listname = Collections.unmodifiableList(Arrays.asList(values…));Il metodo accetta i valori di elenco come parametri e restituisce un elenco. Se provi ad aggiungere o eliminare qualsiasi elemento da questo elenco, il compilatore genera un'eccezione UnsupportedOperationException.
- singletonList ()
Il metodo 'singletonList' restituisce un elenco con un singolo elemento al suo interno. L'elenco è immutabile.
La sintassi generale per questo metodo è:
List listname = Collections.singletonList(value);Il seguente programma Java mostra tutti e tre i metodi della classe Collections discusso sopra.
import java.util.*; public class Main { public static void main(String args()) { // empty list List list = new ArrayList(); // Instantiating list using Collections.addAll() Collections.addAll(list, 10, 20, 30, 40); // Print the list System.out.println('List with addAll() : ' + list.toString()); // Create& initialize the list using unmodifiableList method List intlist = Collections.unmodifiableList( Arrays.asList(1,3,5,7)); // Print the list System.out.println('List with unmodifiableList(): ' + intlist.toString()); // Create& initialize the list using singletonList method List strlist = Collections.singletonList('Java'); // Print the list System.out.println('List with singletonList(): ' + strlist.toString()); } }Produzione:
# 4) Utilizzo di Java8 Streams
Con l'introduzione degli stream in Java 8, puoi anche costruire un flusso di dati e raccoglierli in un elenco.
Il seguente programma mostra la creazione di un elenco utilizzando stream.
import java.util.*; import java.util.stream.Collectors; import java.util.stream.Stream; public class Main { public static void main(String args()) { // Creating a List using toList Collectors method List list1 = Stream.of('January', 'February', 'March', 'April', 'May') .collect(Collectors.toList()); // Print the list System.out.println('List from Java 8 stream: ' + list1.toString()); } }Produzione:
Il programma precedente raccoglie il flusso di stringhe in un elenco e lo restituisce. Puoi anche utilizzare gli altri metodi di Collectors come 'toCollection', 'unmodifiableList' ecc. Oltre a asList nella funzione collect.
# 5) Metodo Java 9 List.of ()
Un nuovo metodo è stato introdotto in Java 9, List.of () che accetta un numero qualsiasi di elementi e costruisce un elenco. L'elenco costruito è immutabile.
import java.util.List; public class Main { public static void main(String args()) { // Create a list using List.of() List strList = List.of('Delhi', 'Mumbai', 'Kolkata'); // Print the List System.out.println('List using Java 9 List.of() : ' + strList.toString()); } }Produzione:
Esempio di elenco
Di seguito è riportato un esempio completo dell'utilizzo di un'interfaccia elenco e dei suoi vari metodi.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List intList = new ArrayList(); //add two values to the list intList.add(0, 10); intList.add(1, 20); System.out.println('The initial List:
' + intList); // Creating another list List cp_list = new ArrayList(); cp_list.add(30); cp_list.add(40); cp_list.add(50); // add list cp_list to intList from index 2 intList.addAll(2, cp_list); System.out.println('List after adding another list at index 2:
'+ intList); // Removes element from index 0 intList.remove(0); System.out.println('List after removing element at index 0:
' + intList); // Replace value of last element intList.set(3, 60); System.out.println('List after replacing the value of last element:
' + intList); } } Produzione:
L'output del programma sopra mostra le varie operazioni eseguite su un ArrayList. Innanzitutto, crea e inizializza l'elenco. Quindi copia il contenuto di un altro elenco in questo elenco e rimuove anche un elemento dall'elenco. Infine, sostituisce l'ultimo elemento nell'elenco con un altro valore.
Esploreremo i metodi dell'elenco in dettaglio nel nostro prossimo tutorial.
Elenco di stampa
Esistono vari metodi con cui è possibile stampare gli elementi dell'elenco in Java.
Parliamo di alcuni metodi qui.
come aprire i file jar windows 10
# 1) Utilizzo di For Loop / Enhanced For Loop
L'elenco è una raccolta ordinata a cui è possibile accedere utilizzando gli indici. È possibile utilizzare il ciclo for che viene utilizzato per iterare utilizzando gli indici per stampare ogni elemento della lista.
Java ha un'altra versione di ciclo for nota come ciclo for migliorato che può essere utilizzata anche per accedere e stampare ogni elemento dell'elenco.
Il programma Java mostrato di seguito lo dimostra la stampa del contenuto della lista usando il ciclo for e il ciclo for migliorato.
import java.util.List; import java.util.ArrayList; import java.util.Arrays; class Main{ public static void main (String() args) { //string list List list = Arrays.asList('Java', 'Python', 'C++', 'C', 'Ruby'); //print list using for loop System.out.println('List contents using for loop:'); for (int i = 0; i Produzione:
# 2) Utilizzo del metodo toString
Il metodo 'toString ()' dell'interfaccia elenco restituisce la rappresentazione in formato stringa dell'elenco.
Il programma qui sotto dimostra l'utilizzo del metodo toString ().
import java.util.List; import java.util.ArrayList; class Main{ public static void main (String() args){ //initialize a string list List list = new ArrayList(){{add('Python');add('C++');add('Java');}}; // string representation of list using toString method System.out.println('List contents using toString() method:' + list.toString()); } } Produzione:
Elenco convertito in un array
L'elenco ha un metodo toArray () che converte l'elenco in un array. Una volta convertito in un array, è possibile utilizzare i metodi dell'array discussi nel rispettivo argomento per stampare il contenuto di questo array. È possibile utilizzare il ciclo for o Enhanced for o persino il metodo toString.
L'esempio fornito di seguito utilizza il metodo toString per stampare il contenuto dell'array.
import java.util.*; class Main { public static void main (String() args) { //list of odd numbers List oddlist = Arrays.asList(1,3,5,7,9,11); // using List.toArray() method System.out.println('Contents of list converted to Array:'); System.out.println(Arrays.toString(oddlist.toArray())); } } Produzione:
Utilizzo di Java 8 Streams
I flussi sono introdotti in Java 8. È possibile utilizzare i flussi per scorrere l'elenco. Esistono anche lambda che consentono di scorrere l'elenco.
Il programma qui sotto mostra l'utilizzo di flussi per scorrere l'elenco e visualizzarne il contenuto.
import java.util.*; class Main{ public static void main (String() args){ //list of even numbers List evenlist = Arrays.asList(2,4,6,8,10,12,14); // print list using streams System.out.println('Contents of evenlist using streams:'); evenlist.stream().forEach(S ->System.out.print(S + ' ')); } } Produzione:
Oltre ai metodi discussi sopra, è possibile utilizzare gli iteratori di elenco per scorrere l'elenco e visualizzarne il contenuto. Avremo un articolo completo sull'iteratore di lista nei tutorial successivi.
Elenco degli elenchi
L'interfaccia dell'elenco Java supporta 'l'elenco degli elenchi'. In questo, i singoli elementi della lista sono di nuovo una lista. Ciò significa che puoi avere un elenco all'interno di un altro elenco.
Questo concetto è molto utile quando devi leggere dati da file CSV. In questo caso, potrebbe essere necessario leggere più elenchi o elenchi all'interno di elenchi e quindi archiviarli in memoria. Ancora una volta dovrai elaborare questi dati e riscrivere nel file. Pertanto, in tali situazioni, è possibile mantenere un elenco di elenchi per semplificare l'elaborazione dei dati.
Il seguente programma Java mostra un esempio di un elenco di elenchi Java.
In questo programma, abbiamo un elenco di elenchi di tipo String. Creiamo due elenchi separati di tipo stringa e assegniamo valori a questi elenchi. Entrambi questi elenchi vengono aggiunti all'elenco degli elenchi utilizzando il metodo add.
Per visualizzare il contenuto dell'elenco di elenchi, utilizziamo due cicli. Il ciclo esterno (foreach) scorre gli elenchi di elenchi che accedono agli elenchi. Il ciclo foreach interno accede ai singoli elementi stringa di ciascuno di questi elenchi.
import java.util.ArrayList; import java.util.List; public class Main { public static void main(String() args) { //create list of lists List java_listOfLists = new ArrayList (); //create a language list and add elements to it ArrayList lang_list = new ArrayList(); lang_list.add('Java'); lang_list.add('C++'); //add language list to java list of list java_listOfLists.add(lang_list); //create a city list and add elements to it ArrayList city_list = new ArrayList(); city_list.add('Pune'); city_list.add('Mumbai'); //add the city list to java list of lists java_listOfLists.add(city_list); //display the contents of list of lists System.out.println('Java list of lists contents:'); java_listOfLists.forEach((list) -> //access each list { list.forEach((city)->System.out.print(city + ' ')); //each element of inner list }); } } Produzione:
L'elenco di elenchi Java è un concetto piccolo, ma è importante soprattutto quando devi leggere dati complessi nel tuo programma.
Domande frequenti
D # 1) Che cos'è un elenco e un set in Java?
Risposta: Un elenco è una raccolta ordinata di elementi. Puoi avere elementi duplicati nell'elenco.
Un set non è una collezione ordinata. Gli elementi del set non sono disposti in un ordine particolare. Inoltre, gli elementi del set devono essere unici. Non consente duplicati.
D # 2) Come funziona un elenco in Java?
Risposta: L'elenco è un'interfaccia in Java che si estende dall'interfaccia Collection. Le classi ArrayList, LinkedList, Stack e Vector implementano l'interfaccia dell'elenco. Pertanto un programmatore può utilizzare queste classi per utilizzare la funzionalità dell'interfaccia elenco.
D # 3) Cos'è un ArrayList in Java?
Risposta: ArrayList è un array dinamico. È una raccolta di elementi ridimensionabile e implementa l'interfaccia dell'elenco. ArrayList utilizza internamente un array per memorizzare gli elementi.
D # 4) Gli elenchi iniziano da 0 o 1 in Java?
Risposta: Gli elenchi in Java hanno un indice intero a base zero. Ciò significa che il primo elemento nell'elenco è all'indice 0, il secondo all'indice 1 e così via.
D # 5) L'elenco è ordinato?
Risposta: Sì. L'elenco è una raccolta ordinata di elementi. Questo ordine viene mantenuto, durante l'inserimento di un nuovo elemento nella lista,
Conclusione
Questo tutorial ha fornito un'introduzione all'interfaccia dell'elenco in Java. Abbiamo anche discusso i principali concetti di elenchi come creazione, inizializzazione di elenchi, stampa di elenchi, ecc.
Nei nostri prossimi tutorial, discuteremo i vari metodi forniti dall'interfaccia dell'elenco. Discuteremo anche il costrutto iteratore utilizzato per iterare l'oggetto elenco. Discuteremo la conversione degli oggetti elenco in altre strutture dati nel nostro prossimo tutorial.
=> Visita qui per vedere la serie di formazione Java per tutti.
Lettura consigliata
- Array Java: dichiara, crea e inizializza un array in Java
- Matrice di oggetti in Java: come creare, inizializzare e utilizzare
- Java Hello World - Crea il tuo primo programma in Java oggi
- Distribuzione Java: creazione ed esecuzione di file JAR Java
- Java Virtual Machine: come JVM aiuta nell'esecuzione di applicazioni Java
- Modificatori di accesso in Java - Tutorial con esempi
- Tutorial Java Reflection con esempi
- Introduzione al linguaggio di programmazione Java - Tutorial video
