Pętle w programowaniu umożliwiają powtarzanie niektórych czynności. Ale nie tylko proste powtarzanie, bo to było bezsensu na dłuższą metę, ale zmianę parametrów, albo ich pobieranie, przetwarzanie według jakichś geometrycznych, lub logicznych zasad. Java posiada 3 główne (może 4, w zależności od tego jaką konwencję nazewnictwa przyjmiemy) rodzaje pętli. Kotlin jednak jak ma to w zwyczaju daje nam dużo więcej możliwości, oraz – elastyczności.

Na początek prosta pętla for, czyli iterująca liczby w zakresie od 0 do 10. W javie:

        for (int i = 0; i < 10; i++) {
            System.out.print("for1 = " + i + ", ");
        }

W Kotlinie:

    for (i in 0..10) {
        print(i)
    }

lub:

    repeat(10) {
        print("repeat10")
    }

No dobra, repeat nie jest pętlą, tylko dodaną do biblioteki standardowej metodą, ale czyż nie jest czytelniejszy? Java wymaga zdefiniowania wartości zmiennej początkowej, warunku, oraz sposobu iteracji. Część z tych elementów może oczywiście znajdować się po za pętlą for, ale nie zawsze potrzebujemy ich wszystkich. Czasem chcemy coś po prostu.. powtórzyć. 😉

Kolejnym typem pętli for jest tzw forEach, który pozwala na iterację bez użycia dodatkowej zmiennej iterującej. W javie przedstawia się tak:

        private static String[] t = {"abc", "cde", "efg"};
        for (String s : t) {
            System.out.print("for2 = " + s + ", ");
        }

Z kolei w Kotlinie:

    val list = listOf("A", "B", "C")
    for(str in list) {
        print(str)
    }

Użyłem przykładu z listą, ponieważ Kotlin nie obsługuje typów prostych, takich jak javowa tablica[].

A co jeżeli chcemy iterować po mapie? Potrzebujemy czegoś na kształt: „for (Map.Entry<String, Object> entry : map.entrySet())”. Z kolei w Kotlinie:

    val map = hashMapOf(1 to "one", 2 to "two", 3 to "three")
    for ((key, value) in map) {
        println("Map[$key] = $value")
    }

Prawda, że przyjemnie? Jest jeszcze coś fajnego, mianowicie pętle foreach możemy wywołać jak metodę, albo funkcję, bezpośrednio na obiekcie na którym operujemy. Tak to wygląda:

    map.forEach {
        print(it.key)
    }
    println()
    (1..5).forEach(::print)
    println()

Słówko kluczowe it odnosi się do bieżącego obiektu. Potrzebowaliśmy np klucza – żaden problem.

Pozostałe dwa typy pętli, które są praktycznie takie same w obydwóch językach nazywają się while i do while. Stosujemy je najczęściej wtedy, kiedy nie znamy dokładnej ilości iteracji, ale istnieje jakiś warunek który zakończy nam działanie pętli. Poniższy przykład jest taki jak w pętli for, ale nie chciałem specjalnie utrudniać, tworząc dziwne warunki, chodzi mi o sam „kształt” pętli.

        //java
        int i = 0;
        while (i < 10) {
            System.out.print("while = " + i + ", ");
            i++;
        }
        System.out.println();
        do {
            System.out.println("do while");
        } while (1 > 10);

    //kotlin
    var i = 0
    while (i < 10) {
        print("while = $i, ")
        i++
    }
    println()
    do {
        println("do while")
    } while (1 > 10)

To by było na tyle, jeśli chodzi o informacje o pętlach. Temat jeszcze powróci, kiedy będziemy omawiali lambdy 😉 Kod w aktualnej wersji znajduje się na GitHubie. Wszystkie aktualne zmiany oczywiście w pakiecie loops. W następnej części opowiem o instrukcjach sterujących w obydwóch językach.

Pozdrawiam!

— status update —

Jak widać, minęło sporo czasu, a kontynuacja kursu Kotlina się nie pojawiła. Pojawi się tutaj: https://kurskotlin.pl/ tak więc tam zapraszam #kurskotlin

Podstawą chyba każdego języka programowania są zmienne, w których można przechować wartość, którą można modyfikować. Są też stałe, kiedy nie chcemy, żeby przypadkiem coś zostało zmienione (np liczba PI, to wartość stała, nadpisywanie jej zawartości np liczbą 5 i nazywanie PI nie ma logicznych podstaw i będzie prowadzić do błędów). Java i Kotlin mają do tego aspektu podobne podejścia. Są to języki silnie, statycznie typowane, tzn jeżeli nadamy jakiś typ zmiennej, to nie da się go wprost porównać z innym typem, jeżeli np napis ma wartość 1 i zmienna typu liczbowego ma wartość 1, to one nie są sobie równe (szczegóły poniżej). Słowo statycznie oznacza z kolei, że zmienne przyjmują swoje typy w czasie kompilacji programu, a nie w czasie jego działania, jak ma to miejsce np w JavaScripcie. Kotlin posiada tutaj jednak ułatwienie, które nazywa się typowaniem zmiennych.

W praktyce oznacza to tyle, że mamy kod w javie:

        byte b = 127;
        short s = 32767;
        int i = 2147483647;
        final byte fb = 127;
        final short fs = 32767;
        final int fi = 2147483647;

Słówko final oznacza stałą, czyli po przypisaniu wartości nie można już jej zmienić. Zaprezentowane wartości to maksimum, jakie może przyjąć dana zmienna, po przekroczeniu jej zacznie się odliczanie od wartości ujemnych, coś na kształt licznika w samochodzie, tylko że tam nie ma ujemnych, tylko zero 😉 A jak to wygląda w Kotlinie?

    var c = 120
    var d: Byte = 120
    val e = 120
    //val f: String = 120

Słówko var (variables) oznacza zmienną, z kolei val (values) stałą. Druga sprawa jest taka, że na podstawie przypisanej wartości zostaje nadany odpowiedni typ zmiennej. Innymi słowy w tym przypadku domyślny będzie Int, chyba, że po dwukropku wymusimy inny typ. Kod w komentarzu się nie skompiluje, ponieważ do wprowadzania napisów (zmienna typu String) używa się dwóch znaków cudzysłowu: „120”.

W tym miejscu należy też wspomnieć o zmiennej Object w javie, po której dziedziczą wszystkie typy. Nie ma ona zbyt wielu metod, ale posiada equals – zawiera. Używamy jej do porównania zawartości obiektów.

        boolean bool = true;
        char c = 'A';
        final char e = 'E';
        String str = "Hello";
        Object ob = 1;
        int in = 1;

        for(int y = 0; y<10; y++) {
            System.out.print(c++ + " ");
            // System.out.print(e++ + " ");
            // System.out.print(ob++ + " ");
        }
        System.out.println();
        if(ob.equals(in)) {
            System.out.println(bool);
        }

Funkcja ta zwróci następujące wartości:

A B C D E F G H I J 
true

Dzieje się tak ponieważ zmienna typu char jest typem liczbowym, dzięki temu możemy zwiększając jej wartość wydrukować kolejną literę. Nie uda się to w przypadku e i ob, ponieważ jedna z nich jest stałą, druga z kolei jest typem Object, gdzie nie wiadomo jak obsługiwać iterację. Z kolei w Kotlinie:

    var c = 120
    var d: Byte = 120
    val e = 120
    //val f: String = 120
    for (i in 0..9) {
        //println(e++)
        println(c++)
    }
    println()
    for (i in 0..9) {
        println(d++)
    }
    var f = 'A'
    var g = "A"
    for (i in 0..9) {
        println(f++)
        //println(g++)
    }

Otrzymamy taką odpowiedź:

120
121
122
123
124
125
126
127
128
129

120
121
122
123
124
125
126
127
-128
-127
A
B
C
D
E
F
G
H
I
J

Co tu się stało? Po pierwsze iterujemy po c, który domyślnie został zapisany jako int, z racji wysokiego zakresu udaje nam się to bezbłędnie. Po e nie możemy iterować, ponieważ jest stała. Ale za to w zmiennej d wymuszamy typ byte, który może przyjąć wartość max 127, a następnie zaczyna iterację od najniższej wartości. Iterowanie typu char jest takie samo jak w Javie, z kolei Stringa nie można iterować, tutaj również bez niespodzianek. Słówko kluczowe equals występuje również w Kotlinie, działa tak samo jak w javie, innymi słowy porównuje wartości pomiędzy takimi samymi typami. Pojawił się też nowy operator === oznaczający, że oba obiekty mają taką samą referencję (czyli odnoszą się do tego samego obiektu). Wygląda to tak:

    var x = 1
    var y: String = "1"
    var z = x
//    if(x==y)
//        println(true)
    if(x.equals(y))
        println("x.equals(y)")
//    if(x===y)
//        println(true)
    if(x===z)
        println(true)
    if(x.equals(y.toInt()))
        println("x.equals(y.toInt())")

Co z kolei zwraca:

true
x.equals(y.toInt())

Czyli z i x mają tą samą referencję, oraz x ma taką samą wartość jak y, jeśli przekształcimy go na Int.

W podsumowaniu chciałem jeszcze zwrócić uwagę na wielkość liter. Typ zmiennej pisany z małej litery to prymityw, Kotlin już takich nie obsługuje i tam piszemy wszystko z dużej. Prymityw znaczy tyle, że nie jest obiektem, tylko typem prostym mogącym przechowywać jakąś wartość liczbową (char jest prymitywem, ponieważ przechowuje wartości liczbowe). Obiekty z kolei mają dodatkowe właściwości, mogą mieć np wartość null. Kotlin jednakże zabezpiecza nas przed taką ewentualnością.

W związku z powyższym Java posiada mechanizm automatycznego opakowywania prymitywów. Tzn, jeżeli porównujemy obiekt z prymitywem int, to automatycznie zostanie on skonwertowany do obiektu Integer o tej samej wartości. W Kotlinie z racji braku obsługi prymitywów takie operacje nie są potrzebne. To by było tyle na dzisiaj, jak widać mechanizm typowania zmiennych pozwala zaoszczędzić zbędnego kodu. Wszystkie użyte dzisiaj przykłady znajdują się też na GitHubie, zachęcam do samodzielnego pobawienia się 😉

Pozdrawiam!

— status update —

Jak widać, minęło sporo czasu, a kontynuacja kursu Kotlina się nie pojawiła. Pojawi się tutaj: https://kurskotlin.pl/ tak więc tam zapraszam #kurskotlin