Basics

Documentation

ДокумСнтация (Language Guide): https://kotlinlang.org/docs/reference/exceptions.html

Packages

package ctf.zone.pwn  
// Имя ΠΏΠ°ΠΊΠ΅Ρ‚Π° указываСтся Π² Π½Π°Ρ‡Π°Π»Π΅ исходного Ρ„Π°ΠΉΠ»Π°, Ρ‚Π°ΠΊ ΠΆΠ΅ ΠΊΠ°ΠΊ ΠΈ Π² Java
// Но Π² ΠΎΡ‚Π»ΠΈΡ‡ΠΈΠ΅ ΠΎΡ‚ Java, Π½Π΅Ρ‚ нСобходимости, Ρ‡Ρ‚ΠΎΠ±Ρ‹ структура ΠΏΠ°ΠΊΠ΅Ρ‚ΠΎΠ² совпадала со структурой ΠΏΠ°ΠΏΠΎΠΊ: 
// исходныС Ρ„Π°ΠΉΠ»Ρ‹ ΠΌΠΎΠ³ΡƒΡ‚ Ρ€Π°ΡΠΏΠΎΠ»Π°Π³Π°Ρ‚ΡŒΡΡ Π² ΠΏΡ€ΠΎΠΈΠ·Π²ΠΎΠ»ΡŒΠ½ΠΎΠΌ мСстС Π½Π° дискС.


import java.lang.IllegalStateException
import java.util.*
import java.io.File

Vars, constants and comments

val PI = 3.14 // test comment
var global_var = 0

/* Π‘Π»ΠΎΡ‡Π½Ρ‹ΠΉ ΠΊΠΎΠΌΠΌΠ΅Π½Ρ‚Π°Ρ€ΠΈΠΉ ΠΈΠ·
Π½Π΅ΡΠΊΠΎΠ»ΡŒΠΊΠΈΡ… строк */

Classes and Functions

Functions

class KotlinClass {
    fun sum(a: Int, b: Int): Int {  // Ѐункция ΠΏΡ€ΠΈΠ½ΠΈΠΌΠ°Π΅Ρ‚ Π΄Π²Π° Π°Ρ€Π³ΡƒΠΌΠ΅Π½Ρ‚Π° Int ΠΈ Π²ΠΎΠ·Π²Ρ€Π°Ρ‰Π°Π΅Ρ‚ Int
        return a + b
    }

    fun sum(a: Int, b: Double) = a + b // Ѐункция с Π²Ρ‹Ρ€Π°ΠΆΠ΅Π½ΠΈΠ΅ΠΌ Π² качСствС Ρ‚Π΅Π»Π° ΠΈ автоматичСски ΠΎΠΏΡ€Π΅Π΄Π΅Π»Π΅Π½Π½Ρ‹ΠΌ Ρ‚ΠΈΠΏΠΎΠΌ Π²ΠΎΠ·Π²Ρ€Π°Ρ‰Π°Π΅ΠΌΠΎΠ³ΠΎ значСния

    fun printSum(a: Int, b: Int): Unit {  // Ѐункция, Π½Π΅ Π²ΠΎΠ·Π²Ρ€Π°Ρ‰Π°ΡŽΡ‰Π°Ρ Π½ΠΈΠΊΠ°ΠΊΠΎΠ³ΠΎ значСния (void Π² Java):
        print(a + b)
    }

    fun printSum(a: Int, b: Double) {  // Π’ΠΈΠΏ Π²ΠΎΠ·Π²Ρ€Π°Ρ‰Π°Π΅ΠΌΠΎΠ³ΠΎ значСния Unit ΠΌΠΎΠΆΠ΅Ρ‚ Π±Ρ‹Ρ‚ΡŒ ΠΎΠΏΡƒΡ‰Π΅Π½
        print(a + b)
        println("jsfvkjsdfg")
    }

