Android Academy · Lekcja

Listy i listy mutowalne

Przechowa Pan/Pani uporządkowane dane.

Listy i listy mutowalne to bezpłatna lekcja Android Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Android Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Android Academy zawiera 4 lekcji w sumie.

Czym jest lista?

Lista to uporządkowana kolekcja elementów. Każdy element ma pozycję nazywaną indeksem, zaczynającym się od 0.

W Kotlinie występują dwa rodzaje list: listy tylko do odczytu, których nie można zmieniać, oraz listy modyfikowalne, do których można dodawać elementy i z których można je usuwać.

Listy są wszędzie w aplikacjach na Androida: w strumieniu postów, wierszu przycisków czy wynikach wyszukiwania.

Tworzenie listy tylko do odczytu

Użyj listOf(), aby utworzyć listę tylko do odczytu. Po jej utworzeniu nie można dodawać ani usuwać elementów.

To najbezpieczniejsza opcja domyślna. Jeśli dane nigdy się nie zmieniają, wybierz listę tylko do odczytu.

fun main() {
    val fruits = listOf("apple", "banana", "cherry")
    println(fruits)
    println("Size: ${fruits.size}")
}

Dostęp do elementów za pomocą indeksu

Odczytaj element, używając nawiasów kwadratowych i jego indeksu. Pierwszy element znajduje się pod indeksem 0.

Można również użyć funkcji first() i last() do pobierania elementów z początku i końca listy.

fun main() {
    val colors = listOf("red", "green", "blue")
    println(colors[0])
    println(colors.first())
    println(colors.last())
}

Iterowanie po liście

Pętla for odwiedza każdy element w kolejności. To najczęstszy sposób przetwarzania wszystkich elementów.

W tym przykładzie każda nazwa jest wypisywana w osobnym wierszu.

fun main() {
    val names = listOf("Ada", "Linus", "Grace")
    for (name in names) {
        println("Hello, $name")
    }
}

Tworzenie listy modyfikowalnej

Gdy trzeba zmieniać zawartość listy, użyj mutableListOf(). Umożliwia ona dodawanie i usuwanie elementów po utworzeniu.

Użyj add(), aby dodać element na końcu.

fun main() {
    val tasks = mutableListOf("wake up", "code")
    tasks.add("sleep")
    println(tasks)
}

Usuwanie elementów

Użyj remove(), aby usunąć konkretną wartość, lub removeAt(), aby usunąć element o podanym indeksie.

Obie funkcje działają tylko na listach modyfikowalnych. Wywołanie ich na liście tylko do odczytu powoduje błąd kompilacji.

fun main() {
    val nums = mutableListOf(10, 20, 30, 40)
    nums.remove(20)
    nums.removeAt(0)
    println(nums)
}

Aktualizowanie elementu

Na liście modyfikowalnej przypisz nową wartość do indeksu, aby zastąpić istniejący element.

Indeks musi już istnieć. W przeciwnym razie wystąpi błąd wyjścia poza zakres.

fun main() {
    val scores = mutableListOf(5, 8, 3)
    scores[1] = 99
    println(scores)
}

Sprawdzanie zawartości

Użyj contains() lub słowa kluczowego in, aby sprawdzić, czy lista zawiera daną wartość.

Użyj isEmpty(), aby sprawdzić, czy lista nie zawiera elementów. Obie funkcje działają na obu rodzajach list.

fun main() {
    val pets = listOf("cat", "dog")
    println("cat" in pets)
    println(pets.contains("fish"))
    println(pets.isEmpty())
}

Typy tylko do odczytu a typy modyfikowalne

Typ List<T> jest przeznaczony tylko do odczytu. Typ MutableList<T> udostępnia operacje modyfikacji.

Popularny wzorzec polega na utworzeniu listy za pomocą typu modyfikowalnego, a następnie udostępnieniu jej jako tylko do odczytu List, aby inny kod nie mógł jej zmieniać.

val safe: List<Int> = mutableListOf(1, 2, 3)
// safe.add(4) would NOT compile

Rozmiar i indeksy

Właściwość size informuje, ile elementów zawiera lista.

Poprawne indeksy mieszczą się w zakresie od 0 do size - 1. Użyj indices, aby iterować po pozycjach.

fun main() {
    val items = listOf("a", "b", "c")
    for (i in items.indices) {
        println("$i -> ${items[i]}")
    }
}

Dodawanie wielu elementów naraz

Użyj addAll(), aby dodać do listy modyfikowalnej wszystkie elementy z innej kolekcji.

Jest to przydatne podczas scalania wyników, na przykład łączenia danych z dwóch stron.

fun main() {
    val list = mutableListOf(1, 2)
    list.addAll(listOf(3, 4, 5))
    println(list)
    println("Total: ${list.size}")
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat list w Kotlinie.

Podsumowanie

Dowiedział się Pan/Dowiedziała się Pani, że listy są uporządkowane, a ich indeksowanie zaczyna się od 0. listOf() tworzy listy tylko do odczytu, a mutableListOf() tworzy listy, które można zmieniać.

Można dodawać, usuwać i aktualizować elementy, iterować po liście oraz sprawdzać jej zawartość. Należy wybierać listy tylko do odczytu, chyba że rzeczywiście potrzebna jest ich modyfikacja.

Często zadawane pytania

Czy lekcja „Listy i listy mutowalne” jest bezpłatna?

Tak — pełny tekst „Listy i listy mutowalne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Android Academy, przejdź na CoddyKit PRO. Kurs Android Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Listy i listy mutowalne”?

Przechowa Pan/Pani uporządkowane dane. Ćwiczysz Android Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Android Academy?

Nie wymagamy żadnego doświadczenia. Android Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Listy i listy mutowalne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Android Academy?

Tak. Każda lekcja Android Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Android Academy