1
2

var mutable = 20
val immutable = 10

1
2
3
4
5

// const の例
const val MAX_COUNT = 100
object Constants {
    const val API_KEY = "abcdef123456"
}

1
2
3
4
5

when (x) {
    is Int -> println("It's an Int")
    is String -> println("It's a String")
    else -> println("Unknown type")
}

1
2

val list = listOf(1, 2, 3)
val map = mapOf("a" to 1, "b" to 2)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

//1～10の範囲
for(i in 1..10){
  print(i) //「12345678910」
}
 
//2～10の範囲で2刻み
for(i in 2..10 step 2){
  print(i) //「246810」
}
 
//9～1の範囲（逆順）で2刻み
for(i in 9 downTo 1 step 2){
  print(i) //「97531」
}
println()
 
//1～10の範囲。ただし終わりの値（10）は含まない
for(i in 1 until 10){
  print(i) //「123456789」
}
println()

//a～zの範囲
for(i in 'a'..'z'){
  print(i) // 「abcdefghijklmnopqrstuvwxyz」
}
 
//A～zの範囲で2刻み
for(i in 'A' until 'z' step 2){
  print(i) // 「ACEGIKMOQSUWY[]_acegikmoqsuwy」
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

fun addAndMul(a: Int, b: Int): Pair<Int, Int>{
  return Pair(a + b, a * b)
}

val (wa, seki) = addAndMul(2, 5)
println("和: $wa, 積: $seki") //「和: 7, 積: 10」

val result = addAndMul(2, 5)

//分解宣言は内部的にcomponentN関数を呼び出している
val wa2 = result.component1()
val seki2 = result.component2()
println("和: $wa2, 積: $seki2") //「和: 7, 積: 10」

1
2
3
4
5
6
7
8

//データクラスは自動でcomponentNというメソッドが定義されているので分解宣言がそのまま使える
data class Person(val firstName: String, val lastName: String, val age: Int)
……
//データクラスのインスタンスを作る
val tanaka = Person("一郎", "田中", 25)
//データクラスのオブジェクトを複数の変数に分解して代入する
val (mei, sei, age) = tanaka
println("姓: $sei, 名: $mei, 年齢: $age") //「姓: 田中, 名: 一郎, 年齢: 25」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Person(
    val name: String,
    val age: Int,
    val email: String
)

// 使用例
val john = Person("John Doe", 30, "john@example.com")

// デストラクチャリング
val (name, age, email) = john

println("Name: $name, Age: $age, Email: $email")

// コピーと修正
val olderJohn = john.copy(age = 31)

1
2
3
4
5

sealed class ApiResult<out T> {
    data class Success<out T>(val data: T) : ApiResult<T>()
    data class Error(val message: String) : ApiResult<Nothing>()
    object Loading : ApiResult<Nothing>()
}

1
2
3
4
5

enum class ApiResult {
    SUCCESS,
    ERROR,
    LOADING
}

1
2

typealias Meter = Int
typealias Killometer = Int

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

println("ABC" is String)  // true
println("ABC" !is String)  // false

open class ClassA() {}
class ClassB(): ClassA() {}
var a = ClassA()
var b = ClassB()
println(a is ClassA) // true
println(a is ClassB) // false
println(b is ClassA) // true
println(b is ClassB) // true

1
2
3

open class Parent() {}
class Child(): Parent() {}
var c: Child = Parent() as Child

1
2

var n1: Short? = 123
var n2: Int? = n1 as? Int?

1
2
3
4

fun functionName(param1: Type1, param2: Type2): ReturnType {
    // 関数の本体
    return result
}

1

fun double(x: Int): Int = x * 2

1

fun greet(name: String = "Guest") = println("Hello, $name!")

1
2

fun createUser(name: String, age: Int) = User(name, age)
val user = createUser(age = 25, name = "John")

1

fun sum(vararg numbers: Int): Int = numbers.sum()

1
2
3
4

fun outer() {
    fun inner() = println("Inner function")
    inner()
}

1

fun String.addExclamation() = this + "!"

1

inline fun operation(a: Int, b: Int, op: (Int, Int) -> Int): Int = op(a, b)

1
2

