# Kā lietot Java ArrayList

**ArrayList** ir viena no visbiežāk izmantotajām datu struktūrām Java. Tā ļauj dinamiski modificēt un saglabāt objektu kopu. Šajā apmācībā iepazīstināsim jūs ar Java ArrayList sintaksi un izskaidrosim, kad to lietot.

## Kāda ir atšķirība starp ArrayList un Array Java valodā?

Java ArrayList ir dinamisks, kas nozīmē, ka tā izmērs palielinās vai samazinās, kad tiek pievienoti vai noņemti elementi. Ir vērts atzīmēt, ka ArrayList klase ir daļa no **Java Collections Framework** un nav pieejama nativā veidā. Atšķirībā no masīviem, tā ir jāimportē no *java.util* bibliotēkas.

ArrayLists ir piemērota izvēle, ja [Java List](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-saraksts/) garums var mainīties. Piemēri ietver objektu uzglabāšanu, datu **meklēšanu vai šķirošanu**, kā arī sarakstu vai rindu veidošanu.

Turpretim masīva izmēru mainīt nav iespējams. Tas nozīmē, ka ideālā gadījumā jums jau iepriekš jāzina, cik daudz objektu masīvs ietilps. Masīvi ir piemēroti, lai pārvaldītu iepriekš definētu **primitīvo datu tipu** kopumu, piemēram, int, float, char vai Boolean.

Viens no ArrayLists trūkumiem ir tas, **ka piekļuve tiem** var **aizņemt vairāk laika**. Kamēr masīviem ir fiksēts nepārtraukts atmiņas bloks, objekti ArrayLists netiek glabāti secīgi. Ir svarīgi ņemt vērā datu struktūru priekšrocības un trūkumus, lai varētu izvēlēties to, kas vislabāk atbilst jūsu lietošanas gadījumam.

## Kāda ir Java ArrayList sintakse?

Pirms ArrayList izveidošanas atbilstošā klase ir jāimportē no *java.util* bibliotēkas.

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

Vispārīgā sintakse ir:

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

„Tips” apzīmē attiecīgo datu tipu Java ArrayList.

Nākamais solis ir izveidot sarakstus ar `strings` un `integers`.

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

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

ArrayLists izmanto atbilstošo primitīvo datu tipu **ietverošo klasi**, lai tos apstrādātu kā objektus. Tas nozīmē, ka jums jānorāda `integer`, nevis `int`.

## Java ArrayList metožu piemēri

Darbības, piemēram, elementu pievienošana vai noņemšana, ArrayList sarakstos netiek veiktas ar Java operatoriem, bet gan ar **iepriekš definētām metodēm**. Turpmāk parādīsim visbiežāk izmantotās ArrayList metodes.

### Elementu pievienošana

Pēc ArrayList ‘colours’ (`String` tipa) izveidošanas mēs pievienosim dažādus elementus, izmantojot `.add()` metodi.

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

Rezultāts ir šāds:

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

### Elementu noņemšana

Lai no Java ArrayList izņemtu objektus, mēs izmantojam `.remove()` metodi un norādām elementa indeksu.

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

Rezultātā tiek parādīts modificētais ArrayList un elements, kas ir ticis noņemts:

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

Tāpat kā lielākajā daļā programmēšanas valodu, skaitīšana Java sākas no 0. Tas nozīmē, ka izņemtais elements indeksā 1 ir `red`.

### Piekļuve elementiem Java ArrayList

Izmantojot funkciju `.get()`, mēs varam piekļūt elementam konkrētā pozīcijā.

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

Rezultātā iegūstam:

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

### Mainīgie elementi

Ar `.set()` mēs varam mainīt elementu, piešķirot jaunu elementu konkrētā indeksā.

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

Tagad indeksā 2 redzam `yellow`, nevis `green`:

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

### Java ArrayList garuma noteikšana

ArrayList elementu skaitu var viegli aprēķināt, izmantojot `.size()` metodi.

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

Šis ir rezultāts:

```Java
3
```

### Kārtēšana un iterēšana caur ArrayList

Lai šķirotu Java ArrayList, ir jāimportē kolekciju klase. Iterācijai mēs izmantojam [Java for-each cilpu](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-for-each-cilpa/). Katrai cilpas iterācijai attiecīgais elements tiek izvadīts uz konsoli.

```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 elementi tiek parādīti no mazākā līdz lielākajam:

```Java
9
17
20
54
```


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