Java lista

A Java Collection Framework nagyon hasznos felületeket és osztályokat tartalmaz, amelyek megvalósítják ezeket az adatstruktúrákkal való munkavégzéshez. Elmondható, hogy ez az egyik legfontosabb JDK keretrendszer. A Lista felület nagyon népszerű. mert mindenféle listák nélkül a programozásban nélkülözhetetlen. Ebben a cikkben ezt a felületet, a Java List metódusait és megvalósításait ismertetjük.

Java lista interfész

A legfontosabb dolog egy listánál, hogy rendezett gyűjtemény . Nevezhetjük sorozatnak is. Java nyelven a listák homogének, vagyis a lista elemei azonos adattípusúak. A Java List interfész a Collectiontől örökli, örökli annak összes műveletét. Rajtuk kívül a következő műveletek is lehetségesek a Listában:

• Pozíciós hozzáférés. Minden elemnek van indexe, és pozíciójuk alapján manipulálható. a listában. Vagyis hozzáadhat, kizárhat és módosíthat elemeket.
• Keresés. A lista elemeit tartalma alapján találhatja meg, és visszaadhatja az indexét.
• Ismétlés. A List szekvenciális jellege lehetővé teszi az iterációs módszerek (listIterator) használatát.
• Tartomány-nézet. Az allista metódus tetszőleges tartományműveleteket hajt végre a listán.

Java lista módszerek

A fenti műveletek a Java List felület metódusaiban láthatók. Íme néhány közülük:

Lista megvalósítás

Mivel a List egy interfész, a programoknak létre kell hozniuk ennek konkrét megvalósítását. A következő Lista-megvalósítások közül választhat a Java Collections API-ban:

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

A List felület legnépszerűbb megvalósítása, az ArrayList. Sokkal ritkábban, de így is láthatjuk a LinkedList használatát valós feladatokban, de a Vector és a Stack már rég morálisan elavulttá vált, így nagy valószínűséggel csak az ősi örökölt kódú projektekben találja meg őket.

Interfész nyilatkozat listája

A listát a Java programban a következő módok egyikén deklarálhatja:

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

A legjobb, ha egy interfészen keresztül deklarál egy új listát. Hasonlóképpen deklarálhatja a List egyéb megvalósításait is. A legrövidebb út:

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

Egy ilyen deklarációval az ilyen listák elemeinek adattípusa a lista inicializálása során kerül meghatározásra, vagyis amikor elemeket adunk oda.

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

Mostantól csak karakterláncok adhatók a veremünkhöz, egész számok a linkedList- hez, lebegtetések a myVector- hoz , a myList pedig egy karakterlista.

Hogyan működik az ArrayList

Ha már ismeri a szokásos tömböket, akkor valamennyire ismeri az ArrayList-et is. Valójában az ArrayList egy dinamikus tömb, belül pedig egy közönséges tömb. Ez a tömb adattárként működik. Az ArrayList csak hivatkozási típusokat, objektumokat tárol, beleértve a harmadik féltől származó osztályokat, karakterláncokat, kimeneti adatfolyamokat és egyéb gyűjteményeket. A wrapper osztályok primitív adattípusok tárolására szolgálnak az ArrayListben. Lista készítésekor azonnal beállíthatjuk a méretét, de a legtöbb esetben nem. Alapértelmezés szerint az ArrayList mérete = 10. Hogyan néz ki egy új elem hozzáadása egy ArrayListhez? Mindenekelőtt elindul egy ellenőrzés, hogy van-e elég hely a belső tömbben, és hogy belefér-e még egy elem. Ha van szóköz, akkor az új elem a lista végére kerül, vagyis az utolsó elemet követő cellába. Az indexe arraylist.size() lesz. Ha most hoztuk létre a listánkat, és az üres, ez azt jelenti, hogy arrayList.size() = 0. Ennek megfelelően egy új elem kerül a cellába 0 indexszel. Ha kiderül, hogy nincs elég hely, egy új tömb jön létre az ArrayList-en belül (az OldArray mérete * 1,5) + 1. Ugyanezen elv szerint a beillesztés a lista közepén történik, ugyanakkor a beillesztett elemet követő összes elem jobbra tolódott. Tehát ha 5 elemünk van a tömbben, és a 2-es cellába (vagyis a harmadikba) kell egy elemet beszúrnunk, akkor 0 és 1 tömbelem a helyén marad, a 2. cellában új elem jelenik meg, és elődje a harmadik cellába megy és így tovább. egy új elem kerül a 0 indexű cellába. Ha kiderül, hogy nincs elég hely, akkor az ArrayList-en belül egy új tömb jön létre, melynek mérete (az OldArray mérete * 1,5) + 1. elv szerint a beillesztés a lista közepén történik, ugyanakkor a beillesztett elemet követő összes elem jobbra tolódik el. Tehát ha 5 elemünk van a tömbben, és a 2-es cellába (vagyis a harmadikba) kell egy elemet beszúrnunk, akkor 0 és 1 tömbelem a helyén marad, a 2. cellában új elem jelenik meg, és elődje a harmadik cellába megy és így tovább. egy új elem kerül a 0 indexű cellába. Ha kiderül, hogy nincs elég hely, akkor az ArrayList-en belül egy új tömb jön létre, melynek mérete (az OldArray mérete * 1,5) + 1. elv szerint a beillesztés a lista közepén történik, ugyanakkor a beillesztett elemet követő összes elem jobbra tolódik el. Tehát ha 5 elemünk van a tömbben, és a 2-es cellába (vagyis a harmadikba) kell egy elemet beszúrnunk, akkor 0 és 1 tömbelem a helyén marad, a 2. cellában új elem jelenik meg, és elődje a harmadik cellába megy és így tovább. beszúrás történik a lista közepén, ugyanakkor a beszúrt elemet követő összes elem jobbra tolódik el. Tehát ha 5 elemünk van a tömbben, és a 2-es cellába (vagyis a harmadikba) kell egy elemet beszúrnunk, akkor 0 és 1 tömbelem a helyén marad, a 2. cellában új elem jelenik meg, és elődje a harmadik cellába megy és így tovább. beszúrás történik a lista közepén, ugyanakkor a beszúrt elemet követő összes elem jobbra tolódik el. Tehát ha 5 elemünk van a tömbben, és a 2-es cellába (vagyis a harmadikba) kell egy elemet beszúrnunk, akkor 0 és 1 tömbelem a helyén marad, a 2. cellában új elem jelenik meg, és elődje a harmadik cellába megy és így tovább.

Java lista példa (Arraylist megvalósítás)

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

   }
}

Íme a program kimenete:

Hogyan működik a LinkedList

A LinkedListben az elemek valójában ugyanabban a láncban lévő linkek. Minden elemnek az általa tárolt adatokon kívül van egy hivatkozása az előző és a következő elemre. Ezek a hivatkozások lehetővé teszik, hogy egyik elemről a másikra navigáljon. Az iterátor mindkét irányban támogatja a bejárást. Megvalósítja a lista elejére, közepére és végére történő beolvasási, eltávolítási és beszúrási módszereket. Lehetővé teszi bármilyen elem hozzáadását, beleértve a nullát is. A LinkedList két interfészt valósít meg – nem csak a listát, hanem a Deque-et is. Ez lehetővé teszi kétirányú sor létrehozását tetszőleges elemből, akár nullából is. A csatolt listában elhelyezett minden objektum egy csomópont (node). Minden csomópont tartalmaz egy elemet, egy hivatkozást az előző és a következő csomópontra. Valójában a csatolt lista csomópontok sorozatából áll, amelyek mindegyike a létrehozásakor meghatározott típusú objektum tárolására szolgál.

Kódpélda

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

A kimenet itt található:

Példa a vektorkódra

A Vector szintén egy dinamikus tömb-megvalósítás, és nagyon hasonlít az ArrayList-hez, de szinkronizált, és van néhány örökölt metódusa, amelyet a gyűjtési keretrendszer nem tartalmaz. Íme egy egyszerű példa ennek az osztálynak a használatára.

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

   }
}

A kimenet a következő:

Java Stack osztálykód Példa

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

A Stacknek nemcsak add() és remove() metódusai vannak, hanem push és pop is, ezek a klasszikusok az ilyen adatszerkezetekhez. A verem betartja az „első be, utoljára ki” szabályt – ez egy olyan anti-queue. Ezért a pop művelet azt az elemet dobja fel, amely utoljára került a verembe. Íme a példánk kimenete: