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