# Mikä on Java-lista?

Java-listat sopivat erityisen hyvin tilanteisiin, joissa **tietojoukon koko** ei ole alusta alkaen selvä tai jos sen odotetaan muuttuvan ajan myötä. Esitämme konkreettisia esimerkkejä Java-listojen käytöstä sekä toiminnoista, joita niiden avulla voi suorittaa.

## Mihin Java-listoja voidaan käyttää?

Luettelot ovat yksi Java-ohjelmoinnin perusrakenteista, ja niitä voidaan käyttää monin eri tavoin. Ne sisältävät elementtejä, jotka on järjestetty **järjestyksessä**. Luetteloon voi lisätä, muokata, poistaa tai hakea elementtejä. Java-luettelot voivat sisältää eri luokkiin kuuluvia objekteja. Niihin on myös mahdollista tallentaa päällekkäisiä elementtejä tai nollaelementtejä. Lisäksi Java-luettelot tukevat geneerisiä luokkia ja menetelmiä, mikä takaa tyyppiturvallisuuden.

Luetteloita voidaan käyttää tietokantasovelluksissa. Niitä käytetään tallentamaan ja käsittelemään **suuria tietokokonaisuuksia tietokantakyselyistä**. Graafisissa käyttöliittymissä Java-luetteloita käytetään usein elementtien luettelon näyttämiseen, kuten pudotusvalikon vaihtoehdot tai verkkokaupan eri tuotteet.

Java-listat ovat myös välttämättömiä algoritmeissa ja tietorakenteissa. Niitä käytetään **lajittelualgoritmeissa, hakualgoritmeissa sekä pino- ja jonorakenteissa**. Verkkosovelluksissa listat voivat helpottaa yhteyksien ja liitäntöjen hallintaa.

## Mitä listausmenetelmiä Java tarjoaa?

Java-listat kuuluvat Collection-rajapintaan ja ne on tuotava ***java.util-paketista***. [Java ArrayList-](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-arraylist/), LinkedList-, Vector- ja Stack-luokkien avulla voit valita useista eri toteutustavoista. Voit määritellä listojen eri instanssit seuraavalla koodilla:

```Java
List linkedList = new LinkedList(); // LinkedList
List arrayList = new ArrayList(); // ArrayList
List vecList = new Vector(); // Vector
List stackList = new Stack(); //Stack
```

Tässä on joitakin tärkeimpiä menetelmiä, joita voit käyttää Java-luetteloissa:

1. `int size()`: Määrittää luettelon elementtien lukumäärän
2. `void add(int index, E element)`: Lisää elementin tiettyyn kohtaan
3. `boolean isEmpty()`: Tarkistaa, onko lista tyhjä
4. `void clear()`: Poistaa kaikki elementit listasta
5. `boolean contains(Object o)`: Palauttaa arvon `true`, jos objekti `o` on luettelossa
6. `boolean add(E e)`: Lisää elementin luettelon loppuun
7. `boolean remove(Object o)`: Poistaa elementin ensimmäisen esiintymän
8. `E get(int index)`: Korvaa tai lisää elementin määritettyyn indeksiin
9. `E set(int index, E element)`: Korvaa tai lisää elementin määritettyyn indeksiin
10. `Object[] toArray()`: Palauttaa taulukon, joka sisältää luettelon elementit
11. `List<E> subList(int fromIndex, int toIndex)`: Kaappaa kaikki elementit määritellyllä alueella
12. `default void replaceAll(UnaryOperator<E> operator)`: Java 8:n vakiomenetelmä, joka soveltaa yksiarvoisia Java-operaattoreita kuhunkin elementtiin ja korvaa sitten kunkin elementin operaation tuloksella.

## Java-listojen käyttö

Seuraavassa esitellään yleisiä menetelmiä, joita käytetään Java-listoja käsiteltäessä. Näitä ovat muun muassa taulukoiden **muuntaminen** listoiksi ja päinvastoin sekä elementtien lajittelu, haku ja muokkaaminen.

### Muunna taulukko luetteloksi

Muunna taulukko luetteloksi toistamalla taulukko silmukoilla ja lisäämällä elementit luetteloon yksi kerrallaan `add()` -menetelmällä.

```Java
import java.util.*;
    public class ArrayToList{
      public static void main(String args[]){
      // Creating Array
      String[] colors={"blue","green","red","yellow"};
      System.out.println("Array: "+Arrays.toString(colors));
      //Converting Array to List
      List<String> list=new ArrayList<String>();
      for(String color: colors){
        list.add(color);
      }
      System.out.println("List: "+list);
      }
    }
```

Tämä tuottaa seuraavan tuloksen:

```Java
Array: [blue, green, red, yellow]
List: [blue, green, red, yellow]
```

### Muunna luettelo taulukoksi

Menetelmällä `toArray()` voit muuntaa luettelon taulukoksi:

```Java
import java.util.*;
    public class ListToArray{
      public static void main(String args[]){
       List<String> days = new ArrayList<String>();
       days.add("Monday");
       days.add("Tuesday");
       days.add("Wednesday");
       days.add("Thursday");
       days.add("Friday");
       days.add("Saturday");
       days.add("Sunday");
       // Converting ArrayList to Array
       String[] array = days.toArray(new String[days.size()]);
       System.out.println("Array: "+Arrays.toString(array));
       System.out.println("List: "+days);
      }
    }
```

Tuloksessa voit nähdä, että taulukon ja luettelon elementit ovat identtisiä:

```Java
Array: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
List: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
```

### Java-luettelon elementtien kutsuminen ja muuttaminen

`get()` -menetelmällä voit käyttää tiettyyn indeksiin kuuluvaa elementtiä. `set()` -menetelmällä voit **korvata elementin toisella elementillä, joka** sijaitsee luettelossa määritellyssä kohdassa.

```Java
import java.util.*;
    public class ListExample{
      public static void main(String args[]){
      // Creating a List
      List<String> letters=new ArrayList<String>();
      // Adding elements
      letters.add("a");
      letters.add("b");
      letters.add("c");
      // get()
      System.out.println("Element at index 1: "+letters.get(1));
      // set()
      letters.set(2, "d");
      for(String letter: letters)
      System.out.println(letter);
      }
    }
```

Koska Java-kielessä laskenta alkaa indeksistä 0, saamme seuraavan tuloksen:

```Java
Element at index 1: b
a
b
d
```

### Lajittele luettelo

Voit lajitella Java-listan käyttämällä Collections-luokan `.sort()` menetelmää. Voit käydä listan läpi silmukalla ja tulostaa elementit konsoliin yksi kerrallaan:

```Java
import java.util.*;
    class SortArrayList{
      public static void main(String args[]){
      // Creating a list of numbers
      List<Integer> numbers=new ArrayList<Integer>();
      numbers.add(4);
      numbers.add(57);
      numbers.add(92);
      numbers.add(26);
      // Sorting
      Collections.sort(numbers);
      for(Integer number: numbers)
        System.out.println(number);
      }
    }
```

Java-luettelon numerot näytetään ruudulla pienimmästä suurimpaan:

```Java
4
26
57
92
```


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