val a: Int = 10000 // これはJVMのプリミティブ型として格納される
print(a === a) // 'true'と表示される
val boxedA: Int? = a    // boxingされる
val anotherBoxedA: Int? = a // boxingされる
print(boxedA === anotherBoxedA) // !!!'false'と表示される!!!
// 内部の値の等価性は保持される
print(boxedA == anotherBoxedA) // 'true'と表示される

// もし〜だったら的な仮想コード。コンパイルできない。
val a: Int? = 1 // Int (java.lang.Integer)にBoxingされる
val b: Long? = a // 暗黙変換で Long (java.lang.Long)にBoxingされる
print(a == b) // ちょwwwこいつ"false"とか言うwww
// Longのequals()がもう一方の型もLongかチェックするからなんですね〜

// 1はIntだけど変数型がByteなのでコンパイル時にByte型の数値として扱われる
val b: Byte = 1 // OK, 数値は静的にチェックされる
// Byte型の値をInt型に格納しても暗黙型変換はされない
val i: Int = b // ERROR

val i: Int = b.toInt() // OK: 明示的に型変換

// a + b では a.plus(b) が呼ばれる。LongがIntを受け取るplusメソッドを用意している。
val l = 1L + 3 // Long + Int => Long

// shlは算術左シフトを行う
val x = (1 shl 2) and 0x000FF000

fun check(c: Char) {
  if (c == 1) { // ERROR: 暗黙の型変換
    // ...
  }
}

fun decimalDigitValue(c: Char): Int {
  if (c !in '0'..'9')
    throw IllegalArgumentException("Out of range")
  return c.toInt() - '0'.toInt() // 明示的に数値に変換
}

class Array<T> private constructor() {
  val size: Int
  fun get(index: Int): T
  fun set(index: Int, value: T): Unit

  fun iterator(): Iterator<T>
  // ...
}

// [1, 2, 3]を作る
val list = arrayOf(1, 2, 3)
// nullで埋められたサイズ3の配列を作る
var arr: Array<Int?> = arrayOfNulls(3)
// Array<String>型で値が ["0", "1", "4", "9", "16"]の配列を作る
val asc = Array(5, { i -> (i * i).toString() })

// プリミティブ型の配列である IntArray を用いる
val x: IntArray = intArrayOf(1, 2, 3)  // 型を明示したが、推論してくれるので省略可能
x[0] = x[1] + x[2]

for (c in str) {
  println(c)
}

// Javaの文字列と同じ感じのやつ
val s = "Hello, world!\n"

// トリプルクォートを使うとスケープが効かない生文字列になる
val text = """
  for (c in "foo")
    print(c)
"""

val i = 10
val s = "i = $i" // i = 10

val s = "abc"
val str = "$s.length is ${s.length}" // abc.length is 3

// $そのものを表現するには
val price = "${'$'}9.99" // $9.99

// 所属するパッケージ名を指定
package foo.bar

// フルネームはfoo.bar.baz
fun baz() {}

// フルネームはfoo.bar.Goo
class Goo {}

// ...

import foo.Bar // これでBarにアクセスできる

import foo.* // fooの下にあるものが全てアクセスできる

import foo.Bar // Barにアクセスできる
import bar.Bar as bBar // bBarは'bar.Bar'を表す

// 伝統的な使い方
var max = a
if (a < b)
  max = b

// else付き
var max: Int
if (a > b)
  max = a
else
  max = b

// ifが式であることを利用した三項演算子的使い方
val max = if (a > b) a else b

val max = if (a > b) {
    print("Choose a")
    a
  }
  else {
    print("Choose b")
    b
  }

when (x) {
  1 -> print("x == 1")
  2 -> print("x == 2")
  // どれにも当てはまらないならelseが実行される
  else -> { // ブロックも使える
    print("x is neither 1 nor 2")
  }
}

when (x) {
  // 0と1で同じ処理なら、コンマで結合できる
  0, 1 -> print("x == 0 or x == 1")
  else -> print("otherwise")
}

when (x) {
  // 定数でなくてもマッチさせられる
  parseInt(s) -> print("s encodes x")
  else -> print("s does not encode x")
}

when (x) {
  // 範囲に含まれるか
  in 1..10 -> print("x is in the range")
  // 配列などのコレクションに含まれるか
  in validNumbers -> print("x is valid")
  // 否定も使える。範囲に含まれなければ実行される。
  !in 10..20 -> print("x is outside the range")
  else -> print("none of the above")
}

val hasPrefix = when(x) {
  // 型チェックもできる。チェック後は自動的にキャストされる。
  is String -> x.startsWith("prefix") // xはStringとして扱える
  else -> false
}

when {
  x.isOdd() -> print("x is odd")
  x.isEven() -> print("x is even")
  else -> print("x is funny")
}

// まぁこれは説明いらないよね
for (item in collection)
  print(item)

// もちろんボディはブロックにできる
for (item: Int in ints) {
  // ...
}

// 最適化によってindicesは実際にはオブジェクトを生成しないのでパフォーマンス劣化はない
for (i in array.indices)
  print(array[i])

// withIndex()でインデックスと値のペアで回すこともできる
for ((index, value) in array.withIndex()) {
    println("the element at $index is $value")
}

while (x > 0) {
  x--
}

do {
  val y = retrieveData()
} while (y != null) // ここでyが見える！

// ラベルを使って直近でなく指定ラベルのループを抜ける
loop@ for (i in 1..100) {
  for (j in 1..100) {
    if (...)
      break@loop
  }
}

fun foo() {
  ints.forEach {
    if (it == 0) return // これはforEachでなくfooを抜ける
    print(it)
  }
}

fun foo() {
  ints.forEach lit@ {
    if (it == 0) return@lit
    print(it)
  }
}

fun foo() {
  ints.forEach {
    if (it == 0) return@forEach // foo関数ではなくforEachに渡したラムダを抜ける（処理１回分）
    print(it)
  }
}

fun foo() {
  ints.forEach(fun(value: Int) {
    if (value == 0) return // foo関数ではなくforEachに渡した無名関数を抜ける（処理１回分）
    print(value)
  })
}

return@a 1