fun operation(x: Int, y: Int, op: (Int, Int) -> Int): Int = op(x, y)
val result = operation(10, 20, { a, b -> a + b })

1
2

fun operation(x: Int, y: Int, op: (Int, Int) -> Int): Int = op(x, y)
val result = operation(10, 20) { a, b -> a + b }

1

list.filter { it > 0 }.map { it * 2 }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

setContent {
    AppTheme {
        MainContent()
    }
}

// 下と同じ
setContent({
    EchoTimerTheme {
        MainContent()
    }
})

1

fun setContent(content: @Composable () -> Unit)

1

val sum = { x: Int, y: Int -> x + y }

1

val multiply: (Int, Int) -> Int = { x, y -> x * y }

1

operator fun Point.plus(other: Point) = Point(x + other.x, y + other.y)

1
2

infix fun Int.times(str: String) = str.repeat(this)
val result = 3 times "Hello "

1
2

tailrec fun factorial(n: Int, acc: Int = 1): Int =
    if (n <= 1) acc else factorial(n - 1, n * acc)

1
2
3

fun <T> printArray(array: Array<T>) {
    array.forEach { println(it) }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 2つ
fun returnPair(): Pair<Int, String> {
    return Pair(42, "Hello")
}

// 3つ
fun returnTriple(): Triple<Int, String, Boolean> {
    return Triple(42, "Hello", true)
}

// 4つ以上で別々の型
data class Result(val value1: Int, val value2: String)

fun multipleValues(): Result {
    return Result(42, "Hello")
}

// 4つ以上で同じ型
fun multipleValues2(): List<Int> {
    return listOf(1, 2, 3, 4, 5)
}

1
2
3

fun printMessage(msg: String) {
    println(msg)
}

1
2
3

fun raiseError(msg: String): Nothing {
    throw MyException(msg)
}

1
2
3
4
5
6

fun add(x: Int, y: Int): Int = x + y

fun main() {
    val method = ::add
    println(method(3, 5))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Example {
    var name: String by Delegate()
}

class Delegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "$thisRef, thank you for delegating '${property.name}' to me!"
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("$value has been assigned to '${property.name}' in $thisRef.")
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

interface Printer {
    fun print()
}

class PrinterImpl(val x: Int) : Printer {
    override fun print() { print(x) }
}

class SomeObject(b: Printer) : Printer by b

fun main() {
    val b = PrinterImpl(10)
    SomeObject(b).print() // 10を出力
}

1
2
3
4

class Foo {
    lateinit var name: String // init()が呼ばれるまで初期化不要
    fun init(name: String) { this.name = name }
}

1
2
3
4
5
6

class Example {
    val lazyValue: String by lazy {
        println("Computed!")
        "Hello"
    }
}

1
2
3
4

val lazyValue: String by lazy {
    println("computed!")
    "Hello"
}

1
2
3

var name: String by Delegates.observable("initial value") {
    prop, old, new -> println("$old -> $new")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// itの使用（let）
person.let { 
    println(it.name)  // it.を使用
    it.age = 30       // it.を使用
}

// thisの使用（apply）
person.apply {
    println(name)     // thisは省略可能
    age = 30          // thisは省略可能
}

1

val length = str?.let { it.length } ?: 0

1
2
3
4

val result = person.run {
    println(name)
    age * 2
}

1
2
3
4

with(person) {
    println(name)
    println(age)
}

1
2
3
4

val person = Person().apply {
    name = "John"
    age = 30
}

1
2
3

val numbers = mutableListOf(1, 2, 3)
numbers.also { println("The list elements are: $it") }
    .add(4)

1

class クラス名 constructor(引数: データ型) {}

1

class Person(private val name: String, public var age: Int = 10)

1
2
3
4
5
6
7

class Person(val name: String, var age: Int) {
    init {
        require(age >= 0) { "Age must be non-negative" }
        name = "bob"
        age = 10
    }
}

1

constructor(引数: データ型): this(引数)

1
2
3
4

class Person(var name:String, var age: Int) {
    // name=引数のname, age=10でプライマリーコンストラクタに渡される
    constructor(name: String) : this(name, 10)
}

1
2
3
4
5
6
7
8
9

class Person {
    var name: String
    var age: Int

    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
    }
}

1
2
3
4
5
6
7
8

class Person(val name: String) {
    var age: Int = 0
    
    // ここのthis(name)でプライマリーコンストラクタを呼び出している
    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Person(val name: String) {
    var age: Int = 0
    var email: String = ""
    
    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }

    // ここが2つめのコンストラクタを使った間接的なプライマリーコンストラクタの呼び出し
    constructor(name: String, age: Int, email: String) : this(name, age) {
        this.email = email
    }
}

1
2
3
4
5

class Foo {
    init {
        println("Foo is created.")
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Person(val name: String, val age: Int = 0) { // ここがプライマリーコンストラクタの引数

    // このinitがプライマリーコンストラクタの本体
    init {
        require(age >= 0) { "Age must be non-negative" }
    }
}

// 使用例
val person1 = Person("Alice", 30)
val person2 = Person("Bob")  // ageはデフォルト値の0が使用される

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Example(val input: String) { // プライマリーコンストラクタの引数
    // ファーストプロパティ
    val first = println("First property")
    
    // ファーストイニシャライザ
    init {
        println("First initializer block: $input")
    }
    
    // セカンダリープロパティ
    val second = println("Second property")
    
    // セカンダリーイニシャライザ
    init {
        println("Second initializer block")
    }
    
    // セカンダリーコンストラクタ
    constructor(input: String, second: Int): this(input) {
        println("Secondary constructor")
    }
}

1
2
3
4
5
6
7
8

fun main() {
    Example("Hello")
}

First property
First initializer block: Hello
Second property
Second initializer block

1
2
3
4
5
6
7
8
9

fun main() {
    Example("Hello", 5)
}

First property
First initializer block: Hello
Second property
Second initializer block
Secondary constructor

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Foo() {
    var name: String = ""
        set(value) {
            println("__set__")
            field = value
        }
        get() {
            println("__get__")
            return field
        }
}

fun main() {
    var a = Foo()
    a.name = "Yamada"  // __set__
    println(a.name) // __get__
}

1

data class User(val name: String, val age: Int)

1
2
3
4
5
6
7
8
9

open class Animal {
    open fun makeSound() { println("Some sound") }
    fun eat() { println("Eating") } // このメソッドはオーバーライド不可
}

class Dog : Animal() {
    override fun makeSound() { println("Bark") } // OK
    // override fun eat() { } // コンパイルエラー
}

1
2
3

abstract class Shape {
    abstract fun draw() // 抽象メソッドは自動的にopen
}

1
2

open class Animal(val name: String)
class Dog(name: String) : Animal(name)

1
2

open class Animal
class Dog : Animal

1
2

open class Animal
class Dog : Animal()

1
2
3
4
5
6
7
8

interface Speakable {
    fun speak()
}
class Person : Speakable {
    override fun speak() {
        println("Hello!")
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

sealed class ApiResult<out T> {
    data class Success<out T>(val data: T) : ApiResult<T>()
    data class Error(val message: String) : ApiResult<Nothing>()
    object Loading : ApiResult<Nothing>()
}

fun handleApiResult(result: ApiResult<String>) {
    when (result) {
        is ApiResult.Success -> println("成功: ${result.data}")
        is ApiResult.Error -> println("エラー: ${result.message}")
        is ApiResult.Loading -> println("読み込み中...")
    }
}

// 使用例
val successResult = ApiResult.Success("データ取得成功")
val errorResult = ApiResult.Error("ネットワークエラー")
val loadingResult = ApiResult.Loading

handleApiResult(successResult)
handleApiResult(errorResult)
handleApiResult(loadingResult)

1
2
3
4
5

class A {
    inner class B { ... }
}

var obj = A().B()

1
2
3
4
5
6

class Foo<T: Number>(val value: T)

fun main() {
    val a1 = Foo(123)
    println(a1.value + 1)  // 124
}

1
2
3
4
5
6
7
8
9

// Java
interface Nextable<T> {
    T nextT();
}

void demo(Nextable<String> strs) {
    Nextable<Object> objects = strs; // !!! Not allowed in Java
    // ...
}

1
2
3
4
5
6
7
8

interface Nextable<out T> {
    fun nextT(): T
}

fun demo(strs: Nextable<String>) {
    val objects: Nextable<Any> = strs // This is OK
    // ...
}

1
2
3
4
5
6
7
8
9

interface Comparable<in T> {
    operator fun compareTo(other: T): Int
}

// NOTE: Numberのsubtypeはdouble
fun demo(x: Comparable<Number>) {
    x.compareTo(1.0) 
    val y: Comparable<Double> = x // ok
}

1
2
3
4

val myObject = object {
    val property = "Hello"
    fun method() = "World"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

interface Greeter {
    fun greet()
}

val englishGreeter = object : Greeter {
    override fun greet() {
        println("Hello!")
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

object MySingleton {
    val CONSTANT_VALUE = 42
    fun printHello() {
        println("Hello from Singleton")
    }
}

fun main() {
    println(MySingleton.CONSTANT_VALUE)
    MySingleton.printHello()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class MyClass {
    companion object {
        const val CONSTANT_VALUE = 42

        fun printHello() {
            println("Hello from Companion Object")
        }
    }
}

fun main() {
    println(MyClass.CONSTANT_VALUE)  // 42
    MyClass.printHello()  // Hello from Companion Object
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class MyClass {
    companion object NamedCompanion {
        const val CONSTANT_VALUE = 42

        fun printHello() {
            println("Hello from Named Companion Object")
        }
    }
}

fun main() {
    println(MyClass.NamedCompanion.CONSTANT_VALUE)  // 42
    MyClass.NamedCompanion.printHello()  // Hello from Named Companion Object
}

1
2

var a: String? = "はろー" //String型の変数
a = null // ok

1
2
3
4
5

var d: String? = null
println(d?.length) //エラーは起きない。「null」が表示される
 
var e: String? = "はろはろ"
println(e?.length) //「4」が表示される

1
2
3

//?:演算子でgetName関数の結果がnullだった場合の値を設定
val name2 :String = getName() ?: "名なしの権兵衛"
println(name2)

1
2
3
4

//!!演算子を使ってnullの入ったNull許容型を無理やり非Null型に変換して参照
var f: String? = null
//コンパイルはできるが、実行時にめでたくNullPointerException発生
println(f!!.length)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

suspend fun fetchUserData() = coroutineScope {
    val userDeferred = async { fetchUser() }
    val friendsDeferred = async { fetchFriends() }
    
    try {
        val user = userDeferred.await()
        val friends = friendsDeferred.await()
        // 両方のデータの処理
    } catch (e: Exception) {
        // エラー処理
    }
}

1
2
3
4
5
6

flow {
    for (i in 1..3) {
        delay(100)
        emit(i) 
    }
}.collect { value -> println(value) } 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// privateで変えられる、setter用
private val _keepScreenOn = MutableStateFlow(settingsPreferences.getBoolean("keepScreenOn", false))  
// publicで変えられない、getter用
val keepScreenOn: StateFlow<Boolean> = _keepScreenOn  

// 利用
lifecycleScope.launch { // AndroidのLifecycleのScope
    viewModel.keepScreenOn.collect { keepOn -> // collectorの処理となる
        if (keepOn) {
          xxx
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val scope = CoroutineScope(Dispatchers.Default)
    val myStateFlow = MutableStateFlow(0)

    scope.launch {
        myStateFlow.collect { value ->
            println("Collected value: $value")
        }
    }
    delay(200)
    // 出力: Collected value: 0  (即座に現在の値が発行される)

    myStateFlow.value = 1
    delay(200)
    // 出力: Collected value: 1

    myStateFlow.value = 1
    delay(200)
    // 重複値なので発行されない

    myStateFlow.value = 2
    delay(200)
    // 出力: Collected value: 2
}

1
2
3

Collected value: 0
Collected value: 1
Collected value: 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val scope = CoroutineScope(Dispatchers.Default)
    val myStateFlow = MutableStateFlow(0)
    val myStateFlow2 = MutableStateFlow(0)

    scope.launch {
        myStateFlow.collect { value ->
            println("Collected myStateFlow: $value")
        }
        myStateFlow2.collect { value ->
            println("Collected myStateFlow2: $value")
        }
    }
    delay(200)
    // 出力: Collected myStateFlow: 0  (即座に現在の値が発行される)

    myStateFlow.value = 1
    delay(200)
    // 出力: Collected myStateFlow: 1

    myStateFlow.value = 1
    delay(200)
    // 重複値なので発行されない

    myStateFlow.value = 2
    delay(200)
    // 出力: Collected myStateFlow: 2

    myStateFlow2.value = 1
    delay(200)
    
    delay(2000)
}

1
2
3

Collected myStateFlow: 0
Collected myStateFlow: 1
Collected myStateFlow: 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

val channel = Channel<Int>()

launch {
    for (i in 1..5) {
        channel.send(i)
    }
    channel.close()
}

for (value in channel) {
    println(value)
}

1
2
3
4
5
6

suspend fun fetchUserData(): UserData {
    // 非同期処理
    val userId = fetchUserId()  // サスペンドポイント1
    delay(100)  // サスペンドポイント2
    return fetchUserDetails(userId)  // サスペンドポイント3
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

suspend fun fetchUserData(): UserData {
    delay(1000) // ネットワーク遅延をシミュレート
    return UserData("John", 30)
}

suspend fun processUser() {
    val deferred = async { fetchUserData() }
    val userData = deferred.await() // 結果が得られるまで中断
    println("User: ${userData.name}")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class MyViewModel : ViewModel() {
    fun loadData() {
        viewModelScope.launch(Dispatchers.IO) {
            val result = performNetworkCall()
            withContext(Dispatchers.Main) {
                updateUI(result)
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

launch(Dispatchers.IO) {
    // I/O操作を行うコード
}

withContext(Dispatchers.Default) {
    // CPU集約型の処理
}

val deferredCPU = async(Dispatchers.Default) {
    // CPU集約型の処理
}
val resultCPU = deferredCPU.await()

1
2
3
4

with open('file.txt', 'r') as file:
    content = file.read()
    print(content)
    # このブロックを抜けると自動でclose

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

val scope = CoroutineScope(Dispatchers.Default)

scope.launch {
    // この中で複数のコルーチンを起動できる
    val result1 = async { fetchData1() }
    val result2 = async { fetchData2() }
    println("Results: ${result1.await()}, ${result2.await()}")
}

// スコープのキャンセル（必要に応じて）
scope.cancel()

1
2
3

val job = launch {
    // コルーチンの処理
}

1
2
3
4

val deferred = async {
    return 42
}
val result = deferred.await() // 42

1
2
3
4

runBlocking {
    delay(1000L)
    println("After delay")
}

1
2
3
4

suspend fun doSomething() = coroutineScope {
    launch { task1() }
    launch { task2() }
}

1
2
3
4

supervisorScope {
    launch { riskyTask1() }
    launch { riskyTask2() }
}

1
2
3

withContext(Dispatchers.IO) {
    // I/O操作
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*

sealed class CounterMsg
object IncCounter : CounterMsg()
class GetCounter(val response: CompletableDeferred<Int>) : CounterMsg()

fun CoroutineScope.counterActor() = actor<CounterMsg> {
    var counter = 0 // アクターの状態
    for (msg in channel) { // メッセージの受信ループ
        when (msg) {
            is IncCounter -> counter++
            is GetCounter -> msg.response.complete(counter)
        }
    }
}

suspend fun main() = coroutineScope {
    val counter = counterActor() // アクターの作成
    withContext(Dispatchers.Default) {
        massiveRun { counter.send(IncCounter) } // 多数の増加メッセージを送信
    }
    // 最終的なカウンターの値を取得
    val response = CompletableDeferred<Int>()
    counter.send(GetCounter(response))
    println("Counter = ${response.await()}")
    counter.close() // アクターを終了
}

suspend fun massiveRun(action: suspend () -> Unit) {
    val n = 100  // 起動するコルーチンの数
    val k = 1000 // 各コルーチンで実行する繰り返しの回数
    val time = measureTimeMillis {
        coroutineScope { 
            repeat(n) {
                launch {
                    repeat(k) { action() }
                }
            }
        }
    }
    println("Completed ${n * k} actions in $time ms")    
}