Java-listat sopivat erityisen hyvin ti­lan­tei­siin, joissa tie­to­jou­kon koko ei ole alusta alkaen selvä tai jos sen odotetaan muuttuvan ajan myötä. Esitämme konk­reet­ti­sia esi­merk­ke­jä Java-listojen käytöstä sekä toi­min­nois­ta, joita niiden avulla voi suorittaa.

Mihin Java-listoja voidaan käyttää?

Luettelot ovat yksi Java-oh­jel­moin­nin pe­rus­ra­ken­teis­ta, ja niitä voidaan käyttää monin eri tavoin. Ne si­säl­tä­vät ele­ment­te­jä, jotka on jär­jes­tet­ty jär­jes­tyk­ses­sä. Luet­te­loon voi lisätä, muokata, poistaa tai hakea ele­ment­te­jä. Java-luettelot voivat sisältää eri luokkiin kuuluvia objekteja. Niihin on myös mah­dol­lis­ta tallentaa pääl­lek­käi­siä ele­ment­te­jä tai nol­lae­le­ment­te­jä. Lisäksi Java-luettelot tukevat ge­nee­ri­siä luokkia ja me­ne­tel­miä, mikä takaa tyyp­pi­tur­val­li­suu­den.

Luet­te­loi­ta voidaan käyttää tie­to­kan­ta­so­vel­luk­sis­sa. Niitä käytetään tal­len­ta­maan ja kä­sit­te­le­mään suuria tie­to­ko­ko­nai­suuk­sia tie­to­kan­ta­ky­se­lyis­tä. Graa­fi­sis­sa käyt­tö­liit­ty­mis­sä Java-luet­te­loi­ta käytetään usein ele­ment­tien luettelon näyt­tä­mi­seen, kuten pu­do­tus­va­li­kon vaih­toeh­dot tai verk­ko­kau­pan eri tuotteet.

Java-listat ovat myös vält­tä­mät­tö­miä al­go­rit­meis­sa ja tie­to­ra­ken­teis­sa. Niitä käytetään la­jit­te­lual­go­rit­meis­sa, ha­kual­go­rit­meis­sa sekä pino- ja jo­no­ra­ken­teis­sa. Verk­ko­so­vel­luk­sis­sa listat voivat helpottaa yh­teyk­sien ja lii­tän­tö­jen hallintaa.

Mitä lis­taus­me­ne­tel­miä Java tarjoaa?

Java-listat kuuluvat Col­lec­tion-ra­ja­pin­taan ja ne on tuotava java.util-paketista. Java ArrayList-, Lin­ked­List-, Vector- ja Stack-luokkien avulla voit valita useista eri to­teu­tus­ta­vois­ta. Voit mää­ri­tel­lä listojen eri ins­tans­sit seu­raa­val­la koodilla:

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

Tässä on joitakin tär­keim­piä me­ne­tel­miä, joita voit käyttää Java-luet­te­lois­sa:

  1. int size(): Määrittää luettelon ele­ment­tien lu­ku­mää­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 luet­te­los­sa
  6. boolean add(E e): Lisää elementin luettelon loppuun
  7. boolean remove(Object o): Poistaa elementin en­sim­mäi­sen esiin­ty­män
  8. E get(int index): Korvaa tai lisää elementin mää­ri­tet­tyyn indeksiin
  9. E set(int index, E element): Korvaa tai lisää elementin mää­ri­tet­tyyn indeksiin
  10. Object[] toArray(): Palauttaa taulukon, joka sisältää luettelon elementit
  11. List<E> subList(int fromIndex, int toIndex): Kaappaa kaikki elementit mää­ri­tel­lyl­lä alueella
  12. default void replaceAll(UnaryOperator<E> operator): Java 8:n va­kio­me­ne­tel­mä, joka soveltaa yk­siar­voi­sia Java-ope­raat­to­rei­ta kuhunkin ele­ment­tiin ja korvaa sitten kunkin elementin ope­raa­tion tu­lok­sel­la.

Java-listojen käyttö

Seu­raa­vas­sa esi­tel­lään yleisiä me­ne­tel­miä, joita käytetään Java-listoja kä­si­tel­täes­sä. Näitä ovat muun muassa tau­lu­koi­den muun­ta­mi­nen listoiksi ja päin­vas­toin sekä ele­ment­tien lajittelu, haku ja muok­kaa­mi­nen.

Muunna taulukko luet­te­lok­si

Muunna taulukko luet­te­lok­si tois­ta­mal­la taulukko sil­mu­koil­la ja li­sää­mäl­lä elementit luet­te­loon yksi ker­ral­laan add() -me­ne­tel­mäl­lä.

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

Tämä tuottaa seuraavan tuloksen:

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

Muunna luettelo tau­lu­kok­si

Me­ne­tel­mäl­lä toArray() voit muuntaa luettelon tau­lu­kok­si:

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

Tu­lok­ses­sa voit nähdä, että taulukon ja luettelon elementit ovat ident­ti­siä:

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

Java-luettelon ele­ment­tien kut­su­mi­nen ja muut­ta­mi­nen

get() -me­ne­tel­mäl­lä voit käyttää tiettyyn indeksiin kuuluvaa ele­ment­tiä. set() -me­ne­tel­mäl­lä voit korvata elementin toisella ele­men­til­lä, joka sijaitsee luet­te­los­sa mää­ri­tel­lys­sä kohdassa.

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

Koska Java-kielessä laskenta alkaa in­dek­sis­tä 0, saamme seuraavan tuloksen:

Element at index 1: b
a
b
d
Java

Lajittele luettelo

Voit lajitella Java-listan käyt­tä­mäl­lä Col­lec­tions-luokan .sort() me­ne­tel­mää. Voit käydä listan läpi sil­mu­kal­la ja tulostaa elementit konsoliin yksi ker­ral­laan:

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

Java-luettelon numerot näytetään ruudulla pie­nim­mäs­tä suu­rim­paan:

4
26
57
92
Java

95991e50aeda50c32cb3b3f2112a5943

Siirry pää­va­lik­koon