    fun variables() {
        // НСизмСняСмая (Ρ‚ΠΎΠ»ΡŒΠΊΠΎ для чтСния) внутрСнняя пСрСмСнная
        val a: Int = 1
        val b = 1   // Π’ΠΈΠΏ `Int` Π²Ρ‹Π²Π΅Π΄Π΅Π½ автоматичСски
        val c: Int  // Π’ΠΈΠΏ обязатСлСн, ΠΊΠΎΠ³Π΄Π° Π·Π½Π°Ρ‡Π΅Π½ΠΈΠ΅ Π½Π΅ инициализируСтся
        c = 1       // ΠΏΠΎΡΠ»Π΅Π΄ΡƒΡŽΡ‰Π΅Π΅ присвоСниС


        // ИзмСняСмая пСрСмСнная
        var x = 5 // Π’ΠΈΠΏ `Int` Π²Ρ‹Π²Π΅Π΄Π΅Π½ автоматичСски
        x += 1

        // ИзмСнСниС Π³Π»ΠΎΠ±Π°Π»ΡŒΠ½Ρ‹Ρ… ΠΏΠ΅Ρ€Π΅ΠΌΠ΅Π½Π½Ρ‹Ρ…
        global_var += 1
    }
}

Static Functions

// Static functions
class MainActivity : AppCompatActivity() {
    companion object {
        // PARAM_RESULT β€” Static Field
        val PARAM_RESULT: String = "com.zfr.network.extra.RESULT" 
        fun test() {
            
        }
    }    
}

Extensions

Π­Ρ‚ΠΎ Ρ„ΡƒΠ½ΠΊΡ†ΠΈΠΈ-Ρ€Π°ΡΡˆΠΈΡ€Π΅Π½ΠΈΡ

// Π€ΡƒΠ½ΠΊΡ†ΠΈΠΈ-Ρ€Π°ΡΡˆΠΈΡ€Π΅Π½ΠΈΡ
fun String.spaceToCamelCase() { return }
"Convert this to camelcase".spaceToCamelCase()

Π’ΠΎΠ·Π²Ρ€Π°Ρ‰Π΅Π½ΠΈΠ΅ Π½Π΅ΡΠΊΠΎΠ»ΡŒΠΊΠΈΡ… Ρ‚ΠΈΠΏΠΎΠ² Π΄Π°Π½Π½Ρ‹Ρ… ΠΈΠ· Ρ„ΡƒΠ½ΠΊΡ†ΠΈΠΉ

Π‘ΠΎΠ·Π΄Π°Π²Π°Ρ‚ΡŒ sealed классы: https://kotlinlang.org/docs/reference/sealed-classes.html

Если Π½Π°Π΄ΠΎ Π²Π΅Ρ‚Π²ΠΈΡ‚ΡŒ Π»ΠΎΠ³ΠΈΠΊΡƒ - Π½Π° ΠΈΡΠΊΠ»ΡŽΡ‡Π΅Π½ΠΈΡΡ…

Strings

Π¨Π°Π±Π»ΠΎΠ½Ρ‹

fun string_patterns(args: Array<String>, test: Any) {
        /*
        Допустимо использованиС ΠΏΠ΅Ρ€Π΅ΠΌΠ΅Π½Π½Ρ‹Ρ… Π²Π½ΡƒΡ‚Ρ€ΠΈ строк Π² Ρ„ΠΎΡ€ΠΌΠ°Ρ‚Π΅ $name ΠΈΠ»ΠΈ ${name}
         */
        if (args.size == 0) return
        else print("kjkfgd")

        print("ΠŸΠ΅Ρ€Π²Ρ‹ΠΉ Π°Ρ€Π³ΡƒΠΌΠ΅Π½Ρ‚: ${args[0]}")

        var a = 1
        // просто имя ΠΏΠ΅Ρ€Π΅ΠΌΠ΅Π½Π½ΠΎΠΉ Π² шаблонС:
        val s1 = "a Ρ€Π°Π²Π½ΠΎ $a"

        a = 2
        // ΠΏΡ€ΠΎΠΈΠ·Π²ΠΎΠ»ΡŒΠ½ΠΎΠ΅ Π²Ρ‹Ρ€Π°ΠΆΠ΅Π½ΠΈΠ΅ Π² шаблонС:
        val s2 = "${s1.replace("Ρ€Π°Π²Π½ΠΎ", "Π±Ρ‹Π»ΠΎ Ρ€Π°Π²Π½ΠΎ")}, Π½ΠΎ Ρ‚Π΅ΠΏΠ΅Ρ€ΡŒ Ρ€Π°Π²Π½ΠΎ $a"

        /*
          Π Π΅Π·ΡƒΠ»ΡŒΡ‚Π°Ρ‚ Ρ€Π°Π±ΠΎΡ‚Ρ‹ ΠΏΡ€ΠΎΠ³Ρ€Π°ΠΌΠΌΡ‹:
          a Π±Ρ‹Π»ΠΎ Ρ€Π°Π²Π½ΠΎ 1, Π½ΠΎ Ρ‚Π΅ΠΏΠ΅Ρ€ΡŒ Ρ€Π°Π²Π½ΠΎ 2
        */
}

Π”ΠΎΠΏΠΎΠ»Π½ΠΈΡ‚ΡŒ строку символами

val name = "Barsik"
val pad = name.padStart(10, '#')
println(pad) // ####Barsik

val name = "Barsik"
val pad = name.padEnd(10, '*')
println(pad) // Barsik****

ΠŸΠΎΠ΄ΡΡ‚Ρ€ΠΎΠΊΠΈ

// подстрока с ΡƒΠΊΠ°Π·Π°Π½Π½ΠΎΠ³ΠΎ индСкса
val result = "developer.alexanderklimov.ru".substring(10) // alexanderklimov.ru

// подстрока Π΄ΠΎ ΠΏΠ΅Ρ€Π²ΠΎΠ³ΠΎ ΡƒΠΊΠ°Π·Π°Π½Π½ΠΎΠ³ΠΎ раздСлитСля
val first = "developer.alexanderklimov.ru".substringBefore('.') // developer

// подстрока послС ΠΏΠ΅Ρ€Π²ΠΎΠ³ΠΎ ΡƒΠΊΠ°Π·Π°Π½Π½ΠΎΠ³ΠΎ раздСлитСля
val last = "developer.alexanderklimov.ru".substringAfter('.') // alexanderklimov.ru

// подстрока послС послСднСго ΡƒΠΊΠ°Π·Π°Π½Π½ΠΎΠ³ΠΎ раздСлитСля
val last = "developer.alexanderklimov.ru".substringAfterLast('.') // ru

// подстрока Π΄ΠΎ послСднСго ΡƒΠΊΠ°Π·Π°Π½Π½ΠΎΠ³ΠΎ раздСлитСля
val beforeLast = "developer.alexanderklimov.ru".substringBeforeLast('.') // developer.alexanderklimov

ВстроСнныС Ρ„ΡƒΠ½ΠΊΡ†ΠΈΠΈ

val blank = "   ".isBlank() // true, Ссли пустая строка ΠΈΠ»ΠΈ пустыС символы ΠΏΡ€ΠΎΠ±Π΅Π»Π°, табуляции ΠΈ Ρ‚.ΠΏ.

// индСкс послСднСго символа
val lastIndex = "ΠšΠΎΡ‚ ΠœΡƒΡ€Π·ΠΈΠΊ".lastIndex // 9

// ΠΏΠ΅Ρ€Π΅Π²ΠΎΠ΄ΠΈΠΌ Π² Π²Π΅Ρ€Ρ…Π½ΠΈΠΉ рСгистр ΠΏΠ΅Ρ€Π²Ρ‹ΠΉ символ строки
// decapitalize() выполняСм ΠΎΠ±Ρ€Π°Ρ‚Π½ΡƒΡŽ Π·Π°Π΄Π°Ρ‡Ρƒ
val capitalize = "ΠΊΠΎΡ‚ ΠœΡƒΡ€Π·ΠΈΠΊ".capitalize()

val withSpaces = "1".padStart(2) // добавляСм ΠΏΡ€ΠΎΠ±Π΅Π» ΠΏΠ΅Ρ€Π΅Π΄ строкой
val endZeros = "1".padEnd(3, '0') // "100"  добавляСм Π½ΡƒΠ»ΠΈ Π² ΠΊΠΎΠ½Π΅Ρ†

val dropStart = "Kotlin".drop(2) // "tlin" ΡƒΠ±ΠΈΡ€Π°Π΅ΠΌ ΠΏΠ΅Ρ€Π²Ρ‹Π΅ символы Π² ΡƒΠΊΠ°Π·Π°Π½Π½ΠΎΠΌ количСствС
val dropEnd = "Kotlin".dropLast(3) // "Kot" ΡƒΠ±ΠΈΡ€Π°Π΅ΠΌ послСдниС символы Π² ΡƒΠΊΠ°Π·Π°Π½Π½ΠΎΠΌ количСствС

// Π²ΠΎΠ·Π²Ρ€Π°Ρ‰Π°Π΅ΠΌ строку Π±Π΅Π· ΠΏΠ΅Ρ€Π²ΠΎΠ³ΠΎ символа, ΠΊΠΎΡ‚ΠΎΡ€Ρ‹ΠΉ удовлСтворяСт ΡƒΡΠ»ΠΎΠ²ΠΈΡŽ
val string = "ΠœΡƒΡ€Π·ΠΈΠΊ"
val result = string.dropWhile{
    it == 'М'
}
textView.text = result // ΡƒΡ€Π·ΠΈΠΊ

// Π²ΠΎΠ·Π²Ρ€Π°Ρ‰Π°Π΅ΠΌ строку Π±Π΅Π· послСднСго символа, ΠΊΠΎΡ‚ΠΎΡ€Ρ‹ΠΉ удовлСтворяСт ΡƒΡΠ»ΠΎΠ²ΠΈΡŽ
val string = "ΠœΡƒΡ€Π·ΠΈΠΊ"
val result = string.dropLastWhile{
    it == 'ΠΊ'
}
textView.text = result // ΠœΡƒΡ€Π·ΠΈ

// Ρ€Π°Π·Π±ΠΈΠ²Π°Π΅ΠΌ Π½Π° массив строк
"A\nB\nC".lines() // [A, B, C]
"ABCD".zipWithNext() // [(A, B), (B, C), (C, D)]

// удаляСм символы ΠΈΠ· Π·Π°Π΄Π°Π½Π½ΠΎΠ³ΠΎ Π΄ΠΈΠ°ΠΏΠ°Π·ΠΎΠ½Π°
val string = "ΠšΠΎΡ‚, ΠΊΠΎΡ‚ΠΎΡ€Ρ‹ΠΉ гулял сам ΠΏΠΎ сСбС"
val result = string.removeRange(
    3..28 // range
)

// удаляСм прСфикс ΠΈΠ· строки
val string = "ΠšΠΎΡ‚, ΠΊΠΎΡ‚ΠΎΡ€Ρ‹ΠΉ гулял сам ΠΏΠΎ сСбС"
val result = string.removePrefix("ΠšΠΎΡ‚")

// удаляСм суффикс ΠΈΠ· строки
val string = "ΠšΠΎΡ‚, ΠΊΠΎΡ‚ΠΎΡ€Ρ‹ΠΉ гулял сам ΠΏΠΎ сСбС"
val result = string.removeSuffix("сСбС")

// удаляСм Π·Π°Π΄Π°Π½Π½Ρ‹ΠΉ Ρ€Π°Π·Π΄Π΅Π»ΠΈΡ‚Π΅Π»ΡŒ, ΠΊΠΎΡ‚ΠΎΡ€Ρ‹ΠΉ Π΄ΠΎΠ»ΠΆΠ΅Π½ ΠΎΠΊΡ€ΡƒΠΆΠ°Ρ‚ΡŒ строку с Π½Π°Ρ‡Π°Π»Π° ΠΈ с ΠΊΠΎΠ½Ρ†Π°
val string = "Ρ‚Π°, Ρ‚Ρ€Π°-Ρ‚Π°-Ρ‚Π°, ΠΌΡ‹ Π²Π΅Π·Ρ‘ΠΌ с собой ΠΊΠΎΡ‚Π°"

val result = string.removeSurrounding(
    "Ρ‚Π°" // delimiter
)

textView.text = result // , Ρ‚Ρ€Π°-Ρ‚Π°-Ρ‚Π°, ΠΌΡ‹ Π²Π΅Π·Ρ‘ΠΌ с собой ΠΊΠΎ

// Π’Π°ΠΊΠΆΠ΅ ΠΌΠΎΠΆΠ½ΠΎ ΡƒΠΊΠ°Π·Π°Ρ‚ΡŒ Ρ€Π°Π·Π½Ρ‹Π΅ Π½Π°Ρ‡Π°Π»ΠΎ ΠΈ ΠΊΠΎΠ½Π΅Ρ†, ΠΊΠΎΡ‚ΠΎΡ€Ρ‹Π΅ ΠΎΠΊΡ€ΡƒΠΆΠ°ΡŽΡ‚ строку
val string = "Π’Ρ€Π°-Ρ‚Π°-Ρ‚Π°, Ρ‚Ρ€Π°-Ρ‚Π°-Ρ‚Π°, ΠΌΡ‹ Π²Π΅Π·Ρ‘ΠΌ с собой ΠΊΠΎΡ‚Π°"

val result = string.removeSurrounding(
    "Π’Ρ€Π°-", // prefix
    " ΠΊΠΎΡ‚Π°" // suffix
)

textView.text = result // Ρ‚Π°-Ρ‚Π°, Ρ‚Ρ€Π°-Ρ‚Π°-Ρ‚Π°, ΠΌΡ‹ Π²Π΅Π·Ρ‘ΠΌ с собой


// ДобавляСм отступы ΠΏΡ€ΠΈ явном ΠΏΠ΅Ρ€Π΅Π²ΠΎΠ΄Π΅ Π½Π° Π½ΠΎΠ²ΡƒΡŽ строку
val string = "Какой-Ρ‚ΠΎ Π΄Π»ΠΈΠ½Π½Ρ‹ΠΉ тСкст, \nсостоящий ΠΈΠ· ΠΈΠΌΡ‘Π½ ΠΊΠΎΡ‚ΠΎΠ²: " +
        "\nΠ’Π°ΡΡŒΠΊΠ°" +
        "\nБарсик" +
        "\nΠ Ρ‹ΠΆΠΈΠΊ"

val result = string.prependIndent(
    "     " // indent
)

// Π Π°Π·Π±ΠΈΠ²Π°Π΅ΠΌ символы Π½Π° Π΄Π²Π΅ Π³Ρ€ΡƒΠΏΠΏΡ‹. 
// Π’ ΠΏΠ΅Ρ€Π²ΡƒΡŽ Π³Ρ€ΡƒΠΏΠΏΡƒ ΠΏΠΎΠΏΠ°Π΄ΡƒΡ‚ символы Π² Π²Π΅Ρ€Ρ…Π½Π΅ΠΌ рСгистрС, Π²ΠΎ Π²Ρ‚ΠΎΡ€ΡƒΡŽ - символы Π² Π½ΠΈΠΆΠ½Π΅ΠΌ рСгистрС
val string = "ΠšΠΎΡ‚ Π’Π°ΡΡŒΠΊΠ° ΠΈ ΠΊΠΎΡ‚ ΠœΡƒΡ€Π·ΠΈΠΊ - Π”Ρ€ΡƒΠ·ΡŒΡ!"

val result: Pair<String, String> = string.partition {
    it.isUpperCase()
}

textView.text = result.first + ":" + result.second //ΠšΠ’ΠœΠ”:ΠΎΡ‚ аська ΠΈ ΠΊΠΎΡ‚ ΡƒΡ€Π·ΠΈΠΊ - Ρ€ΡƒΠ·ΡŒΡ!

// Π Π°Π·Π±ΠΈΠ²Π°Π΅ΠΌ строку Π½Π° список строк. Π’ качСствС раздСлитСля - ΠΏΠ΅Ρ€Π΅Π²ΠΎΠ΄ Π½Π° Π½ΠΎΠ²ΡƒΡŽ строку
val string = "ΠšΠΎΡ‚ Π’Π°ΡΡŒΠΊΠ°\nΠšΠΎΡ‚ΠœΡƒΡ€Π·ΠΈΠΊ\nΠšΠΎΡ‚ ΠœΡƒΡ€Π·ΠΈΠΊ"

// Split string into lines (CRLF, LF or CR)
val lines: List<String> = string.lines()

textView.text = "Кол-Π²ΠΎ строк: ${lines.size}"
lines.forEach {
    textView.append("\n" + it)
}

// Π Π°Π·Π±ΠΈΠ²Π°Π΅ΠΌ строку Π½Π° список строк с ΡƒΠΊΠ°Π·Π°Π½Π½Ρ‹ΠΌ числом символов. Π’ послСднСй строкС ΠΌΠΎΠΆΠ΅Ρ‚ Π²Ρ‹Π²ΠΎΠ΄ΠΈΡ‚ΡŒΡΡ остаток
val string = "Π’Ρ€Π°-Ρ‚Π°-Ρ‚Π°, Ρ‚Ρ€Π°-Ρ‚Π°-Ρ‚Π°, ΠΌΡ‹ Π²Π΅Π·Ρ‘ΠΌ с собой ΠΊΠΎΡ‚Π°"
val list:List<String> = string.chunked(11)
list.forEach {
    textView.append("$it\n")
}

/*
Π’Ρ€Π°-Ρ‚Π°-Ρ‚Π°, 
Ρ‚Ρ€Π°-Ρ‚Π°-Ρ‚Π°, 
ΠΌΡ‹ Π²Π΅Π·Ρ‘ΠΌ с 
собой ΠΊΠΎΡ‚Π°
*/

// Π‘ΠΎΠ΄Π΅Ρ€ΠΆΠΈΡ‚ Π»ΠΈ строка Ρ‚ΠΎΠ»ΡŒΠΊΠΎ Ρ†ΠΈΡ„Ρ€Ρ‹ (ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΡƒΠ΅ΠΌ ΠΏΡ€Π΅Π΄ΠΈΠΊΠ°Ρ‚)
val string = "09032020"

// Returns true if all characters match the given predicate.
val result: Boolean = string.all{
    it.isDigit()
}
textView.append("Is the string $string contain only digit? $result")

// Π‘ΠΎΠ΄Π΅Ρ€ΠΆΠΈΡ‚ Π»ΠΈ строка хотя Π±Ρ‹ ΠΎΠ΄Π½Ρƒ Ρ†ΠΈΡ„Ρ€Ρƒ (ΠΈΡΠΏΠΎΠ»ΡŒΠ·ΡƒΠ΅ΠΌ ΠΏΡ€Π΅Π΄ΠΈΠΊΠ°Ρ‚)
val string = "3 ΠΊΠΎΡ‚Π°"
// Returns true if at least one character matches the given predicate.
val result: Boolean = string.any() {
    it.isDigit()
}
textView.append("Is the text \"$string\" contain any digit? $result")

// Π‘Ρ€Π°Π²Π½ΠΈΠ²Π°Π΅ΠΌ Π΄Π²Π΅ строки с ΡƒΡ‡Ρ‘Ρ‚ΠΎΠΌ рСгистра
val string1 = "This is a sample string."
val string2 = "This is a SAMPLE string."

if (string1.compareTo(string2, ignoreCase = true) == 0) {
    textView.append("\n\nBoth strings are equal, ignoring case.")
} else {
    textView.append("\n\nBoth strings are not equal, ignoring case.")
}

МоТно Ρ„ΠΈΠ»ΡŒΡ‚Ρ€ΠΎΠ²Π°Ρ‚ΡŒ Π΄Π°Π½Π½Ρ‹Π΅ с ΠΏΠΎΠΌΠΎΡ‰ΡŒΡŽ filter(). Допустим, ΠΌΡ‹ Ρ…ΠΎΡ‚ΠΈΠΌ ΠΈΠ·Π²Π»Π΅Ρ‡ΡŒ Ρ‚ΠΎΠ»ΡŒΠΊΠΎ Ρ†ΠΈΡ„Ρ€Ρ‹ ΠΈΠ· строки.


val string = "9 ΠΆΠΈΠ·Π½Π΅ΠΉ (2016) - Nine Lives - информация ΠΎ Ρ„ΠΈΠ»ΡŒΠΌΠ΅"
val filteredText = string.filter { it.isDigit() }
textView.text = filteredText // 92016

Если хочСтся Ρ€Π΅ΡˆΠΈΡ‚ΡŒ ΠΎΠ±Ρ€Π°Ρ‚Π½ΡƒΡŽ Π·Π°Π΄Π°Ρ‡Ρƒ ΠΈ ΠΏΠΎΠ»ΡƒΡ‡ΠΈΡ‚ΡŒ Ρ‚ΠΎΠ»ΡŒΠΊΠΎ символы, Π½ΠΎ Π½Π΅ Ρ†ΠΈΡ„Ρ€Ρ‹ - Ρ‚ΠΎ достаточно Π²Ρ‹Π·Π²Π°Ρ‚ΡŒ filterNot().


val filteredText = string.filterNot { it.isDigit() }

String -> Hex String

fun ByteArray.toHexString() = joinToString("") { "%02x".format(it) }

var someString = "test"
val result = someString.toByteArray().toHexString()

Π¦ΠΈΠΊΠ»Ρ‹, вСтвлСния, Π³Ρ€ΡƒΠΏΠΏΠΎΠ²Ρ‹Π΅ ΠΎΠΏΠ΅Ρ€Π°Ρ†ΠΈΠΈ

// ИспользованиС Ρ†ΠΈΠΊΠ»ΠΎΠ²
for (arg in args)
    print(arg)

for (i in args.indices)
    print(args[i])

var i = 0
while (i < args.size) {
    print(args[i++])
}

// ИспользованиС switch (здСсь ΠΎΠ½ when называСтся)
when (test) {
    1 -> print("123")
    "Hello" -> print("jvcbsdjfv")
    is Long -> print("sjkdvnksdv")
    !is String -> print("sdfsdg")
    else -> print("Unknown")
}

// ИспользованиС ΠΈΠ½Ρ‚Π΅Ρ€Π²Π°Π»ΠΎΠ²
if (i in 1..5)
    print("OK")
if (i !in 1..5)
    print("FAIL")
for (i in 1..5 step 1)
    print(i)
    
// Ρ‚Ρ€ΠΈΠ°Ρ€Π½Ρ‹Π΅ ΠΎΠΏΠ΅Ρ€Π°Ρ‚ΠΎΡ€Ρ‹
fun max(a: Int, b: Int) = if (a > b) a else b

// return с ΠΎΠΏΠ΅Ρ€Π°Ρ‚ΠΎΡ€ΠΎΠΌ when
val color = "sfgsdg"
var test = when (color) {
    "Red" -> 0
    "Green" -> 1
    "Blue" -> 2
    else -> throw IllegalArgumentException("Invalid color param value")
}

// try/catch
val result = try {
    print("lkdfjvlkdfjvlkdfg")
} catch (e: ArithmeticException) {
    throw IllegalStateException(e)
}

// Π’Ρ‹Π·ΠΎΠ² Π½Π΅ΡΠΊΠΎΠ»ΡŒΠΊΠΈΡ… ΠΎΠ±ΡŠΠ΅ΠΊΡ‚ΠΎΠ² Ρ‡Π΅Ρ€Π΅Π· with
/*
class Turtle {
    fun penDown()
    fun penUp()
    fun turn(degrees: Double)
    fun forward(pixels: Double)
}

val myTurtle = Turtle()
with(myTurtle) { //draw a 100 pix square
    penDown()
    for(i in 1..4) {
        forward(100.0)
        turn(90.0)
    }
    penUp()
}
*/

Nullable

1. Elvis operator "?:" - Π²Π΅Ρ€Π½Π΅Ρ‚ Π·Π½Π°Ρ‡Π΅Π½ΠΈΠ΅ ΠΈΠ»ΠΈ сдСлаСт дСйствиС (return)
test = value ?: return

2. Use safee call - выполнится Ссли Π½Π΅ null
left?.let { node -> queue.add(node) }
left?.let { queue.add(it) }
left?.let(queue::add)

3. 
// Nullable-значСния ΠΈ ΠΏΡ€ΠΎΠ²Π΅Ρ€ΠΊΠ° Π½Π° null
fun var_null_and_check(str: Any): Int? {
    // Π’ΠΎΠ·Π²Ρ€Π°Ρ‰Π°Π΅Ρ‚ null Ссли str Π½Π΅ содСрТит числа
    // Бсылка Π΄ΠΎΠ»ΠΆΠ½Π° Π±Ρ‹Ρ‚ΡŒ явно объявлСна ΠΊΠ°ΠΊ nullable (символ ?) ΠΊΠΎΠ³Π΄Π° ΠΎΠ½Π° ΠΌΠΎΠΆΠ΅Ρ‚ ΠΏΡ€ΠΈΠ½ΠΈΠΌΠ°Ρ‚ΡŒ Π·Π½Π°Ρ‡Π΅Π½ΠΈΠ΅ null.
    val x = null
    if (str is String || str == null)
        return 1
        //return str.length
    else {
        if (str !is String)
            return 1
        return 0
    }
}

// Π‘ΠΎΠΊΡ€Π°Ρ‰Π΅Π½ΠΈΠ΅ для "Если Π½Π΅ null"
val files = File("Test").listFiles()
println(files?.size)

// Π‘ΠΎΠΊΡ€Π°Ρ‰Π΅Π½ΠΈΠ΅ для "Если Π½Π΅ null, ΠΈΠ½Π°Ρ‡Π΅"
println(files?.size ?: "empty")

// Π’Ρ‹Π·ΠΎΠ² ΠΎΠΏΠ΅Ρ€Π°Ρ‚ΠΎΡ€Π° ΠΏΡ€ΠΈ равСнствС null
/*
val email = name["email"] ?: throw IllegalStateException("Email is missing!")
*/

// Π’Ρ‹ΠΏΠΎΠ»Π½Π΅Π½ΠΈΠ΅ ΠΏΡ€ΠΈ нСравСнствС
/*
val data = ...

data?.let {
    ... // execute this block if not null
}
*/

ΠšΠΎΠ»Π»Π΅ΠΊΡ†ΠΈΠΈ

fun collections() {
        val items = setOf("apple", "banana", "kiwi")
        // ИспользованиС лямбда-выраТСния для Ρ„ΠΈΠ»ΡŒΡ‚Ρ€Π°Ρ†ΠΈΠΈ ΠΈ ΠΌΠΎΠ΄ΠΈΡ„ΠΈΠΊΠ°Ρ†ΠΈΠΈ ΠΊΠΎΠ»Π»Π΅ΠΊΡ†ΠΈΠΈ
        items
            .filter { it.startsWith("A") }
            .sortedBy { it }
            .map { it.toUpperCase() }
            .forEach { print(it) }

        // Read-only ассоциативный список (map)
        var map = mapOf("a" to 1, "b" to 2, "c" to 3)

        // Π˜Ρ‚Π΅Ρ€Π°Ρ†ΠΈΡ ΠΏΠΎ ΠΊΠ°Ρ€Ρ‚Π΅/списку ΠΏΠ°Ρ€
        for ((k, v) in map) {
            println("$k -> $v")
        }

        // ΠžΠ±Ρ€Π°Ρ‰Π΅Π½ΠΈΠ΅ ΠΊ списку
        println(map["key"])

        // read-only list
        val list = listOf("a", "b", "c")
    }

Π›Π΅Π½ΠΈΠ²Ρ‹Π΅ свойства

Π‘ΡƒΠ΄ΡƒΡ‚ вычислСны ΠΏΡ€ΠΈ ΠΎΠ±Ρ€Π°Ρ‰Π΅Π½ΠΈΠΈ

// Π›Π΅Π½ΠΈΠ²Ρ‹Π΅ свойства
val p: String by lazy {
    // compute the string
    return@lazy "sdfsdf"
}

Π‘ΠΈΠ½Π³Π»Ρ‚ΠΎΠ½

// Π‘ΠΎΠ·Π΄Π°Π½ΠΈΠ΅ синглтона
/*
object Resource {
    val name = "Name"
}
*/

Reflection

ΠŸΠΎΠ»ΡƒΡ‡ΠΈΡ‚ΡŒ Type ΠΈΠ»ΠΈ Class

val type = object : TypeToken<MyErrorData>(){}.type
val klass = MyErrorData::class
Π³Π΄Π΅-Ρ‚ΠΎ Π΅Ρ‰Π΅ Ρ‚Π°ΠΊΠΎΠ΅ Π²ΠΈΠ΄Π΅Π»:
val klass = MyErrorData::class.java
val klass = MyErrorData.class

Last updated