Java lista

Java Collection Framework innehåller mycket användbara gränssnitt och klasser som implementerar dem för att arbeta med datastrukturer. Man kan säga att detta är ett av de viktigaste JDK-ramverken. Listgränssnittet är mycket populärt. för utan alla möjliga listor i programmering är det oumbärligt. I den här artikeln kommer vi att täcka detta gränssnitt, Java List-metoder och implementeringar.

Java List Interface

Det viktigaste med en lista är att det är en beställd samling. Du kan också kalla det en sekvens. I Java är listor homogena, det vill säga elementen i listan är av samma datatyp. Java List-gränssnitt ärver från Collection, det ärver alla dess operationer. Utöver dem är följande operationer också möjliga i List:

• Positionell åtkomst. Varje element har ett index och kan manipuleras baserat på deras position. i listan. Det vill säga att du kan lägga till, exkludera och ändra element.
• Sök. Du kan hitta ett element i en lista efter dess innehåll och returnera dess index.
• Iteration. Listas sekventiell karaktär tillåter användning av iterationsmetoder (listIterator).
• Räckviddsvy. Sublistmetoden utför godtyckliga intervalloperationer på listan.

Java listmetoder

Ovanstående operationer exponeras i metoderna för Java List-gränssnittet. Här är några av dem:

Listimplementering

Eftersom List är ett gränssnitt måste program skapa en konkret implementering av det. Du kan välja mellan följande listimplementationer i Java Collections API:

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

Den mest populära implementeringen av List-gränssnittet kallas ArrayList. Mycket mindre ofta, men du kan fortfarande se användningen av LinkedList i verkliga uppgifter, men Vector och Stack har blivit moraliskt föråldrade under lång tid, så du kommer med största sannolikhet bara att hitta dem i projekt med gammal äldre kod.

Listgränssnittsdeklaration

Du kan deklarera en lista i Java-program på något av följande sätt:

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

Det är bäst att deklarera en ny lista via ett gränssnitt. På samma sätt kan du deklarera andra implementeringar av List. Kortaste vägen:

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

Med en sådan deklaration bestäms datatypen för elementen i sådana listor under initieringen av listan, det vill säga när element läggs till där.

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 bara strängar läggas till vår stack, heltal till linkedList , flyter till myVector , och myList är en lista med tecken.

Hur ArrayList fungerar

Om du redan är bekant med vanliga arrayer är du också lite bekant med ArrayList. Faktum är att ArrayList är en dynamisk array, och inuti den finns en vanlig array. Denna array fungerar som ett datalager. ArrayList lagrar endast referenstyper, alla objekt, inklusive tredjepartsklasser, strängar, utdataströmmar och andra samlingar. Wrapper-klasser används för att lagra primitiva datatyper i ArrayList. När vi skapar en lista kan vi omedelbart ställa in dess storlek, men i de flesta fall gör vi det inte. Som standard är ArrayList size = 10. Hur ser det ut att lägga till ett nytt element i en ArrayList? Först och främst startas en kontroll för att se om det finns tillräckligt med utrymme i den interna arrayen och om ytterligare ett element får plats. Om det finns utrymme läggs det nya elementet till i slutet av listan, det vill säga i cellen som följer efter det sista elementet. Dess index kommer att vara arraylist.size(). Om vi ​​precis har skapat vår lista och den är tom betyder det att arrayList.size() = 0. Följaktligen kommer ett nytt element att läggas till i cellen med index 0. Om det visar sig att det inte finns tillräckligt med utrymme, kommer en ny array skapas inuti ArrayList med storleken (storleken på OldArray * 1,5) + 1. Enligt samma princip sker en infogning i mitten av listan, men samtidigt är alla element som följer det infogade elementet flyttas åt höger. Så om vi har 5 element i arrayen och vi behöver infoga ett element i cell nummer 2 (det vill säga den tredje), så förblir 0 och 1 arrayelement på plats, ett nytt element dyker upp i cell 2, och dess föregångare går till den tredje cellen och så vidare. ett nytt element kommer att läggas till i cellen med index 0. Om det visar sig att det inte finns tillräckligt med utrymme skapas en ny array inuti ArrayList med storleken (storleken på OldArray * 1,5) + 1. På samma sätt princip, en infogning sker i mitten av listan, men samtidigt förskjuts alla element som följer det infogade elementet åt höger. Så om vi har 5 element i arrayen och vi behöver infoga ett element i cell nummer 2 (det vill säga den tredje), så förblir 0 och 1 arrayelement på plats, ett nytt element dyker upp i cell 2, och dess föregångare går till den tredje cellen och så vidare. ett nytt element kommer att läggas till i cellen med index 0. Om det visar sig att det inte finns tillräckligt med utrymme skapas en ny array inuti ArrayList med storleken (storleken på OldArray * 1,5) + 1. På samma sätt princip, en infogning sker i mitten av listan, men samtidigt förskjuts alla element som följer det infogade elementet åt höger. Så om vi har 5 element i arrayen och vi behöver infoga ett element i cell nummer 2 (det vill säga den tredje), så förblir 0 och 1 arrayelement på plats, ett nytt element dyker upp i cell 2, och dess föregångare går till den tredje cellen och så vidare. en infogning sker i mitten av listan, men samtidigt förskjuts alla element som följer det infogade elementet åt höger. Så om vi har 5 element i arrayen och vi behöver infoga ett element i cell nummer 2 (det vill säga den tredje), så förblir 0 och 1 arrayelement på plats, ett nytt element dyker upp i cell 2, och dess föregångare går till den tredje cellen och så vidare. en infogning sker i mitten av listan, men samtidigt förskjuts alla element som följer det infogade elementet åt höger. Så om vi har 5 element i arrayen och vi behöver infoga ett element i cell nummer 2 (det vill säga den tredje), så förblir 0 och 1 arrayelement på plats, ett nytt element dyker upp i cell 2, och dess föregångare går till den tredje cellen och så vidare.

Java List Exempel (Arraylist realisation)

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

   }
}

Här är resultatet av detta program:

Hur LinkedList fungerar

I en LinkedList är elementen faktiskt länkar i samma kedja. Varje element, förutom den data som lagras, har en länk till föregående och nästa element. Dessa länkar låter dig navigera från ett element till ett annat. Iteratorn stöder traversering i båda riktningarna. Implementerar metoder för att hämta, ta bort och infoga i början, mitten och slutet av en lista. Låter dig lägga till alla element inklusive null. LinkedList implementerar två gränssnitt - inte bara List utan också Deque. Detta ger möjlighet att skapa en dubbelriktad kö från alla element, till och med null. Varje objekt som placeras i den länkade listan är en nod (nod). Varje nod innehåller ett element, en länk till föregående och nästa nod. Faktum är att den länkade listan består av en sekvens av noder, som var och en är utformad för att lagra ett objekt av den typ som definierades när det skapades.

Kodexempel

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

Utgången är här:

Exempel på vektorkod

Vector är också en dynamisk arrayförverkligande och är väldigt lik ArrayList, men synkroniserad och har några äldre metoder som samlingsramverket inte innehåller. Här är ett enkelt exempel på denna klassanvändning.

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

   }
}

Utgången är:

Java Stack-klasskod Exempel

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 inte bara add() och remove() metoder utan även push och pop, de är klassiska för sådan datastruktur. Stacken följer regeln "först in, sist ut" - det här är en sådan anti-kö. Därför poppar popoperationen det element som senast placerades på stapeln. Här är resultatet av vårt exempel: