Lista Java

Java Collection Framework conține interfețe și clase foarte utile care le implementează pentru lucrul cu structurile de date. Se poate spune că acesta este unul dintre cele mai importante cadre JDK. Interfața Listă este foarte populară. pentru că fără tot felul de liste în programare este indispensabil. În acest articol, vom acoperi această interfață, metodele și implementările Java List.

Interfață Java Listă

Cel mai important lucru despre o listă este că este o colecție ordonată . Puteți numi, de asemenea, o secvență. În Java, listele sunt omogene, adică elementele listei sunt de același tip de date. Interfața Java List moștenește de la Collection, moștenește toate operațiunile sale. Pe lângă acestea, în Listă sunt posibile și următoarele operațiuni:

• Acces pozițional. Fiecare element are un index și poate fi manipulat în funcție de poziție. În listă. Adică puteți adăuga, exclude și modifica elemente.
• Căutare. Puteți găsi un element într-o listă după conținutul său și puteți returna indexul acestuia.
• Repetare. Natura secvențială a List permite utilizarea metodelor de iterație (listIterator).
• Vedere-gamă. Metoda sublistei efectuează operații de interval arbitrare pe listă.

Metode de listă Java

Operațiile de mai sus sunt expuse în metodele interfeței Java List. Iată câteva dintre ele:

Implementarea listei

Deoarece List este o interfață, programele trebuie să creeze o implementare concretă a acesteia. Puteți alege dintre următoarele implementări Listă în API-ul Java Collections:

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

Cea mai populară implementare a interfeței List numită ArrayList. Mult mai rar, dar puteți vedea totuși utilizarea LinkedList în sarcini reale, dar Vector și Stack au devenit de mult învechite din punct de vedere moral, așa că cel mai probabil le veți găsi doar în proiectele cu cod vechi vechi.

Declarație de interfață Listă

Puteți declara o listă în programul Java în unul dintre următoarele moduri:

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

Cel mai bine este să declarați o nouă listă printr-o interfață. În mod similar, puteți declara și alte implementări ale List. Cel mai scurt drum:

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

Cu o astfel de declarație, tipul de date al elementelor unor astfel de liste este determinat în timpul inițializării listei, adică atunci când elementele sunt adăugate acolo.

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

Acum pot fi adăugate numai șiruri de caractere la stiva noastră, numere întregi la linkedList , plutesc la myVector , iar myList este o listă de caractere.

Cum funcționează ArrayList

