Java liste

Java Collection Framework indeholder meget nyttige grænseflader og klasser, der implementerer dem til at arbejde med datastrukturer. Det kan siges, at dette er en af ​​de vigtigste JDK-frameworks. List-grænsefladen er meget populær. for uden alle mulige lister i programmering er det uundværligt. I denne artikel vil vi dække denne grænseflade, Java List-metoder og implementeringer.

Java List Interface

Det vigtigste ved en liste er, at det er en bestilt samling. Du kan også kalde det en sekvens. I Java er lister homogene, det vil sige, at listens elementer er af samme datatype. Java List-grænsefladen arver fra Collection, den arver alle dens operationer. Ud over dem er følgende operationer også mulige i List:

• Positionel adgang. Hvert element har et indeks og kan manipuleres baseret på deres position. på listen. Det vil sige, at du kan tilføje, ekskludere og ændre elementer.
• Søg. Du kan finde et element i en liste efter dets indhold og returnere dets indeks.
• Gentagelse. Listens sekventielle karakter tillader brugen af ​​iterationsmetoder (listIterator).
• Range-view. Underlistemetoden udfører arbitrære områdeoperationer på listen.

Java liste metoder

Ovenstående operationer er afsløret i metoderne i Java List-grænsefladen. Her er nogle af dem:

Liste implementering

Fordi List er en grænseflade, skal programmer skabe en konkret implementering af den. Du kan vælge mellem følgende listeimplementeringer i Java Collections API:

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

Den mest populære implementering af List-grænsefladen kaldet ArrayList. Meget sjældnere, men du kan stadig se brugen af ​​LinkedList i rigtige opgaver, men Vector og Stack er blevet moralsk forældede i lang tid, så du vil højst sandsynligt kun finde dem i projekter med gammel legacy-kode.

Listegrænsefladeerklæring

Du kan erklære en liste i Java-program på en af ​​følgende måder:

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

Det er bedst at erklære en ny liste via en grænseflade. På samme måde kan du erklære andre implementeringer af List. Den korteste vej:

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

Med en sådan erklæring bestemmes datatypen for elementerne i sådanne lister under initialiseringen af ​​listen, dvs. når elementer tilføjes der.

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

Nu kan kun strenge tilføjes til vores stak, heltal til linkedList , flyder til myVector , og myList er en liste over tegn.

Sådan fungerer ArrayList

Hvis du allerede er bekendt med almindelige arrays, er du også lidt bekendt med ArrayList. Faktisk er ArrayList et dynamisk array, og indeni det er et almindeligt array. Dette array fungerer som et datalager. ArrayList gemmer kun referencetyper, eventuelle objekter, inklusive tredjepartsklasser, strenge, outputstrømme og andre samlinger. Wrapper-klasser bruges til at gemme primitive datatyper i ArrayList. Når vi opretter en liste, kan vi straks indstille dens størrelse, men i de fleste tilfælde gør vi det ikke. Som standard er ArrayList-størrelse = 10. Hvordan ser det ud at tilføje et nyt element til en ArrayList? Først og fremmest startes et tjek for at se, om der er plads nok i det interne array, og om der kan passe et element mere. Hvis der er plads, tilføjes det nye element til slutningen af ​​listen, det vil sige til den celle, der følger efter det sidste element. Dens indeks vil være arraylist.size(). Hvis vi lige har oprettet vores liste, og den er tom, betyder det, at arrayList.size() = 0. Følgelig vil et nyt element blive tilføjet til cellen med indeks 0. Hvis det viser sig, at der ikke er nok plads, vil en ny array oprettes inde i ArrayList med størrelsen (størrelsen af ​​OldArray * 1.5) + 1. Efter samme princip sker der en indsættelse i midten af ​​listen, men samtidig er alle elementer, der følger efter det indsatte element, flyttet til højre. Så hvis vi har 5 elementer i arrayet, og vi skal indsætte et element i celle nummer 2 (det vil sige den tredje), så forbliver 0 og 1 array-elementer på plads, et nyt element vises i celle 2, og dens forgænger går til den tredje celle og så videre. et nyt element vil blive tilføjet til cellen med indeks 0. Hvis det viser sig, at der ikke er plads nok, oprettes et nyt array inde i ArrayList med størrelsen (størrelsen af ​​OldArray * 1,5) + 1. Ved samme princippet sker en indsættelse i midten af ​​listen, men samtidig forskydes alle elementer, der følger efter det indsatte element, til højre. Så hvis vi har 5 elementer i arrayet, og vi skal indsætte et element i celle nummer 2 (det vil sige den tredje), så forbliver 0 og 1 array-elementer på plads, et nyt element vises i celle 2, og dens forgænger går til den tredje celle og så videre. et nyt element vil blive tilføjet til cellen med indeks 0. Hvis det viser sig, at der ikke er plads nok, oprettes et nyt array inde i ArrayList med størrelsen (størrelsen af ​​OldArray * 1,5) + 1. Ved samme princippet sker en indsættelse i midten af ​​listen, men samtidig forskydes alle elementer, der følger efter det indsatte element, til højre. Så hvis vi har 5 elementer i arrayet, og vi skal indsætte et element i celle nummer 2 (det vil sige den tredje), så forbliver 0 og 1 array-elementer på plads, et nyt element vises i celle 2, og dens forgænger går til den tredje celle og så videre. en indsættelse sker i midten af ​​listen, men samtidig forskydes alle elementer, der følger efter det indsatte element, til højre. Så hvis vi har 5 elementer i arrayet, og vi skal indsætte et element i celle nummer 2 (det vil sige den tredje), så forbliver 0 og 1 array-elementer på plads, et nyt element vises i celle 2, og dens forgænger går til den tredje celle og så videre. en indsættelse sker i midten af ​​listen, men samtidig forskydes alle elementer, der følger efter det indsatte element, til højre. Så hvis vi har 5 elementer i arrayet, og vi skal indsætte et element i celle nummer 2 (det vil sige den tredje), så forbliver 0 og 1 array-elementer på plads, et nyt element vises i celle 2, og dens forgænger går til den tredje celle og så videre.

Java-listeeksempel (arraylist-realisering)

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

   }
}

Her er output fra dette program:

Sådan fungerer LinkedList

I en LinkedList er elementerne faktisk led i samme kæde. Hvert element, ud over de data, det gemmer, har et link til det forrige og næste element. Disse links giver dig mulighed for at navigere fra et element til et andet. Iteratoren understøtter traversering i begge retninger. Implementerer metoder til at hente, fjerne og indsætte i begyndelsen, midten og slutningen af ​​en liste. Giver dig mulighed for at tilføje alle elementer inklusive null. LinkedList implementerer to grænseflader - ikke kun List, men også Deque. Dette giver mulighed for at oprette en tovejskø fra alle elementer, endda null. Hvert objekt placeret i den sammenkædede liste er en node (node). Hver node indeholder et element, et link til den forrige og næste node. Faktisk består den sammenkædede liste af en sekvens af noder, som hver er designet til at gemme et objekt af den type, der blev defineret, da det blev oprettet.

Kode eksempel

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

Output er her:

Eksempel på vektorkode

Vector er også en dynamisk array-realisering og minder meget om ArrayList, men synkroniseret og har nogle ældre metoder, som samlingsrammerne ikke indeholder. Her er et simpelt eksempel på denne klassebrug.

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

   }
}

Udgangen er:

Java Stack klasse kode eksempel

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 har ikke kun add() og remove() metoder, men også push og pop, de er klassiske for en sådan datastruktur. Stakken overholder reglen "først ind, sidst ud" - dette er sådan en anti-kø. Derfor åbner pop-operationen det element, der sidst blev placeret på stakken. Her er outputtet af vores eksempel: