Elenco Java

Il Java Collection Framework contiene interfacce e classi molto utili che le implementano per lavorare con le strutture di dati. Si può dire che questo è uno dei framework JDK più importanti. L'interfaccia List è molto popolare. perché senza tutti i tipi di elenchi nella programmazione è indispensabile. In questo articolo tratteremo questa interfaccia, i metodi e le implementazioni di Java List.

Interfaccia elenco Java

La cosa più importante di un elenco è che si tratta di una raccolta ordinata . Puoi anche chiamarla una sequenza. In Java le liste sono omogenee, ovvero gli elementi della lista sono dello stesso tipo di dati. L'interfaccia Java List eredita da Collection, eredita tutte le sue operazioni. Oltre a queste, in List sono possibili anche le seguenti operazioni:

• Accesso posizionale. Ogni elemento ha un indice e può essere manipolato in base alla loro posizione. nella lista. Cioè, puoi aggiungere, escludere e modificare elementi.
• Ricerca. Puoi trovare un elemento in un elenco in base al suo contenuto e restituirne l'indice.
• Iterazione. La natura sequenziale di List consente l'uso di metodi di iterazione (listIterator).
• Gamma-vista. Il metodo sublist esegue operazioni di intervallo arbitrario sull'elenco.

Metodi dell'elenco Java

Le operazioni di cui sopra sono esposte nei metodi dell'interfaccia Java List. Eccone alcuni:

Implementazione elenco

Poiché List è un'interfaccia, i programmi devono crearne un'implementazione concreta. È possibile scegliere tra le seguenti implementazioni List nell'API delle raccolte Java:

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack

L'implementazione più popolare dell'interfaccia List chiamata ArrayList. Molto meno spesso, ma puoi ancora vedere l'uso di LinkedList in attività reali, ma Vector e Stack sono diventati moralmente obsoleti da molto tempo, quindi molto probabilmente li troverai solo in progetti con codice legacy antico.

Dichiarazione dell'interfaccia dell'elenco

È possibile dichiarare un programma List in Java in uno dei seguenti modi:

List<String> myList = new ArrayList();
List myList1 = new ArrayList();
List myList3 = new ArrayList<String>();
ArrayList arrayList = new ArrayList();

È meglio dichiarare un nuovo elenco tramite un'interfaccia. Allo stesso modo, puoi dichiarare altre implementazioni di List. La via più breve:

Vector myVector = new Vector;
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();

Con una tale dichiarazione, il tipo di dati degli elementi di tali elenchi viene determinato durante l'inizializzazione dell'elenco, cioè quando gli elementi vengono aggiunti lì.

List myList = new ArrayList<String>();
Vector myVector = new Vector();
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();
stack.add("Paul");
linkedList.add(1);
myVector.add(1.2f);
myList.add('a');

Ora solo le stringhe possono essere aggiunte al nostro stack, interi a linkedList , float a myVector e myList è un elenco di caratteri.

Come funziona ArrayList

Se hai già familiarità con gli array regolari, conosci anche ArrayList. In effetti, ArrayList è un array dinamico e al suo interno c'è un array ordinario. Questo array funge da archivio dati. ArrayList memorizza solo i tipi di riferimento, qualsiasi oggetto, incluse classi di terze parti, stringhe, flussi di output e altre raccolte. Le classi wrapper vengono utilizzate per archiviare tipi di dati primitivi in ​​ArrayList. Quando creiamo un elenco, possiamo impostarne immediatamente le dimensioni, ma nella maggior parte dei casi non lo facciamo. Per impostazione predefinita, ArrayList size = 10. Che aspetto ha l'aggiunta di un nuovo elemento a un ArrayList? Prima di tutto, viene avviato un controllo per vedere se c'è abbastanza spazio nell'array interno e se un altro elemento si adatterà. Se c'è spazio, il nuovo elemento viene aggiunto alla fine dell'elenco, cioè alla cella che segue l'ultimo elemento. Il suo indice sarà arraylist.size(). Se abbiamo appena creato il nostro elenco ed è vuoto, ciò significa che arrayList.size() = 0. Di conseguenza, un nuovo elemento verrà aggiunto alla cella con indice 0. Se risulta che non c'è abbastanza spazio, un nuovo l'array viene creato all'interno dell'ArrayList con la dimensione (la dimensione dell'OldArray * 1.5) + 1. Per lo stesso principio, un inserimento avviene al centro dell'elenco, ma allo stesso tempo, tutti gli elementi che seguono l'elemento inserito sono spostato a destra. Quindi, se abbiamo 5 elementi nell'array e dobbiamo inserire un elemento nella cella numero 2 (ovvero la terza), gli elementi dell'array 0 e 1 rimangono al loro posto, un nuovo elemento appare nella cella 2 e il suo predecessore va alla terza cella e così via. un nuovo elemento verrà aggiunto alla cella con indice 0. Se risulta che non c'è abbastanza spazio, viene creato un nuovo array all'interno di ArrayList con la dimensione (la dimensione di OldArray * 1.5) + 1. Con lo stesso principio, un inserimento avviene al centro della lista, ma allo stesso tempo, tutti gli elementi che seguono l'elemento inserito vengono spostati a destra. Quindi, se abbiamo 5 elementi nell'array e dobbiamo inserire un elemento nella cella numero 2 (ovvero la terza), gli elementi dell'array 0 e 1 rimangono al loro posto, un nuovo elemento appare nella cella 2 e il suo predecessore va alla terza cella e così via. un nuovo elemento verrà aggiunto alla cella con indice 0. Se risulta che non c'è abbastanza spazio, viene creato un nuovo array all'interno di ArrayList con la dimensione (la dimensione di OldArray * 1.5) + 1. Con lo stesso principio, un inserimento avviene al centro della lista, ma allo stesso tempo, tutti gli elementi che seguono l'elemento inserito vengono spostati a destra. Quindi, se abbiamo 5 elementi nell'array e dobbiamo inserire un elemento nella cella numero 2 (ovvero la terza), gli elementi dell'array 0 e 1 rimangono al loro posto, un nuovo elemento appare nella cella 2 e il suo predecessore va alla terza cella e così via. un inserimento avviene al centro della lista, ma allo stesso tempo tutti gli elementi che seguono l'elemento inserito vengono spostati a destra. Quindi, se abbiamo 5 elementi nell'array e dobbiamo inserire un elemento nella cella numero 2 (ovvero la terza), gli elementi dell'array 0 e 1 rimangono al loro posto, un nuovo elemento appare nella cella 2 e il suo predecessore va alla terza cella e così via. un inserimento avviene al centro della lista, ma allo stesso tempo tutti gli elementi che seguono l'elemento inserito vengono spostati a destra. Quindi, se abbiamo 5 elementi nell'array e dobbiamo inserire un elemento nella cella numero 2 (ovvero la terza), gli elementi dell'array 0 e 1 rimangono al loro posto, un nuovo elemento appare nella cella 2 e il suo predecessore va alla terza cella e così via.

