# Kas ir Java saraksts?

Java saraksti ir īpaši piemēroti gadījumiem, kad **datu kopas lielums** nav skaidrs jau sākumā vai ja paredzams, ka lielums laika gaitā mainīsies. Mēs parādīsim konkrētus piemērus, kā izmantot Java sarakstus, kā arī darbības, ko ar tiem var veikt.

## Kādiem mērķiem var izmantot Java sarakstus?

Saraksti ir viena no pamata datu struktūrām Java programmēšanā, un tos var izmantot dažādos veidos. Tie satur elementus, kas ir sakārtoti **secīgā secībā**. Sarakstā var pievienot, mainīt, dzēst vai meklēt elementus. Java saraksti var saturēt objektus, kas pieder dažādām klasēm. Ir iespējams arī saglabāt dublikātus elementus vai null elementus. Turklāt Java saraksti atbalsta vispārīgas klases un metodes, nodrošinot tipa drošību.

Sarakstus var izmantot datu bāzes lietojumprogrammās. Šeit tie tiek izmantoti, lai uzglabātu un piekļūtu **lieliem datu kopumiem no datu bāzes vaicājumiem**. Grafiskajās lietotāja saskarnēs Java saraksti bieži tiek izmantoti, lai parādītu elementu sarakstu, piemēram, izvēles iespējas nolaižamajā izvēlnē vai dažādus priekšmetus tiešsaistes veikalā.

Java saraksti ir neaizstājami arī algoritmos un datu struktūrās. Tos izmanto **šķirošanas algoritmos, meklēšanas algoritmos un skriptu un rindu struktūrās**. Tīkla lietojumprogrammās saraksti var palīdzēt atvieglot savienojumu un ligzdu pārvaldību.

## Kādas saraksta metodes ir Java?

Java saraksti pieder Collection interfeisam un ir jāimportē no paketes ***java.util***. Ar [Java ArrayList](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-masivs/), LinkedList, Vector un Stack ir dažādas īstenošanas klases, no kurām var izvēlēties. Sarakstu dažādās instancēs var deklarēt ar šādu kodu:

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

Šeit ir daži no svarīgākajiem paņēmieniem, ko var izmantot Java sarakstos:

1. `int size()`: Nosaka elementu skaitu sarakstā
2. `void add(int index, E element)`: Pievieno elementu konkrētā pozīcijā
3. `boolean isEmpty()`: Pārbauda, vai saraksts ir tukšs
4. `void clear()`: No saraksta izdzēš visus elementus
5. `boolean contains(Object o)`: Atgriež vērtību `true`, ja objekts `o` ir sarakstā
6. `boolean add(E e)`: Pievieno elementu saraksta beigās
7. `boolean remove(Object o)`: Noņem elementa pirmo parādīšanos
8. `E get(int index)`: Aizstāj vai ievieto elementu norādītajā indeksā
9. `E set(int index, E element)`: Aizstāj vai ievieto elementu norādītajā indeksā
10. `Object[] toArray()`: Atgriež masīvu, kas satur elementus no saraksta
11. `List<E> subList(int fromIndex, int toIndex)`: Uztver visus elementus norādītajā intervālā
12. `default void replaceAll(UnaryOperator<E> operator)`: Standarta metode Java 8, kas piemēro vienvietīgos Java operatorus katram elementam un pēc tam aizstāj katru elementu ar operācijas rezultātu.

## Kā lietot Java sarakstus

Tālāk mēs parādīsim visbiežāk izmantotās metodes, strādājot ar Java sarakstiem. Tās ietver masīvu **pārveidošanu** sarakstos un otrādi, kā arī elementu šķirošanu, izgūšanu un modificēšanu.

### Pārvērst masīvu sarakstā

Lai pārvērstu masīvu sarakstā, varat iziet cauri masīvam, izmantojot cilpas, un pievienot elementus sarakstam vienu pēc otra, izmantojot metodi `add()`.

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

Rezultāts ir šāds:

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

### Konvertējiet sarakstu masīvā

Izmantojot metodi `toArray()`, varat konvertēt sarakstu masīvā:

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

Rezultātā var redzēt, ka masīva un saraksta elementi ir identiski:

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

### Sauc un maini elementus Java sarakstā

Izmantojot `get()` metodi, varat piekļūt elementam ar konkrētu indeksu. `set()` metode ļauj **aizstāt elementu ar citu elementu** noteiktā pozīcijā sarakstā.

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

Tā kā skaitīšana Java sākas ar indeksu 0, mēs iegūstam šādu rezultātu:

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

### Kārtot sarakstu

Jūs varat šķirot Java sarakstu, izmantojot `.sort()` metodi no Collections klases. Jūs varat iziet cauri sarakstam, izmantojot cilpu, un izdrukāt elementus uz konsoles vienu pēc otra:

```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 sarakstā esošie skaitļi tiek parādīti ekrānā no mazākā līdz lielākajam:

```Java
4
26
57
92
```


This is a markdown version of: [https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-saraksts/](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-saraksts/) for AI/LLM consumption.