Kaip naudoti Java ArrayList

ArrayList yra viena iš daž­niau­siai naudojamų duomenų struktūrų Java kalboje. Ji leidžia di­na­miš­kai keisti ir saugoti objektų rinkinį. Šiame pamokų cikle su­pa­žin­din­si­me jus su Java ArrayList sintakse ir pa­aiš­kin­si­me, kada ją naudoti.

Koks yra skirtumas tarp ArrayList ir Array Java kalboje?

Java ArrayList yra di­na­miš­kas, tai reiškia, kad jo dydis didėja ir mažėja, kai elementai yra pridedami arba pa­ša­li­na­mi. Verta paminėti, kad ArrayList klasė yra Java Col­le­c­tions Framework dalis ir nėra prieinama iš karto. Skir­tin­gai nei masyvai, ji turi būti im­por­tuo­ta iš java.util bi­b­lio­te­kos.

Ar­ra­y­Lists yra tinkamas pa­si­rin­ki­mas, kai Java sąrašo ilgis gali kisti. Pa­vyz­džiai: objektų sau­go­ji­mas, duomenų paieška ar rū­šia­vi­mas, sąrašų ar eilių kūrimas.

Prie­šin­gai, masyvo dydžio pakeisti negalima. Tai reiškia, kad idealiu atveju tu­rė­tu­mė­te iš anksto žinoti, kiek objektų tilps į masyvą. Masyvai tinka iš anksto apibrėžtų pri­mi­ty­vių duomenų tipų, pvz., int, float, char arba Boolean, rin­ki­niams tvarkyti.

Vienas iš ArrayList trūkumų yra tai, kad prieiga prie jų gali užtrukti ilgiau. Nors masyvai turi fiksuotą ištisinį atminties bloką, objektai ArrayList nėra saugomi ištisai. Svarbu at­si­žvelg­ti į duomenų struktūrų pri­va­lu­mus ir trūkumus, kad ga­lė­tu­mė­te pa­si­rink­ti tą, kuri ge­riau­siai tinka jūsų naudojimo atvejui.

Kokia yra Java ArrayList sintaksė?

Prieš kuriant ArrayList, ati­tin­ka­ma klasė turi būti im­por­tuo­ta iš java.util bi­b­lio­te­kos.

import java.util.ArrayList;

Bendroji sintaksė yra tokia:

ArrayList<Type> arrayList= new ArrayList<>();

„Type“ reiškia ati­tin­ka­mą duomenų tipą Java ArrayList.

Kitas žingsnis – sudaryti strings ir integers sąrašus.

ArrayList<String> arrayList= new ArrayList<>();

ArrayList<Integer> arrayList= new ArrayList<>();

Ar­ra­y­Lists naudoja ati­tin­ka­mą pri­mi­ty­vių duomenų tipų apgaubimo klasę, kad jie būtų trak­tuo­ja­mi kaip objektai. Tai reiškia, kad turite nurodyti integer, o ne int.

Java ArrayList metodų pa­vyz­džiai

Tokios ope­ra­ci­jos kaip elementų pri­dė­ji­mas ar pa­ša­li­ni­mas nėra at­lie­ka­mos ArrayList sąrašuose naudojant Java ope­ra­to­rius, bet per iš anksto api­brėž­tus metodus. Toliau pa­teik­si­me daž­niau­siai nau­do­ja­mus ArrayList metodus.

Elementų pri­dė­ji­mas

Sukūrę ArrayList „colours“ (String tipo), pridėsime įvairius elementus naudodami .add() metodą.

import java.util.ArrayList;
class Main {
    public static void main(String[] args){
        ArrayList<String> colours = new ArrayList<>();
        colours.add("blue");
        colours.add("red");
        colours.add("green");
        System.out.println("ArrayList: " + colours);
    }
}

Tai duoda tokį rezultatą:

ArrayList: [blue, red, green]

Elementų pa­ša­li­ni­mas

Norėdami pašalinti objektus iš Java ArrayList, naudojame .remove() metodą ir nurodome elemento indeksą.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colours = new ArrayList<>();
        colours.add("blue");
        colours.add("red");
        colours.add("green");
        System.out.println("ArrayList: " + colours);
        String colour = colours.remove(1);
        System.out.println("ArrayList: " + colours);
        System.out.println("Removed Element: " + colour);
    }
}

Re­zul­ta­tas rodo pakeistą ArrayList ir pašalintą elementą:

ArrayList: [blue, green]
Removed Element: red

Kaip ir daugumoje prog­ra­ma­vi­mo kalbų, skai­čia­vi­mas Java kalboje prasideda nuo 0. Tai reiškia, kad pa­ša­lin­tas elementas indekse 1 yra red.

Prieiga prie elementų Java ArrayList

Naudodami funkciją .get(), galime pasiekti elementą tam tikroje po­zi­ci­jo­je.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> clothes = new ArrayList<>();
        clothes.add("jacket");
        clothes.add("shirt");
        clothes.add("pullover");
        System.out.println("ArrayList: " + clothes);
        String str = clothes.get(2);
        System.out.print("Element at index 2: " + str);
    }
}

Gautas re­zul­ta­tas:

ArrayList: [jacket, shirt, pullover]
Element at index 2: pullover

Kintantys elementai

Naudodami .set(), galime pakeisti elementą, pri­skir­da­mi naują elementą tam tikrame indekse.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colours = new ArrayList<>();
        colours.add("blue");
        colours.add("red");
        colours.add("green");
        System.out.println("ArrayList: " + colours);
        colours.set(2, "yellow");
        System.out.println("Modified ArrayList: " + colours);
    }
}

Dabar indeksu 2 matome yellow vietoj green:

ArrayList: [blue, red, green]
Modified ArrayList: [blue, red, yellow]

Java ArrayList ilgio nu­sta­ty­mas

ArrayList elementų skaičių galima lengvai ap­skai­čiuo­ti naudojant .size() metodą.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colours = new ArrayList<>();
        colours.add("blue");
        colours.add("red");
        colours.add("green");
        System.out.println(colours.size());
    }
}

Tai yra re­zul­ta­tas:

3

Rū­šia­vi­mas ir kar­to­ji­mas per ArrayList

Norint rūšiuoti Java ArrayList, reikia im­por­tuo­ti kolekcijų klasę. Ite­ra­ci­jai naudojame Java for-each ciklą. Kiek­vie­nos ciklo ite­ra­ci­jos metu ati­tin­ka­mas elementas išvedamas į konsolę.

import java.util.ArrayList;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> ages = new ArrayList<Integer>();
        ages.add(20);
        ages.add(54);
        ages.add(17);
        ages.add(9);
        Collections.sort(ages);
        for (int i : ages) {
            System.out.println(i);
        }
    }
}

ArrayList elementai rodomi nuo mažiausio iki di­džiau­sio:

9
17
20
54

dc8b52a43898356b40686188ee9833ee

e55dd419814f58a4e87e39befe1f5071

f4923fd8ba30637c20154bb3a1e957db