Esempio di elenco Java (realizzazione dell'elenco di array)

import java.util.*;

public class ArrayListExample2 {
   public static void main(String[] args) {
       List<String> myFriendsList = new ArrayList();
       //we created list of some objects 
       System.out.println( "the size of myList before init = " + myFriendsList.size());
       myFriendsList.add("Alex");
       myFriendsList.add("Tanya");
       myFriendsList.add("Veloxy");
       myFriendsList.add("Alex");
       myFriendsList.add("Andrew");
       System.out.println(myFriendsList);
       System.out.println( "the size of myList after init = " + myFriendsList.size());

       myFriendsList.add("Ihor");
       System.out.println(myFriendsList);
       System.out.println("the size of my list = " +  myFriendsList.size());


       //here the program will print out the first appearance of "Alex" element
       System.out.println(myFriendsList.indexOf("Alex"));
       //program will print out the first appearance of "Alex" element starting from the element 0

       myFriendsList.remove(3);
       System.out.println(myFriendsList.get(3));
       System.out.println("after removing one of Alex's there is only one Alex: " + myFriendsList);
       System.out.println(myFriendsList.get(1));



       myFriendsList.clear();
       System.out.println("the size of the vector after clear method = " +  myFriendsList.size());

   }
}

Ecco l'output di questo programma:

Come funziona LinkedList

In una LinkedList, gli elementi sono in realtà collegamenti nella stessa catena. Ogni elemento, oltre ai dati che memorizza, ha un collegamento all'elemento precedente e successivo. Questi collegamenti consentono di navigare da un elemento all'altro. L'iteratore supporta l'attraversamento in entrambe le direzioni. Implementa metodi per ottenere, rimuovere e inserire all'inizio, al centro e alla fine di un elenco. Consente di aggiungere qualsiasi elemento incluso null. LinkedList implementa due interfacce: non solo List, ma anche Deque. Ciò fornisce la possibilità di creare una coda bidirezionale da qualsiasi elemento, anche nullo. Ogni oggetto inserito nell'elenco collegato è un nodo (nodo). Ogni nodo contiene un elemento, un collegamento al nodo precedente e successivo. Infatti, la lista concatenata è costituita da una sequenza di nodi, ciascuno dei quali è progettato per memorizzare un oggetto del tipo definito al momento della sua creazione.

Esempio di codice

import java.util.*;
public class LinkedListTest {

       public static void main(String args[]){

           List myLinkedList= new LinkedList<Integer>();
           myLinkedList.add(1);
           myLinkedList.add(2);
           myLinkedList.add(4);
           System.out.println("three added elements: " + myLinkedList);
           myLinkedList.add(5);
           myLinkedList.remove(1);
           System.out.println(myLinkedList);
           myLinkedList.size(); //3
           
           //add new element at the specified position:
           myLinkedList.add(2,7);
           System.out.println(myLinkedList);
                }
       }

L'output è qui:

Esempio di codice vettoriale

Vector è anche una realizzazione di array dinamici ed è molto simile a ArrayList, ma sincronizzato e ha alcuni metodi legacy che il framework di raccolta non contiene. Ecco un semplice esempio di utilizzo di questa classe.

import java.util.Vector;

public class VectorExample1 {

   public static void main(String[] args) {
       Vector vector = new Vector();
       System.out.println("the size of the empty vector = " +  vector.size());
       vector.add("Alex");
       vector.add("Tanya");
       vector.add("Andrew");
       System.out.println(vector);
       vector.add("Alex");
       vector.add("Ihor");
       System.out.println(vector);
       System.out.println("the size of the vector = " +  vector.size());
       System.out.println("the first element of the vector = " + vector.firstElement());

       //here the program will print out the first appearance of "Johnny" element
       System.out.println(vector.indexOf("Andrew"));
       //program will print out the first appearance of "Johnny" element starting from the element 1
       System.out.println(vector.indexOf("Alex", 1));
       System.out.println(vector);
       vector.clear();
       System.out.println("the size of the vector after clear method = " +  vector.size());

   }
}

L'uscita è:

Codice classe Java Stack Esempio

import java.util.Stack;

public class StackTest {
   public static void main(String[] args) {
       Stack stack = new Stack();
       System.out.println(stack.isEmpty());
       stack.add("Paul");
       stack.add("Johnny");
       stack.add("Alex");
       System.out.println(stack.isEmpty());
       stack.push("Andrew");
       System.out.println(stack);
       stack.pop();
       System.out.println(stack);
   }
}

Stack non ha solo i metodi add() e remove() ma anche push e pop, sono classici per tale struttura dati. Lo stack obbedisce alla regola "first in, last out" - questo è un tale anti-coda. Pertanto, l'operazione pop estrae l'elemento che è stato inserito per ultimo nello stack. Ecco l'output del nostro esempio: