Java-lijst

Het Java Collection Framework bevat zeer nuttige interfaces en klassen die deze implementeren voor het werken met datastructuren. Men kan zeggen dat dit een van de belangrijkste JDK-frameworks is. De List-interface is erg populair. want zonder allerlei lijstjes in de programmering is het onmisbaar. In dit artikel behandelen we deze interface, Java List-methoden en implementaties.

Java-lijstinterface

Het belangrijkste van een lijst is dat het een geordende verzameling is. Je kunt het ook een reeks noemen. In Java zijn lijsten homogeen, dat wil zeggen dat de elementen van de lijst van hetzelfde gegevenstype zijn. Java List-interface erft van Collection, het erft al zijn bewerkingen. Daarnaast zijn de volgende bewerkingen ook mogelijk in Lijst:

• Positionele toegang. Elk element heeft een index en kan worden gemanipuleerd op basis van hun positie. in de lijst. Dat wil zeggen, u kunt elementen toevoegen, uitsluiten en wijzigen.
• Zoekopdracht. U kunt een element in een lijst vinden op basis van de inhoud en de index retourneren.
• Iteratie. Het sequentiële karakter van List maakt het gebruik van iteratiemethoden (listIterator) mogelijk.
• Bereikweergave. De sublijstmethode voert willekeurige bereikbewerkingen uit op de lijst.

Java-lijstmethoden

De bovenstaande bewerkingen worden weergegeven in de methoden van de Java List-interface. Hier zijn er een paar:

Lijst implementatie

Omdat List een interface is, moeten programma's er een concrete implementatie van maken. U kunt kiezen uit de volgende List-implementaties in de Java Collections API:

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

De meest populaire implementatie van de List-interface genaamd ArrayList. Veel minder vaak, maar je kunt het gebruik van LinkedList nog steeds in echte taken zien, maar Vector en Stack zijn al lange tijd moreel achterhaald, dus je zult ze hoogstwaarschijnlijk alleen vinden in projecten met oude legacy-code.

Lijst Interfaceverklaring

U kunt een List in Java-programma op een van de volgende manieren declareren:

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

Een nieuwe lijst declareren doe je best via een interface. Op dezelfde manier kunt u andere implementaties van List declareren. De kortste weg:

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

Met zo'n declaratie wordt het datatype van de elementen van dergelijke lijsten bepaald tijdens de initialisatie van de lijst, dat wil zeggen wanneer daar elementen aan worden toegevoegd.

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 kunnen alleen strings aan onze stapel worden toegevoegd, integers aan linkedList , floats aan myVector en myList is een lijst met tekens.

Hoe ArrayList werkt

