Kuidas kasutada Java Ar­ray­Lis­t'i

ArrayList on üks Java kõige ka­su­ta­ta­va­maid and­me­st­ruk­tuure. See võimaldab teil dü­naa­mi­li­selt muuta ja sal­ves­tada objektide kogumit. Selles õpetuses tut­vus­tame teile Java ArrayList’i süntaksit ja selgitame, millal seda kasutada.

Mis vahe on Java keeles ArrayList ja Array vahel?

Java ArrayList on dü­naa­mi­line, mis tähendab, et selle suurus kasvab ja kahaneb, kui elemente lisatakse või eemal­da­takse. Tuleb märkida, et ArrayList-klass on osa Java Col­lec­tions Fra­mewor­kist ja ei ole algselt kät­te­saa­dav. Erinevalt mas­sii­vi­dest tuleb see importida java.util-raa­ma­tu­ko­gust.

ArrayList on sobiv valik, kui Java List pikkus võib po­tent­siaal­selt va­rieeruda. Näiteks objektide sal­ves­ta­mine, andmete otsimine või sor­tee­ri­mine ning ni­me­kir­jade või jär­je­kor­dade loomine.

Seevastu massiivi suurust ei ole võimalik muuta. See tähendab, et ideaalis peaksite eelnevalt teadma, kui palju objekte massiiv mahutab. Massiivid sobivad eel­de­fi­nee­ri­tud pri­mi­tiiv­sete and­me­tüü­pide, nagu int, float, char või Boolean, hal­da­miseks.

Ar­ray­Lis­tide üheks puuduseks on see, et nende juur­de­pääs võib võtta kauem aega. Kui mas­sii­vi­del on kindel pidev mälublokk, siis Ar­ray­Lis­tide objektid ei ole jär­jes­tikku sal­ves­ta­tud. On oluline võtta arvesse and­me­st­ruk­tuu­ride eeliseid ja puudusi, et saaksite valida oma ka­su­tus­juh­tu­mile kõige sobivama.

Mis on Java ArrayList’i süntaks?

Enne ArrayList’i loomist tuleb vastav klass importida java.util raa­ma­tu­ko­gust.

import java.util.ArrayList;

Üldine süntaks on:

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

„Type” tähistab vastavat and­me­tüüpi Java Ar­ray­Lis­tis.

Järgmine samm on luua ni­me­kir­jad strings ja integers.

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

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

Ar­ray­Lis­tid kasutavad vastavaid pri­mi­tiiv­seid and­me­tüüpe ümb­rit­se­vaid klasse, et neid saaks käsitleda ob­jek­ti­dena. See tähendab, et peate määrama integer asemel int.

Näited Java ArrayList mee­to­di­test

Ele­men­tide lisamine või eemal­da­mine ei toimu Ar­ray­Lis­ti­des Java ope­raa­to­ri­tega, vaid eel­de­fi­nee­ri­tud meetodite abil. Allpool tut­vus­tame teile kõige le­vi­nu­maid ArrayList meetodeid.

Ele­men­tide lisamine

Pärast ArrayList ‘colours’ (String tüüpi) loomist lisame erinevaid elemente, kasutades meetodit .add().

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

Selle tu­le­mu­seks on:

ArrayList: [blue, red, green]

Ele­men­tide eemal­da­mine

Objektide eemal­da­miseks Java Ar­ray­Lis­tist kasutame meetodit .remove() ja määrame elemendi indeksi.

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

Väljund näitab muudetud ArrayList’i ja eemal­da­tud elementi:

ArrayList: [blue, green]
Removed Element: red

Nagu enamikus prog­ram­mee­ri­mis­keel­tes, algab loen­da­mine Java keeles 0-st. See tähendab, et indeksist 1 eemal­da­tud element on red.

Java Ar­ray­Lis­tis ele­men­ti­dele juur­de­pääs

Funkt­siooni .get() abil saame juur­de­pääsu ele­men­dile kindlas asukohas.

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

Väl­jun­diks saame:

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

Muutuvad elemendid

.set() abil saame muuta elementi, määrates uue elemendi kindlale indeksile.

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

Nüüd näeme indeksil 2 green asemel yellow:

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

Java ArrayList’i pikkuse määramine

Ar­ray­Lis­tis olevate ele­men­tide arvu saab hõlpsasti arvutada, kasutades .size() meetodit.

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

See on tulemus:

3

ArrayList’i sor­tee­ri­mine ja lä­bi­vaa­ta­mine

Java ArrayList’i sor­tee­ri­miseks tuleb importida kol­lekt­sioo­ni­klass. Ite­rat­siooni jaoks kasutame Java for-each-tsüklit. Iga tsükli ite­rat­siooni puhul väl­jas­ta­takse vastav element konsooli.

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’i elemendid kuvatakse väik­sei­mast suurima järgi:

9
17
20
54

dc8b52a43898356b40686188ee9833ee

e55dd419814f58a4e87e39befe1f5071

f4923fd8ba30637c20154bb3a1e957db

f688b820b8660a3cf4e4a5aaedc163ca