# Mis on Java nimekiri?

Java nimekirjad sobivad eriti hästi olukordadesse, kus **andmekogumi suurus** ei ole algusest peale selge või kui suurus võib aja jooksul muutuda. Näitame teile konkreetseid näiteid Java nimekirjade kasutamise kohta ning toiminguid, mida nendega teha saab.

## Milleks saab Java nimekirju kasutada?

Loendid on Java programmeerimise üks põhilisi andmestruktuure ja neid saab kasutada mitmel viisil. Need sisaldavad elemente, mis on järjestatud **kindlas järjekorras**. Loendisse saab lisada, muuta, kustutada või otsida elemente. Java loendid võivad sisaldada erinevatesse klassidesse kuuluvaid objekte. Samuti on võimalik salvestada dubleeritud elemente või null-elemente. Lisaks toetavad Java loendid geneerilisi klasse ja meetodeid, tagades tüübikindluse.

Loendeid saab kasutada andmebaasirakendustes. Siin kasutatakse neid **andmebaasi päringutest saadud suurte andmekogumite** salvestamiseks ja neile juurdepääsuks. Graafilistes kasutajaliidestes kasutatakse Java loendeid sageli elementide loendi kuvamiseks, näiteks rippmenüü valikute või veebipoe erinevate toodete puhul.

Java loendid on samuti asendamatud algoritmides ja andmestruktuurides. Neid kasutatakse **sorteerimisalgoritmides, otsingualgoritmides ning virna- ja järjekorrastruktuurides**. Võrgurakendustes võivad loendid aidata hõlbustada ühenduste ja pistikute haldamist.

## Millised loendamise meetodid on Java-s olemas?

Java loendid kuuluvad Collection-liidesesse ja need tuleb importida paketist ***java.util***. [Java ArrayList](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-arraylist/), LinkedList, Vector ja Stack pakuvad mitmesuguseid rakendusklasse, mille hulgast saate valida. Loendite erinevaid instantsi saate deklareerida järgmise koodiga:

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

Siin on mõned olulisemad meetodid, mida saate Java-nimekirjade jaoks kasutada:

1. `int size()`: Määrab loendi elementide arvu
2. `void add(int index, E element)`: Lisab elemendi kindlasse positsiooni
3. `boolean isEmpty()`: Kontrollib, kas nimekiri on tühi
4. `void clear()`: Eemaldab kõik elemendid nimekirjast
5. `boolean contains(Object o)`: Tagastab väärtuse `true`, kui objekt `o` on nimekirjas
6. `boolean add(E e)`: Lisab elemendi nimekirja lõppu
7. `boolean remove(Object o)`: Eemaldab elemendi esimese esinemise
8. `E get(int index)`: Asendab või lisab elemendi määratud indeksile
9. `E set(int index, E element)`: Asendab või lisab elemendi määratud indeksile
10. `Object[] toArray()`: Tagastab massiivi, mis sisaldab nimekirja elemente
11. `List<E> subList(int fromIndex, int toIndex)`: Salvestab kõik elemendid määratud intervalli piires
12. `default void replaceAll(UnaryOperator<E> operator)`: Java 8 standardmeetod, mis rakendab üheargumentilisi Java operaatoreid igale elemendile ja asendab seejärel iga elemendi operatsiooni tulemusega.

## Kuidas kasutada Java nimekirju

Allpool tutvustame tavalisi meetodeid, mida kasutatakse Java-nimekirjadega töötamisel. Nende hulka kuuluvad massiivide **teisendamine** nimekirjadeks ja vastupidi, samuti elementide sorteerimine, otsimine ja muutmine.

### Muuda massiiv nimekirjaks

Massiivi nimekirjaks teisendamiseks võite massiivi läbi käia silmuste abil ja lisada elemendid nimekirja ükshaaval meetodi `add()` abil.

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

Selle tulemuseks on väljund:

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

### Muuda nimekiri massiiviks

Meetodiga `toArray()` saate teisendada loendi massiiviks:

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

Väljundis näete, et massiivi ja loendi elemendid on identsed:

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

### Java nimekirja elementide kutsumine ja muutmine

Meetodiga `get()` saate juurdepääsu elemendile kindla indeksiga. Meetodiga `set()` saate **asendada elemendi teise elemendiga** nimekirja kindlas kohas.

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

Kuna Java-s algab loendamine indeksist 0, saame järgmise tulemuse:

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

### Sorteeri nimekiri

Java nimekirja saab sorteerida, kasutades Collections-klassi `.sort()` meetodit. Nimekirja saab läbi käia silmuse abil ja trükkida elemendid ükshaaval konsooli:

```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 nimekirjas olevad numbrid kuvatakse ekraanil väikseimast suurima järgi:

```Java
4
26
57
92
```


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-nimekiri/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-nimekiri/) for AI/LLM consumption.