Dacă ești deja familiarizat cu matricele obișnuite, ești oarecum familiarizat cu ArrayList. De fapt, ArrayList este o matrice dinamică, iar în interiorul său se află o matrice obișnuită. Această matrice acționează ca un depozit de date. ArrayList stochează numai tipuri de referință, orice obiecte, inclusiv clase terță parte, șiruri, fluxuri de ieșire și alte colecții. Clasele Wrapper sunt folosite pentru a stoca tipuri de date primitive în ArrayList. Când creăm o listă, putem seta imediat dimensiunea acesteia, dar în cele mai multe cazuri nu o facem. În mod implicit, dimensiunea ArrayList = 10. Cum arată adăugarea unui nou element la o ArrayList? În primul rând, se începe o verificare pentru a vedea dacă există suficient spațiu în matricea internă și dacă se va potrivi încă un element. Dacă există spațiu, noul element este adăugat la sfârșitul listei, adică în celula care urmează ultimului element. Indexul său va fi arraylist.size(). Dacă tocmai am creat lista noastră și este goală, aceasta înseamnă că arrayList.size() = 0. În consecință, un nou element va fi adăugat în celula cu indicele 0. Dacă se dovedește că nu este suficient spațiu, un nou element matricea este creată în interiorul ArrayList cu dimensiunea (dimensiunea OldArray * 1.5) + 1. După același principiu, are loc o inserare în mijlocul listei, dar în același timp, toate elementele care urmează elementului inserat sunt deplasat la dreapta. Deci, dacă avem 5 elemente în matrice și trebuie să inserăm un element în celula numărul 2 (adică a treia), atunci elementele de matrice 0 și 1 rămân la locul lor, un nou element apare în celula 2 și predecesorul său merge la a treia celulă și așa mai departe. un nou element va fi adăugat în celula cu indicele 0. Dacă se dovedește că nu este suficient spațiu, se creează o nouă matrice în interiorul ArrayList cu dimensiunea (dimensiunea OldArray * 1.5) + 1. În același timp principiu, o inserare are loc în mijlocul listei, dar în același timp, toate elementele care urmează elementului inserat sunt deplasate la dreapta. Deci, dacă avem 5 elemente în matrice și trebuie să inserăm un element în celula numărul 2 (adică a treia), atunci elementele de matrice 0 și 1 rămân la locul lor, un nou element apare în celula 2 și predecesorul său merge la a treia celulă și așa mai departe. un nou element va fi adăugat în celula cu indicele 0. Dacă se dovedește că nu este suficient spațiu, se creează o nouă matrice în interiorul ArrayList cu dimensiunea (dimensiunea OldArray * 1.5) + 1. În același timp principiu, o inserare are loc în mijlocul listei, dar în același timp, toate elementele care urmează elementului inserat sunt deplasate la dreapta. Deci, dacă avem 5 elemente în matrice și trebuie să inserăm un element în celula numărul 2 (adică a treia), atunci elementele de matrice 0 și 1 rămân la locul lor, un nou element apare în celula 2 și predecesorul său merge la a treia celulă și așa mai departe. o inserare are loc în mijlocul listei, dar, în același timp, toate elementele care urmează elementului inserat sunt deplasate spre dreapta. Deci, dacă avem 5 elemente în matrice și trebuie să inserăm un element în celula numărul 2 (adică a treia), atunci elementele de matrice 0 și 1 rămân la locul lor, un nou element apare în celula 2 și predecesorul său merge la a treia celulă și așa mai departe. o inserare are loc în mijlocul listei, dar, în același timp, toate elementele care urmează elementului inserat sunt deplasate spre dreapta. Deci, dacă avem 5 elemente în matrice și trebuie să inserăm un element în celula numărul 2 (adică a treia), atunci elementele de matrice 0 și 1 rămân la locul lor, un nou element apare în celula 2 și predecesorul său merge la a treia celulă și așa mai departe.

Exemplu de listă Java (realizarea Arraylist)

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

   }
}

Iată rezultatul acestui program:

Cum funcționează LinkedList

Într-o LinkedList, elementele sunt de fapt verigări din același lanț. Fiecare element, pe lângă datele pe care le stochează, are un link către elementul anterior și următorul. Aceste link-uri vă permit să navigați de la un element la altul. Iteratorul acceptă traversarea în ambele direcții. Implementează metode pentru obținerea, eliminarea și inserarea la începutul, mijlocul și sfârșitul unei liste. Vă permite să adăugați orice elemente, inclusiv null. LinkedList implementează două interfețe - nu numai List, ci și Deque. Acest lucru oferă posibilitatea de a crea o coadă bidirecțională din orice element, chiar și nul. Fiecare obiect plasat în lista legată este un nod (nod). Fiecare nod conține un element, o legătură către nodul anterior și următorul. De fapt, lista legată constă dintr-o secvență de noduri, fiecare dintre ele fiind conceput pentru a stoca un obiect de tipul definit atunci când a fost creat.

Exemplu de cod

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

Ieșirea este aici:

Exemplu de cod vectorial

Vector este, de asemenea, o realizare de matrice dinamică și este foarte asemănătoare cu ArrayList, dar este sincronizată și are unele metode moștenite pe care cadrul de colecție nu le conține. Iată un exemplu simplu de utilizare a acestei clase.

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

   }
}

Ieșirea este:

Cod de clasă Java Stack Exemplu

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 are nu numai metode add() și remove(), ci și push și pop, ele sunt clasice pentru o astfel de structură de date. Stiva respectă regula „primul intrat, ultimul ieșit” - aceasta este o astfel de coadă. Prin urmare, operația pop scoate în evidență elementul care a fost plasat ultima dată pe stivă. Iată rezultatul exemplului nostru: