Java Ar­ray­Lis­tin käyttö

ArrayList on yksi Java-kielessä eniten käy­te­tyis­tä tie­to­ra­ken­teis­ta. Sen avulla voit muokata ja tallentaa dy­naa­mi­ses­ti objektien kokoelmia. Tässä oppaassa esit­te­lem­me Java Ar­ray­Lis­tin syntaksin ja selitämme, milloin sitä kannattaa käyttää.

Mikä on ero Ar­ray­Lis­tin ja Arrayn välillä Java-kielessä?

Java ArrayList on dy­naa­mi­nen, mikä tar­koit­taa, että sen koko kasvaa ja pienenee, kun ele­ment­te­jä lisätään tai pois­te­taan. On syytä huomata, että ArrayList-luokka on osa Java Col­lec­tions Fra­mewor­kia eikä ole käy­tet­tä­vis­sä na­tii­vis­ti. Toisin kuin taulukot, se on tuotava java.util-kir­jas­tos­ta.

ArrayList-luettelot ovat sopiva valinta, kun Java-luettelon pituus voi vaihdella. Esi­merk­ke­jä ovat objektien tal­len­ta­mi­nen, tietojen haku tai lajittelu sekä luet­te­loi­den tai jonojen luominen.

Sen sijaan taulukon kokoa ei voi muuttaa. Tämä tar­koit­taa, että sinun tulisi mieluiten tietää etukäteen, kuinka monta objektia taulukko tulee si­säl­tä­mään. Taulukot sopivat ennalta mää­ri­tel­ty­jen pri­mi­tii­vis­ten tie­to­tyyp­pien, kuten int, float, char tai Boolean, hal­lin­taan.

ArrayList-luet­te­loi­den hait­ta­puo­le­na on, että niiden käyttö voi kestää kauemmin. Tau­lu­koil­la on kiinteä jatkuva muis­ti­loh­ko, mutta ArrayList-luet­te­loi­den objektit eivät ole tal­len­net­tui­na peräkkäin. On tärkeää ottaa huomioon tie­to­ra­ken­tei­den edut ja haitat, jotta voit valita käyt­tö­tar­koi­tuk­see­si parhaiten sopivan rakenteen.

Mikä on Java Ar­ray­Lis­tin syntaksi?

Ennen ArrayList-luokan luomista vastaava luokka on tuotava java.util-kir­jas­tos­ta.

import java.util.ArrayList;

Yleinen syntaksi on:

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

“Tyyppi” tar­koit­taa vastaavaa tie­to­tyyp­piä Java Ar­ray­Lis­tis­sä.

Seuraava vaihe on luoda luettelot strings ja integers.

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

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

ArrayList-luokat käyttävät vastaavaa pri­mi­tii­vis­ten tie­to­tyyp­pien wrapper-luokkaa, jotta niitä voidaan käsitellä kuin objekteja. Tämä tar­koit­taa, että sinun on mää­ri­tet­tä­vä integer eikä int.

Esi­merk­ke­jä Java ArrayList -me­ne­tel­mis­tä

Ele­ment­tien li­sää­mi­nen tai pois­ta­mi­nen ei tapahdu ArrayList-luokassa Java-ope­raat­to­reil­la, vaan ennalta mää­ri­tel­ty­jen me­ne­tel­mien avulla. Esit­te­lem­me alla ylei­sim­mät ArrayList-me­ne­tel­mät.

Ele­ment­tien li­sää­mi­nen

Kun olemme luoneet ArrayList-luettelon “colours” (String tyyppiä), lisäämme siihen erilaisia ele­ment­te­jä .add() -me­ne­tel­mäl­lä.

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

Tämä johtaa seu­raa­vaan tulokseen:

ArrayList: [blue, red, green]

Ele­ment­tien pois­ta­mi­nen

Pois­taak­sem­me kohteita Java Ar­ray­Lis­tis­tä käytämme .remove() -me­ne­tel­mää ja mää­ri­täm­me elementin indeksin.

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

Tu­lok­ses­sa näkyy muokattu ArrayList ja poistettu elementti:

ArrayList: [blue, green]
Removed Element: red

Kuten useim­mis­sa oh­jel­moin­ti­kie­lis­sä, las­ke­mi­nen Java-kielessä alkaa nollasta. Tämä tar­koit­taa, että in­dek­sis­tä 1 poistettu elementti on red.

Ele­ment­tien käyt­tä­mi­nen Java Ar­ray­Lis­tis­sä

Toiminnon .get() avulla voimme käyttää tiettyyn si­jain­tiin kuuluvaa ele­ment­tiä.

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

Tuloksena saamme:

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

Muuttuvat elementit

.set() avulla voimme muuttaa ele­ment­tiä mää­rit­tä­mäl­lä uuden elementin tiettyyn indeksiin.

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

Nyt näemme indeksin 2 kohdalla yellow sijaan green:

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

Java Ar­ray­Lis­tin pituuden mää­rit­tä­mi­nen

ArrayList-luettelon ele­ment­tien lukumäärä voidaan helposti laskea .size() -me­ne­tel­mäl­lä.

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

Tämä on tulos:

3

Lajittelu ja tois­ta­mi­nen ArrayList-luet­te­los­sa

Java Ar­ray­Lis­tin la­jit­te­le­mi­sek­si on tuotava ko­koel­ma­luok­ka. Ite­roin­tia varten käytämme Java for-each -silmukkaa. Jo­kai­sel­la silmukan ite­roin­nil­la vastaava elementti tu­los­te­taan konsoliin.

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-luettelon elementit näytetään pie­nim­mäs­tä suu­rim­paan:

9
17
20
54

dc8b52a43898356b40686188ee9833ee