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:Módszer | Leírás |
---|---|
add (E elem) | Ez a módszer elemelemet ad a lista végéhez. |
add(int index, elem) | A módszer hozzáad egy elemet a lista egy adott indexéhez. Ha egy szükséges paramétert átadott, akkor hozzáadja az elemet a lista végéhez. |
addAll(int index, gyűjtemény gyűjtemény) | Az adott gyűjtemény összes elemét hozzáadja a listához. Ha egyetlen paramétert adunk át, akkor az adott gyűjtemény összes elemét hozzáadja a lista végéhez. |
méret() | A lista méretét adja vissza (a lista elemeinek mennyiségét). |
get(int index) | A megadott indexen lévő elemet adja vissza. |
halmaz(int index, elem) | Egy adott index elemeit lecseréli az új elemre, és visszaadja az új elemre cserélt elemet. |
eltávolítás (int index) | Eltávolít egy elemet a megadott indexből. |
eltávolítás (elem) | Eltávolítja az adott elem első előfordulását a listából. |
egyértelmű() | Eltávolítja az összes elemet a listából. |
indexOf(elem) | Az adott elem első előfordulását adja vissza. Ha az elem nem szerepel a listában, akkor -1 értéket ad vissza . |
lastIndexOf(elem) | Az adott elem utolsó előfordulását adja vissza. Ha az elem nem szerepel a listában, akkor -1 értéket ad vissza . |
egyenlő (elem) | Hasonlítsa össze az adott elem egyenlőségét a lista elemeivel! |
hash kód() | Az adott lista hashcode értékét adja vissza. |
üres() | Ellenőrzi, hogy a lista üres-e. Igaz értéket ad vissza, ha a lista üres. |
(elemet) tartalmaz | Ellenőrzi, hogy a lista tartalmazza-e az elemet . Igaz értéket ad vissza, ha a lista tartalmazza az elemet. |
tartalmazza az összeset (gyűjtemény gyűjtemény) | Ellenőrzi, hogy a lista tartalmazza-e az összes elemgyűjteményt. |
rendezés (összehasonlító comp) | A lista elemeit az adott összehasonlító alapján rendezi. |
allista(int fromIndex, int toIndex) | A listának a megadott fromIndex (beleértve) és toIndex (kizárólag) közötti részét adja vissza. |
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
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:
a myList mérete az init előtt = 0 [Alex, Tanya, Veloxy, Alex, Andrew] a myList mérete az init után = 5 [Alex, Tanya, Veloxy, Alex, Andrew, Ihor] a listám mérete = 6 0 Andrew után az egyik Alex eltávolítása csak egy Alex van: [Alex, Tanya, Veloxy, Andrew, Ihor] Tanya a vektor mérete a törlési metódus után = 0 A folyamat a 0 kilépési kóddal befejeződött
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ó:
három hozzáadott elem: [1, 2, 4] [1, 4, 5] [1, 4, 7, 5]
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ő:
az üres vektor mérete = 0 [Alex, Tanya, Andrew] [Alex, Tanya, Andrew, Alex, Ihor] a vektor mérete = 5 a vektor első eleme = Alex 2 3 [Alex, Tanya, Andrew, Alex, Ihor] a vektor mérete törlési metódus után = 0 A folyamat 0 kilépési kóddal fejeződött be
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:
igaz hamis [Paul, Johnny, Alex, Andrew] [Paul, Johnny, Alex]
GO TO FULL VERSION