ArrayList w Javie: tworzenie, dodawanie, usuwanie, pętle i sortowanie

Lista, która sama zmienia rozmiar

Zwykła tablica w Javie ma stałą długość: jeśli zdecydujesz się na dziesięć miejsc, masz je na zawsze. ArrayList to alternatywa o zmiennym rozmiarze z java.util: rośnie, gdy dodajesz elementy, kurczy się, gdy je usuwasz, i ma wygodne metody do rzeczy, które faktycznie robisz z listą.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Ada");
        names.add("Boris");
        names.add("Chen");

        System.out.println(names);
        System.out.println("Count: " + names.size());
    }
}

Zwróć uwagę na typ w nawiasach ostrych, List<String>, który mówi kompilatorowi, że lista przechowuje wartości String. <> (tak zwany „diament”) po prawej stronie pozwala Javie wywnioskować ten sam typ bez powtarzania go. Zauważ też, że importujesz java.util.ArrayList; ta klasa nie jest dostępna domyślnie.

Deklaruj jako List, twórz jako ArrayList

Prawie zawsze zobaczysz zmienną zadeklarowaną jako interfejs List, a nie konkretny ArrayList:

List<String> names = new ArrayList<>();

To dobry nawyk, a nie reguła. Programowanie pod interfejs List sprawia, że reszta kodu nie zależy od tego, jakiej implementacji listy użyto, więc później możesz ją podmienić bez zmieniania reszty. W codziennym użyciu oba zapisy działają tak samo.

Dodawanie, odczyt i nadpisywanie

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");      // dodaje na końcu
        fruits.add("banana");
        fruits.add(1, "cherry");  // wstawia pod indeksem 1

        System.out.println(fruits.get(0));   // odczyt według indeksu
        fruits.set(0, "apricot");            // nadpisuje indeks 0

        System.out.println(fruits);
    }
}

• add(value) dodaje element na końcu.
• add(index, value) wstawia element na danej pozycji i przesuwa kolejne elementy o jedno miejsce dalej.
• get(index) odczytuje element na danej pozycji (indeksy od zera).
• set(index, value) nadpisuje istniejący element.

Indeksy liczy się od zera, a get z indeksem spoza zakresu rzuca IndexOutOfBoundsException.

Usuwanie elementów

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("cherry");

        fruits.remove("banana");  // usuwa według wartości (pierwsze dopasowanie)
        fruits.remove(0);         // usuwa według indeksu

        System.out.println(fruits);
    }
}

Gdy lista przechowuje Integer, czeka klasyczna pułapka. remove(int) oznacza „usuń według indeksu”, a remove(Object) oznacza „usuń według wartości”, więc:

List<Integer> nums = new ArrayList<>(List.of(10, 20, 30));
nums.remove(1);                      // usuwa indeks 1 -> wartość 20
nums.remove(Integer.valueOf(20));    // usuwa wartość 20

Opakuj wartość w Integer.valueOf(...), gdy chodzi ci o „usuń tę wartość”, a nie „usuń ten indeks”.

Rozmiar, zawieranie i wyszukiwanie indeksu

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        System.out.println(fruits.size());            // 3
        System.out.println(fruits.isEmpty());         // false
        System.out.println(fruits.contains("banana")); // true
        System.out.println(fruits.indexOf("cherry"));  // 2
    }
}

List.of(...) szybko tworzy niemodyfikowalną listę; przekazanie jej do konstruktora ArrayList daje modyfikowalną kopię z tymi wartościami na start.

Pętla po ArrayList

Najczytelniejsza pętla to rozszerzone for (pętla for-each):

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (String fruit : fruits) {
            System.out.println(fruit.toUpperCase());
        }
    }
}

Gdy potrzebujesz też indeksu, użyj pętli z licznikiem oraz size() i get(i):

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (int i = 0; i < fruits.size(); i++) {
            System.out.println(i + ": " + fruits.get(i));
        }
    }
}

Jedna zasada: nie dodawaj ani nie usuwaj elementów listy, gdy pętla for-each po niej iteruje, bo to rzuca ConcurrentModificationException. Aby bezpiecznie usunąć pasujące elementy, użyj removeIf:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        nums.removeIf(n -> n % 2 == 0);   // usuwa liczby parzyste
        System.out.println(nums);
    }
}

Sortowanie

Collections.sort porządkuje listę w miejscu według porządku naturalnego (alfabetycznie dla napisów, liczbowo dla liczb):

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(3, 1, 4, 1, 5, 9, 2, 6));

        Collections.sort(nums);
        System.out.println(nums);

        nums.sort(Collections.reverseOrder());  // malejąco
        System.out.println(nums);
    }
}

Dla własnego porządku przekaż Comparator do list.sort(...), na przykład names.sort(Comparator.comparingInt(String::length)), aby sortować według długości.

ArrayList przechowuje obiekty, nie typy proste

Nie możesz napisać ArrayList<int>. Typy generyczne działają tylko z typami obiektowymi, więc używaj klas opakowujących Integer, Double, Boolean i tak dalej:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> scores = new ArrayList<>();
        scores.add(95);   // int 95 jest automatycznie opakowywany w Integer
        scores.add(88);

        int first = scores.get(0);  // automatycznie rozpakowywany z powrotem do int
        System.out.println(first + scores.get(1));
    }
}

Autoboxing w Javie sam konwertuje między int a Integer, więc kod czyta się naturalnie. Pamiętaj tylko, że sama lista przechowuje obiekty Integer.

Dalej: HashMap

ArrayList to właściwe narzędzie, gdy liczy się kolejność i pozycja. Gdy musisz wyszukiwać elementy według klucza, na przykład użytkownika po nazwie albo cenę po kodzie produktu, potrzebujesz HashMap, którą omawia następna strona.