Als u al bekend bent met reguliere arrays, bent u ook enigszins bekend met ArrayList. ArrayList is in feite een dynamische array en daarbinnen zit een gewone array. Deze array fungeert als een gegevensopslag. ArrayList slaat alleen referentietypen op, alle objecten, inclusief klassen van derden, tekenreeksen, uitvoerstromen en andere verzamelingen. Wrapper-klassen worden gebruikt om primitieve gegevenstypen op te slaan in ArrayList. Bij het maken van een lijst kunnen we meteen de grootte instellen, maar in de meeste gevallen doen we dat niet. Standaard is ArrayList size = 10. Hoe ziet het toevoegen van een nieuw element aan een ArrayList eruit? Allereerst wordt er gekeken of er voldoende ruimte is in de interne array en of er nog een element in past. Als er ruimte is, wordt het nieuwe element toegevoegd aan het einde van de lijst, dat wil zeggen aan de cel die volgt op het laatste element. De index ervan is arraylist.size(). Als we zojuist onze lijst hebben gemaakt en deze is leeg, betekent dit dat arrayList.size() = 0. Dienovereenkomstig wordt een nieuw element toegevoegd aan de cel met index 0. Als blijkt dat er niet genoeg ruimte is, wordt een nieuwe array wordt gemaakt binnen de ArrayList met de grootte (de grootte van de OldArray * 1.5) + 1. Volgens hetzelfde principe vindt een invoeging plaats in het midden van de lijst, maar tegelijkertijd worden alle elementen die volgen op het ingevoegde element naar rechts verschoven. Dus als we 5 elementen in de array hebben, en we moeten een element invoegen in cel nummer 2 (dat wil zeggen, de derde), dan blijven 0 en 1 array-elementen op hun plaats, verschijnt er een nieuw element in cel 2, en zijn voorganger gaat naar de derde cel enzovoort. er wordt een nieuw element toegevoegd aan de cel met index 0. Als blijkt dat er niet genoeg ruimte is, wordt er een nieuwe array gemaakt binnen de ArrayList met de grootte (de grootte van de OldArray * 1.5) + 1. Door dezelfde principe vindt een invoeging plaats in het midden van de lijst, maar tegelijkertijd worden alle elementen die volgen op het ingevoegde element naar rechts verschoven. Dus als we 5 elementen in de array hebben, en we moeten een element invoegen in cel nummer 2 (dat wil zeggen, de derde), dan blijven 0 en 1 array-elementen op hun plaats, verschijnt er een nieuw element in cel 2, en zijn voorganger gaat naar de derde cel enzovoort. er wordt een nieuw element toegevoegd aan de cel met index 0. Als blijkt dat er niet genoeg ruimte is, wordt er een nieuwe array gemaakt binnen de ArrayList met de grootte (de grootte van de OldArray * 1.5) + 1. Door dezelfde principe vindt een invoeging plaats in het midden van de lijst, maar tegelijkertijd worden alle elementen die volgen op het ingevoegde element naar rechts verschoven. Dus als we 5 elementen in de array hebben, en we moeten een element invoegen in cel nummer 2 (dat wil zeggen, de derde), dan blijven 0 en 1 array-elementen op hun plaats, verschijnt er een nieuw element in cel 2, en zijn voorganger gaat naar de derde cel enzovoort. een invoeging vindt plaats in het midden van de lijst, maar tegelijkertijd worden alle elementen die volgen op het ingevoegde element naar rechts verschoven. Dus als we 5 elementen in de array hebben, en we moeten een element invoegen in cel nummer 2 (dat wil zeggen, de derde), dan blijven 0 en 1 array-elementen op hun plaats, verschijnt er een nieuw element in cel 2, en zijn voorganger gaat naar de derde cel enzovoort. een invoeging vindt plaats in het midden van de lijst, maar tegelijkertijd worden alle elementen die volgen op het ingevoegde element naar rechts verschoven. Dus als we 5 elementen in de array hebben, en we moeten een element invoegen in cel nummer 2 (dat wil zeggen, de derde), dan blijven 0 en 1 array-elementen op hun plaats, verschijnt er een nieuw element in cel 2, en zijn voorganger gaat naar de derde cel enzovoort.

Voorbeeld van Java-lijst (realisatie van arraylijst)

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

   }
}

Hier is de uitvoer van dit programma:

Hoe LinkedList werkt

In een LinkedList zijn de elementen eigenlijk schakels in dezelfde keten. Elk element heeft, naast de gegevens die het opslaat, een link naar het vorige en volgende element. Met deze links kunt u van het ene element naar het andere navigeren. De iterator ondersteunt verplaatsing in beide richtingen. Implementeert methoden voor het ophalen, verwijderen en invoegen aan het begin, midden en einde van een lijst. Hiermee kunt u alle elementen toevoegen, inclusief null. LinkedList implementeert twee interfaces - niet alleen List, maar ook Deque. Dit biedt de mogelijkheid om een ​​bidirectionele wachtrij te maken van alle elementen, zelfs null. Elk object dat in de gekoppelde lijst wordt geplaatst, is een knooppunt (knooppunt). Elk knooppunt bevat een element, een link naar het vorige en volgende knooppunt. In feite bestaat de gekoppelde lijst uit een reeks knooppunten, die elk zijn ontworpen om een ​​object op te slaan van het type dat is gedefinieerd toen het werd gemaakt.

Codevoorbeeld

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

De uitvoer is hier:

Voorbeeld van vectorcode

Vector is ook een dynamische array-realisatie en lijkt erg op ArrayList, maar is gesynchroniseerd en heeft een aantal verouderde methoden die het verzamelingsframework niet bevat. Hier is een eenvoudig voorbeeld van het gebruik van deze klasse.

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

   }
}

De uitvoer is:

Java Stack klassecode Voorbeeld

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 heeft niet alleen add() en remove() methoden, maar ook push en pop, die zijn klassiek voor een dergelijke datastructuur. De stapel volgt de regel "first in, last out" - dit is zo'n anti-wachtrij. Daarom popt de pop-bewerking het element dat het laatst op de stapel was geplaatst. Hier is de uitvoer van ons voorbeeld: