# Java ArrayListin käyttö

**ArrayList** on yksi Java-kielessä eniten käytetyistä tietorakenteista. Sen avulla voit muokata ja tallentaa dynaamisesti objektien kokoelmia. Tässä oppaassa esittelemme Java ArrayListin syntaksin ja selitämme, milloin sitä kannattaa käyttää.

## Mikä on ero ArrayListin ja Arrayn välillä Java-kielessä?

Java ArrayList on dynaaminen, mikä tarkoittaa, että sen koko kasvaa ja pienenee, kun elementtejä lisätään tai poistetaan. On syytä huomata, että ArrayList-luokka on osa **Java Collections Frameworkia** eikä ole käytettävissä natiivisti. Toisin kuin taulukot, se on tuotava *java.util-kirjastosta*.

ArrayList-luettelot ovat sopiva valinta, kun [Java-luettelon](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-lista/) pituus voi vaihdella. Esimerkkejä ovat objektien tallentaminen, tietojen **haku tai lajittelu** sekä luetteloiden tai jonojen luominen.

Sen sijaan taulukon kokoa ei voi muuttaa. Tämä tarkoittaa, että sinun tulisi mieluiten tietää etukäteen, kuinka monta objektia taulukko tulee sisältämään. Taulukot sopivat ennalta määriteltyjen **primitiivisten tietotyyppien**, kuten int, float, char tai Boolean, hallintaan.

ArrayList-luetteloiden haittapuolena on, että niiden **käyttö** voi **kestää kauemmin**. Taulukoilla on kiinteä jatkuva muistilohko, mutta ArrayList-luetteloiden objektit eivät ole tallennettuina peräkkäin. On tärkeää ottaa huomioon tietorakenteiden edut ja haitat, jotta voit valita käyttötarkoitukseesi parhaiten sopivan rakenteen.

## Mikä on Java ArrayListin syntaksi?

Ennen ArrayList-luokan luomista vastaava luokka on tuotava *java.util-kirjastosta*.

```Java
import java.util.ArrayList;
```

Yleinen syntaksi on:

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

“Tyyppi” tarkoittaa vastaavaa tietotyyppiä Java ArrayListissä.

Seuraava vaihe on luoda luettelot `strings` ja `integers`.

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

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

ArrayList-luokat käyttävät vastaavaa primitiivisten tietotyyppien **wrapper-luokkaa**, jotta niitä voidaan käsitellä kuin objekteja. Tämä tarkoittaa, että sinun on määritettävä `integer` eikä `int`.

## Esimerkkejä Java ArrayList -menetelmistä

Elementtien lisääminen tai poistaminen ei tapahdu ArrayList-luokassa Java-operaattoreilla, vaan **ennalta määriteltyjen menetelmien** avulla. Esittelemme alla yleisimmät ArrayList-menetelmät.

### Elementtien lisääminen

Kun olemme luoneet ArrayList-luettelon “colours” (`String` tyyppiä), lisäämme siihen erilaisia elementtejä `.add()` -menetelmällä.

```Java
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 seuraavaan tulokseen:

```Java
ArrayList: [blue, red, green]
```

### Elementtien poistaminen

Poistaaksemme kohteita Java ArrayLististä käytämme `.remove()` -menetelmää ja määritämme elementin indeksin.

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

Tuloksessa näkyy muokattu ArrayList ja poistettu elementti:

```Java
ArrayList: [blue, green]
Removed Element: red
```

Kuten useimmissa ohjelmointikielissä, laskeminen Java-kielessä alkaa **nollasta**. Tämä tarkoittaa, että indeksistä 1 poistettu elementti on `red`.

### Elementtien käyttäminen Java ArrayListissä

Toiminnon `.get()` avulla voimme käyttää tiettyyn sijaintiin kuuluvaa elementtiä.

```Java
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:

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

### Muuttuvat elementit

`.set()` avulla voimme muuttaa elementtiä määrittämällä uuden elementin tiettyyn indeksiin.

```Java
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`:

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

### Java ArrayListin pituuden määrittäminen

ArrayList-luettelon elementtien lukumäärä voidaan helposti laskea `.size()` -menetelmällä.

```Java
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:

```Java
3
```

### Lajittelu ja toistaminen ArrayList-luettelossa

Java ArrayListin lajittelemiseksi on tuotava kokoelmaluokka. Iterointia varten käytämme [Java for-each -silmukkaa](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-for-each-silmukka/). Jokaisella silmukan iteroinnilla vastaava elementti tulostetaan konsoliin.

```Java
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 pienimmästä suurimpaan:

```Java
9
17
20
54
```


This is a markdown version of: [https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-arraylist/](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-arraylist/) for AI/LLM consumption.