JavaプログラマのためのKotlin入門

![kotlin.png](https://qiita-image-store.s3.amazonaws.com/0/47085/9ffaf5e6-443f-e713-6114-a54dc1652cbc.png)

[Kotlin が Android の公式言語になる](https://blog.jetbrains.com/jp/2017/05/18/767)ことが Goole I/O 2017 で発表されました。 Java プログラマが Kotlin を始めることがこれから多くなると思うので、 Kotlin をスムーズに始められるように次の 3 点についてまとめます。

1. **Javaとほぼ同じところ**
2. **[新しい考え方が必要でつまづきがちなところ](http://qiita.com/koher/items/d9411a00986f14683a3f)**
3. **[Kotlinならではの便利なこと](http://qiita.com/koher/items/cb91dbbff9b14575f498)**

すべてを一つの投稿にすると長くなるので連載形式とし、本投稿では最初の「Javaと同じところ」について説明します。

## Kotlinって何？

本題の前に、 Kotlin について簡単に説明します。

まずは↓の Android のコードを見て下さい。これは Android Studio が生成するテンプレートの Kotlin 版です。 Android アプリ開発者であれば、初見でも概ね何をしているのかわかると思います。

```kotlin
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val toolbar = findViewById(R.id.toolbar) as Toolbar
        setSupportActionBar(toolbar)

        val fab = findViewById(R.id.fab) as FloatingActionButton
        fab.setOnClickListener { view ->
            Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                    .setAction("Action", null).show()
        }
    }

    override fun onCreateOptionsMenu(menu: Menu): Boolean {
        menuInflater.inflate(R.menu.menu_main, menu)
        return true
    }

    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        val id = item.itemId


        if (id == R.id.action_settings) {
            return true
        }

        return super.onOptionsItemSelected(item)
    }
}
```

[Kotlin](https://kotlinlang.org/) は JetBrains 社が作っている JVM 上で動作する言語で、 **"100% interoperable with Java (Java と完全に相互運用可能 )"** を謳っています。あるクラス `A` を Java で書いて、それを継承した `B` を Kotlin で書いて、さらに `B` を継承した `C` を Java で書いたりできます。そのため、 **これまで Java で書かれていたプロジェクトに、追加開発分だけ Kotlin を混ぜ込むようなことでき、新規採用もしやすいです**。

Kotlin は元々 Android で Java の代わりによく使われている言語です。 Android Studio は IntelliJ IDEA という IDE をベースに作られていますが、 JetBrains は IntelliJ IDEA の開発元です。当然 Kotlin は Android Studio でもうまく動くようにできており、 Google が公式に Kotlin を採用しているわけではないけど Android Studio （のベースである IntelliJ IDEA ）では公式にサポートされているという、半公式言語のような状態でした。今回は、そんな Kotlin を Android の公式言語にしますよと Google が発表したという話です。

JetBrains は Java 用の IDE を作っているだけあって、 Java の良いところ・悪いところを熟知しています。 **Kotlin は Better Java としてかゆいところに手が届くように作られており、一方で Java プログラマが抵抗感なくすんなりと受け入れられるようにできています。** 特にパラダイムが大きく異なるわけでもないので、 Java プログラマならすぐに使えるようになると思います。僕の務める [Qoncept](http://qoncept.co.jp/) では、 Java プログラマが新しく Kotlin のプロジェクトにアサインされる場合でも、 2, 3 日の勉強だけで実践投入されています[^1]。個人的には、 Kotlin のパラダイムは Java とほぼ重なっているので新しく学習すべきことが少なく、 Scala などの他の JVM 言語と比べると敷居が低いように思います[^4]。

僕の主観では、 Kotlin で書くと Java と比べて倍以上生産性が高いように感じます。かつて Java は 10 年ほどの長きにわたって僕のベスト言語でしたが、今では Java に戻ることはできません。↓のように、 Android に限らず Java の代わりに Kotlin を使っています。

<blockquote class="twitter-tweet" data-lang="ja"><p lang="ja" dir="ltr">Windows で動く簡単な GUI アプリ作んないといけなくて Java の Swing でやってるんだけど、コードを Kotlin で書いたら普通に動いて、 &quot;100% Java Interoperability&quot; のすごさを実感してる。</p>&mdash; koher (@koher) <a href="https://twitter.com/koher/status/720928078080270337">2016年4月15日</a></blockquote>

### Kotlinのインストール

- **とりあえずブラウザ上で試す**: インストールしなくても[こちら](https://try.kotlinlang.org/)からブラウザ上で実行可能
- **Android Studio 3.0**: Kotlin がプリインされたプレビュー版を[ダウンロード]((https://try.kotlinlang.org/))
- **Android Studio 2.x**: `Plugins > Install JetBrains plugin…` から `Kotlin` で検索してプラグインをインストール（[詳細]((https://kotlinlang.org/docs/tutorials/kotlin-android.html))）
- **IntelliJ IDEA**: 同上（[詳細](https://kotlinlang.org/docs/tutorials/getting-started.html)）
- **コマンドライン**: Mac なら `brew install kotlin` 、その他環境も詳細は[こちら](https://kotlinlang.org/docs/tutorials/command-line.html)

## Javaとほぼ同じところ

Kotlin では多くの概念は Java と同じです。構文の見た目が違うだけなので、対応関係を覚えるだけでそれなりにプログラムが書けるようになります。本節では、そのような対応関係について説明します。

それぞれ、末尾に参考になる公式ドキュメントへのリンクをつけてありますので、詳細を知りたい場合はそちらを併せて御覧下さい。

### Hello, world!

```java
// Java
public class Main {
  public static void main(String[] args) {
      System.out.println("Hello, world!");
  }
}
```

```kotlin
// Kotlin
fun main(args: Array<String>) {
  println("Hello, world!")
}
```

Kotlin では `main` メソッドのためにわざわざクラスを作る必要がありません。また、 Kotlin では `println` がメソッドではなくクラスに属さない関数として実装されています。そのため `System.out` を書く必要がありません。関数は `static` メソッドのようなものなので、 `static` も書く必要がありません。デフォルトで `public` なので `public` も不要です。さらに、 Kotlin では文の末尾の `;` も要りません。

`fun` や `Array<String>` などの書式については後で説明します。

- Creating and running a first application: https://kotlinlang.org/docs/tutorials/command-line.html#creating-and-running-a-first-application

### 演算子、リテラル、コメント

基本的に Java と同じです。 `0x0F` や `42L` などのリテラルも使えます。また、他のいくつかの言語のように、桁が見やすいように `1_000_000` のようにアンダースコアを入れることもできます。

- Literal Constants: https://kotlinlang.org/docs/reference/basic-types.html#literal-constants
- String Literals: https://kotlinlang.org/docs/reference/basic-types.html#string-literals
- Comments: https://kotlinlang.org/docs/reference/basic-syntax.html#comments

### 変数宣言

```java
// Java
String s = "abc";
final String t = "xyz";
```

```kotlin
// Kotlin
var s: String = "abc"
val t: String = "xyz"
```

ご覧のように Kotlin では Java と違い、変数名の後ろに型を書きます。また、 `final` な変数を宣言するには `val` 、変更可能な変数を宣言するには `var` を使います。現代のプログラミングでは不変でよいものは不変にするのが望ましいと言われることが多いですが、 Java では `final` を付けるのが面倒でした。 `val` と `var` ならタイプ数も同じです。 **Kotlin では `var` に優先して `val` を使い、どうしても再代入可能にしたい場合にだけ `var` を使います。**[^2]

`var` や `val` を書くのが面倒と感じられるかもしれませんが、 Kotlin では **_型推論（ Type Inference ）_** によって変数宣言時に型を省略することができるため、変数宣言を Java よりも簡潔に書けることが多いです。

```kotlin
// Kotlin
var s = "abc"
val t = "xyz"
```

変数宣言時に型を省略した場合、右辺値（この場合は `"abc"` や `"xyz"` ）から変数の型が推論されます。

- Defining local variables: https://kotlinlang.org/docs/reference/basic-syntax.html#defining-local-variables

### プリミティブ型

Kotlin では Java でいうプリミティブ型の型名も `Int`, `Double`, `Boolean` のように大文字で始めます。

```java
// Java
int a = 42;
final boolean b = true;
```

```kotlin
// Kotlin
var a: Int = 42
val b: Boolean = true
```

これらの型はクラスとして振る舞うのでメソッドを呼ぶことができます。 Java の発想では `Integer` などのクラスにボクシングされているのではないかと考えてしまいますが、そうではありません。内部的にはプリミティブとして扱われ、 `Int` のメソッドを呼ぶのは Java で `static` メソッドに `int` を渡すのと等価です。そのため、パフォーマンス上の心配はありません。ただし、 `List<Int>` などに渡された場合は Kotlin でもボクシングされます。

```java
// Java
String s = Integer.toString(a);
```

```kotlin
// Kotlin
val s = a.toString()
```

- Basic Types: https://kotlinlang.org/docs/reference/basic-types.html

### 制御構文

#### `if`

基本的に Java と同じです。しかし、 Kotlin の `if` は式として使えるので、次のように `if` や `else` ブロックの中で最後に評価された式の値を直接代入することができます。

```java
// Java
final String foo;
if (bar < 42) {
  foo = "abc";
} else {
  foo = "xyz";
}
```

```kotlin
// Kotlin
val foo = if (bar < 42) {
  "abc"
} else {
  "xyz"
}
```

`if` が式ということは Java の三項演算子 `x ? y : z` のように使えるため、 Kotlin には三項演算子がありません。三項演算子のようなことをやりたければ `if` を使えば十分です。

```java
// Java
final String foo = bar < 42 ? "abc" : "xyz";
```

```kotlin
// Kotlin
val foo = if (bar < 42) "abc" else "xyz"
```

- If Expression: https://kotlinlang.org/docs/reference/control-flow.html#if-expression

#### `while`, `do` - `while`

Java と同じです。

- While Loops: https://kotlinlang.org/docs/reference/control-flow.html#while-loops

#### `for`

Kotlin には Java でいう拡張 `for` 文しかありません。構文はほぼ同じですが、 `:` の代わりに `in` を使います。 Java では↓の `number` の型を記述しなければならないですが、 Kotlin ではここでも型推論で省略できます。

```java
// Java
for (int number : numbers) {
  System.out.println(number);
}
```

```kotlin
// Kotlin
for (number in numbers) {
  println(number)
}
```

↓のような `for` 文相当のことをするには次のように書きます。

```java
// Java
for (int i = 0; i< 100; i++) {
  System.out.println(i);
}
```

```kotlin
// Kotlin
for (i in 0 until 100) {
  println(i)
}
```

この `until` は特殊な構文ではなくただのメソッドで、 `0.until(100)` と同じです。 Kotlin ではこのように、 `+`, `*` などの二項演算子と同じような中置記法のメソッドを作ることができます。 `0 until 100` の戻り値は `IntRange` で、 `IntRange` は `Iterable` なので `for` - `in` でループできるわけです。

この他にも、様々なメソッドを使って多様なループを表現できます。

```kotlin
// Kotlin
for (i in 99 downTo 0) println(i) // for (int i = 99; i >= 0; i--)
for (i in 0 until 100 step 2) println(i) // for (int i = 0; i < 100; i += 2)
for (i in 1..100) println(i) // for (int i = 1; i <= 100; i++)
```

- For Loops: https://kotlinlang.org/docs/reference/control-flow.html#for-loops
- Ranges: https://kotlinlang.org/docs/reference/ranges.html

### `switch` → `when`

`switch` 文は Kotlin では `when` になります。 `when` も式として使えるので、次のように簡単に書けます。また、 `switch` と違って次の `case` に進むことはないので `break` を忘れる心配もありません。

```java
// Java
final String s;
switch (a) {
  case 0:
    s = "abc";
    break;
  case 1:
  case 2:
    s = "def";
    break;
  default:
    s = "xyz"
    break;
}
```

```kotlin
// Kotlin
val s = when (a) {
  0 -> "abc"
  1, 2 -> "def"
  else -> "xyz"
}
```

- When Expression: https://kotlinlang.org/docs/reference/control-flow.html#when-expression

### `new`

Kotlin では Java と違ってコンストラクタの呼び出しに `new` は不要です。

```java
// Java
final Foo foo = new Foo();
```

```kotlin
// Kotlin
val foo = Foo()
```

### クラス

Kotlin でもクラスの考え方は Java と同じです。しかし、 Kotlin ではずいぶんとすっきり書くことができます。

```java
// Java
public class Person {
  private final String firstName;
  private final String lastName;
  private int age;

  public Person(String firstName, String lastName, int age) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.age = age;
  }

  public String getFirstName() {
    return firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public int getAge() {
    return age;
  }

  public void setAge(int age)) {
    this.age = age;
  }

  public String getFullName() {
    return firstName + " " + lastName;
  }
}
```

```kotlin
// Kotlin
class Person {
  val firstName: String
  val lastName: String
  var age: Int

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

  fun getFullName(): String {
    return firstName + " " + lastName
  }
}
```

Kotlin ではデフォルトが `public` なので `public` を書く必要がありません。他に `private`, `protected`, `internal` があります。 `private` は Java と同じです。 `protected` もほぼ同じですが Java と違って同一パッケージ内でもサブクラスからしかアクセスできません。 `internal` は Java のデフォルトアクセスレベルであるパッケージプライベートと違い、同一モジュール内からアクセスできます。モジュールとは一緒にコンパイルされるソース群のことで、 `internal` であっても一緒にコンパイルさえされていればパッケージを超えてアクセスすることができます。

次に、 `firstName`, `lastName`, `age` の getter, setter がないことに気付きます。 Java では `firstName` などに付けられていた `private` 修飾子もありません。実は、 Kotlin にはフィールドがありません。 `firstName` などはプロパティと呼ばれるもので Java のフィールドと getter, setter をまとめたようなものです。プロパティについては後で詳しく説明します。

getter や setter を書かなくて良いのでコードがずいぶんと短くなりました。 Java のコードは 31 行ですが、 Kotlin では 15 行です。しかし、↑のコードはわかりやすいようにあえて Java っぽく書いたものです。まだまだ短くなります。

- Classes: https://kotlinlang.org/docs/reference/classes.html#classes
- Visibility Modifiers: https://kotlinlang.org/docs/reference/visibility-modifiers.html

#### プロパティ

**_プロパティ（ Property ）_** はフィールドと getter, setter を合わせたようなものです。次のように使います。

```java
// Java
final int age = person.getAge();
person.setAge(age + 1);
```

```kotlin
// Kotlin
val age = person.age
person.age = age + 1
```

これだけだと Java でフィールドを `public` にしたのと同じに思えるかもしれません。しかし、プロパティはフィールドと違い、メソッドのように処理の結果を返すこともできます。 `getFullName` メソッドを `fullName` というプロパティに書き変えてみます。

```java
// Java
public class Person {
  ...

  public String getFullName() {
    return firstName + " " + lastName;
  }
}
```

```kotlin
// Kotlin
class Person {
  ...

  val fullName: String
    get() {
      return firstName + " " + lastName
    }
}
```

こうして実装されたプロパティは普通のプロパティと同じように `person.fullName` で呼び出すことができます。なお、 `val` ではなく `var` とすると、 `set` を使って setter 相当の実装をすることもできます。

さらに、プロパティの実装が式一つで済む場合は、次のように省略して書けます。

```kotlin
// Kotlin
  val fullName: String
    get() = firstName + " " + lastName
```

Java でフィールドを `public` にせず getter や setter を作るのは、フィールドだとサブクラスでオーバーライドして挙動を変えたり、インターフェースで抽象化することができないからです。 Kotlin のプロパティはメソッドと等価なので、サブクラスでオーバーライドしたり、インターフェースにプロパティを宣言して、それをオーバーライドして実装することもできます。

- Properties and Fields: https://kotlinlang.org/docs/reference/properties.html
- Overriding Properties: https://kotlinlang.org/docs/reference/classes.html#overriding-properties

#### コンストラクタ

Kotlin では次のようにして、プロパティの宣言とコンストラクタの宣言をまとめてやってしまうことができます。

```kotlin
// Kotlin
class Person(val firstName: String, val lastName: String, var age: Int) {
  ...
}
```

Java でフィールドの宣言とコンストラクタや getter, setter の実装は冗長なコードになりがちで IDE で自動生成することが多いですが、 Kotlin では↑だけで済んでしまします。 `...` に入るのはさっきの `fullName` の実装（ 2 行）だけなので、なんと Java で 31 行だったコードが 4 行になってしまいました。

このような形で書くコンストラクタを **_プライマリコンストラクタ（ Primary Constructor ）_** と呼びます。プライマリコンストラクタは便利ですが、これではプロパティを初期化する以外の処理を書けません。プライマリコンストラクタにプロパティを初期化する以外の処理を書くには `init` を使います。

```java
// Java
public class Person {
  private final String firstName;
  private final String lastName;
  private int age;

  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
    age = 0;
  }

  ...
}
```

```kotlin
// Kotlin
class Person(val firstName: String, val lastName: String) {
  var age: Int

  init {
    age = 0
  }

  ...
}
```

一方、 `constructor` で作るコンストラクタを **_セカンダリコンストラクタ（ Secondary Constructor ）_** と呼びます。プライマリコンストラクタは一つしか作れませんが、セカンダリコンストラクタはいくつでも作ることができます。

```java
// Java
public class Person {
  private final String firstName;
  private final String lastName;
  private int age;

  public Person(String firstName, String lastName, int age) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.age = age;
  }

  public Person(String firstName, String lastName) {
    this(firstName, lastName, 0);
  }

  ...
}
```

```kotlin
// Kotlin
class Person(val firstName: String, val lastName: String, var age: Int) {
  constructor(firstName: String, lastName: String) : this(firstName, lastName, 0) {
  }

  ...
}
```

↑でやりたいのは、 `age` を省略できるコンストラクタを作りたいだけです。そんなときはわざわざセカンダリコンストラクタを作らなくても、プライマリコンストラクタにデフォルト引数を設定することができます。

```kotlin
// Kotlin
class Person(val firstName: String, val lastName: String, var age: Int = 0) {
  ...
}
```

こうしておくと、 `age` を省略してコンストラクタを呼ぶと `age` に `0` を渡したものとして実行されます。

```kotlin
// Kotlin
val person = Person("Albert", "Einstein")
// Person("Albert", "Einstein", 0) と同じ
```

-　Constructors: https://kotlinlang.org/docs/reference/classes.html#constructors

#### メソッド

```java
// Java
public class Person {
  ...

  // 時間経過を表すメソッド
  public int elapse(int years) {
    age += years;
    return age;
  }
}
```

```kotlin
// Kotlin
class Person(val firstName: String, val lastName: String) {
  ...

  // 時間経過を表すメソッド
  fun elapse(years: Int): Int {
    age += years
    return age
  }
}
```

メソッドについては特に変わったところはありません。メソッドの宣言は `fun` で始めます。引数も変数宣言と同じように `years: Int` というスタイルで書き、戻り値の型も末尾で `: Int` のように指定します。戻り値がない場合は `: Void` ではなく `: Unit` と書くか、戻り値の型の記述を省略します。

なお、メソッドについても式一つで済む場合は、↓のように省略形で書くことができます。

```kotlin
// Kotlin
fun getFullName(): String = firstName + " " + lastName
```

また、コンストラクタ引数同様に、デフォルト引数を与えてオーバーロードの代わりとすることもできます。

```java
// Java
  public int elapse(int years) {
    age += years;
    return age;
  }

  public int elapse() {
    return elapse(1);
  }
```

```kotlin
// Kotlin
  fun elapse(years: Int = 1): Int {
    age += years
    return age
  }
}
```

#### 継承

Kotlin ではデフォルトでクラスやメソッドは `final` 扱いです。これは、現代のプログラミングにおいては実装の継承は良いことではなく、必要最小限にとどめるべきとされているからです。 `final` でなくすには `open` のキーワードを付けます。

```java
// Java
public class Person {
  ...

  public String getFullName() {
    return firstName + " " + lastName;
  }
}

public final class EasternPerson extends Person {
  public EasternPerson(String firstName, String lastName, int age) {
    super(firstName, lastName, age);
  }

  @Override
  public String getFullName() {
    return lastName + " " + firstName; // 姓 名の順にする
  }
}
```

```kotlin
// Kotlin
// `open` で `final` でなくす
open class Person(val firstName: String, val lastName: String, var age: Int) {
  ...

  open val fullName: String // `final` でなくす
    get() = firstName + " " + lastName
}

class EasternPerson(firstName: String, lastName: String, age: Int) : Person(firstName, lastName, age) {
  override val fullName: String
    get() = lastName + " " + firstName // 姓 名の順にする
}
```

`extends` の代わりには上記のように `:` を使います。 `EasternPerson` のプライマリコンストラクタの引数には `val` も `var` も付いていないことに注目して下さい。 `val` や `var` を付けるとプロパティを宣言するという意味になってしまいますが、何も付けなければそれはただの引数であることを意味します。ここでは `super` クラスのコンストラクタに渡す引数にしたいだけなので `var` も `val` も必要ありません。

`: Person(firstName, lastName, age)` の `(firstName, lastName, age)` の部分は、 Java でいう `super(firstName, lastName, age)` に当たります。

また、 Java では `@Override` は強制ではないですが、 Kotlin では修飾子となり必須です。これによって、 `@Override` を付け忘れて typo するようなミスも確実に防げます。

- Inheritance: https://kotlinlang.org/docs/reference/classes.html#inheritance

### インタフェース

インタフェースも書き方が異なるだけで考え方は Java と同じです。

```java
// Java
public interface Foo {
  int getBar();
  void baz(String qux);
}
```

```kotlin
// Kotlin
interface Foo {
  val bar: Int
  fun baz(qux: String)
}
```

↑の `bar` のように、インターフェースでプロパティを宣言してクラスにそれを実装させることができます。このことからも、プロパティがメソッドのようなものであることがわかります。

```kotlin
// Kotlin
class ConcreteFoo(override val bar: Int): Foo {
  override fun baz(qux: String) {
    println(qux)
  }
}
```

- Interfaces: https://kotlinlang.org/docs/reference/interfaces.html

### ジェネリクス

Kotlin でも Java と同じようにジェネリクスが使えます。

```java
// Java
public final class Box<T> {
  private T value;

  public Box(T value) {
    this.value = value;
  }

  public T getValue() {
    return value;
  }

  public void setValue(T value) {
    this.value = value;
  }
}
```

```kotlin
// Kotlin
class Box<T>(var value: T)
// {} の中に何も書かないなら↑の後の {} も不要
```

変性のコントロールは `out` , `in` を使って簡潔に書けます。

```java
// Java
final Box<? extends Cat> cat = new Box(new Cat());
final Box<? extends Animal> animal = cat;

final Box<? super Animal> animal = new Box(new Animal());
final Box<? super Cat> cat = animal;
```

```kotlin
// Kotlin
val cat: Box<out Cat> = Box(Cat())
val animal: Box<out Animal> = cat

val animal: Box<in Animal> = Box(Animal())
val cat: Box<in Cat> = animal
```

なお、 Kotlin では利用時ではなく、 C# や Scala のように型パラメータの宣言時に変性を決定することもできますが、それについては次回の投稿で説明します。

- Generics: https://kotlinlang.org/docs/reference/generics.html

### コレクション

Kotlin にも `List` や `Map`, `Set` などがありますが、それぞれ `List` と `MutableList` のように分かれています。 `List` のインスタンスは `listOf` という関数で、 `MutableList` のインスタンスは `mutableListOf` という関数で作ります。 Kotlin でも `ArrayList` や `HashMap` 等が使えますが、特にこだわらないときにはコンストラクタでコレクションのインスタンスを生成するのではなく、 `listOf` 等の関数を使います。 `MutableList` は名前の通り可変です。

```java
// Java
final List<Integer> a = Collections.unmodifiableList(Arrays.asList(2, 3, 5));

final List<Integer> b = new ArrayList();
b.add(2);
b.add(3);
b.add(5);
```

```kotlin
// Kotlin
val a: List<Int> = listOf(2, 3, 5)

val b: MutableList<Int> = mutableListOf()
b.add(2) // 可変
b.add(3) // 可変
b.add(5) // 可変
```

なぜわざわざ `List`, `MutableList` のように分かれているのでしょうか。現代のプログラミングではミュータブルである必要のないクラスはできるだけイミュータブルにしておきたいという考え方があります。イミュータブルなクラスを作ろうとするとイミュータブルなコレクションがほしくなります。保持しているコレクションがミュータブルだと、そのクラスがイミュータブルであることを保証できなくなるからです。

そのため、イミュータブルであることを型で表したいというニーズがあります。しかし、実は Kotlin のように `List` と `MutableList` に分けただけではそれは実現できません。 `MutableList` が `List` のサブタイプであるために、↓のように `List` を変更できてしまうからです。

```kotlin
// Kotlin
val a = mutableListOf(2, 3, 5)
val b: List<Int> = a

println(b) // [2, 3, 5]

a.add(7)

println(b) // [2, 3, 5, 7]
```

Kotlin の `List` はイミュータブルな `List` ではなく、リードオンリーなビューとしての役目しか果たせません。僕は、この点については `List` を実装した `ImmutableList` クラスを別に作って、 Scala のように厳密に区別すべきだったと思います。

- Collections: https://kotlinlang.org/docs/reference/collections.html

### 配列

配列についても `Array<String>` のようなジェネリクスを使った表記をします。プリミティブ型の配列については `Array<Int>` などではなく `IntArray` などを使います。 `Array<Int>` は Java でいう `Integer[]` に相当し効率が悪いので、 `int[]` 相当の `IntArray` などのクラスが別途用意されています。

```java
// Java
final int[] a = new int[] { 2, 3, 5};
```

```kotlin
// Kotlin
val a = intArrayOf(2, 3, 5)
```

- Arrays: https://kotlinlang.org/docs/reference/basic-types.html#arrays

### ラムダ式

Kotlin でも Java 8 以降同様にラムダ式を使えますが、必ずラムダ式全体を　`{}` で囲む必要があります。

```java
// Java
final Stream<Integer> squared = numbers.map(x -> x * x);
```

```kotlin
// Kotlin
val squared = numbers.map({ x -> x * x })
```

なお、 Kotlin のコレクションは `map` や `filter` などが直接使えるように拡張されているので、↑のようなコードを `List` で直接使うことができます。

また、 Kotlin では最後のパラメータにラムダ式を渡す場合には、ラムダ式を `()` の外に出すことができます。さらに、引数がラムダ式しかないメソッドの場合には、 `()` そのものを省略することができます。加えて、ラムダ式の引数が一つしかない場合には、それを省略して `it` とすることができます。これらを合わせると↑のコードは次のように書けます。

```kotlin
// Kotlin
val squared = numbers.map { it * it }
```

- Higher-Order Functions and Lambdas: https://kotlinlang.org/docs/reference/lambdas.html

### `try` - `catch` - `finally`

`try` - `catch` - `finally` も Java と同じように使えます。一番大きな違いは、 Kotlin には検査例外がないことです。 Java で検査例外を `throw` するメソッドでもすべて非検査例外扱いになり、 `catch` しなくてもコンパイルエラーになりません。僕は、[検査例外に関してはこちらのような考え](http://qiita.com/koher/items/e4c1d88981291c35d571)なので、検査例外をなくしてしまったことが Kotlin の言語仕様の中で一番イケてないところだと考えています。

Java の try-with-resources も Kotlin にはないですが、 `use` メソッドで似たようなことができます。

```java
// Java
try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)))) {
  ...
} catch (IOException e) {
  ...
}
```

```kotlin
// Kotlin
try {
  file.bufferedReader().use { reader ->
    ...
  }
} catch (e: IOException) {
  ...
}
```

`use` については次々回に詳しく説明します。

- Exceptions: https://kotlinlang.org/docs/reference/exceptions.html

### `package` と `import`

`package` や `import` の書き方は末尾の `;` がないだけで Java と同じです。 Kotlin から Java のパッケージを `import` し、それを使ったり Java のクラスを継承したりすることもできます。

Java ではクラス名が重複しているときに完全修飾名を使わなければならなかったので面倒でしたが、 Kotlin では `as` で別名を付けることができるので楽ちんです。

```kotlin
// Kotlin
import java.util.Date
import java.sql.Date as SqlDate
```

- Packages: https://kotlinlang.org/docs/reference/packages.html
- Imports: https://kotlinlang.org/docs/reference/packages.html#imports

## まとめ

Kotlin は、構文の見た目が異なるだけで、ほぼ Java に対応しているのがわかると思います。今回の内容だけでも大体のプログラムは Kotlin で書けそうと思えたのではないでしょうか。 Kotlin を使えば、今回紹介したプライマリコンストラクタやプロパティを使うだけでも、 Java と比べてずいぶんとコードがすっきりします。今回の内容だけでも Kotlin を使う価値があると思うので、興味がわいてきたら是非試してみて下さい。

**次の投稿**: [JavaプログラマがKotlinでつまづきがちなところ](http://qiita.com/koher/items/d9411a00986f14683a3f)

[^1]: もちろん、 Kotlin を使いこなすにはそれなりの学習が必要ですが、 Java と同じように（ +α で）使うにはそれくらいの学習期間でも可能です。

[^4]: Java プログラマが Scala やるのに [scala_text](https://dwango.github.io/scala_text/) がいいと教えてもらったので紹介します。

[^2]: Java でも至るところ `final` を付けるスタイルでコーディングしている人もいるでしょうが、多くのサンプルコードでは `final` が付いていませんし、 `final` を付けていない人も多いと思うのでこのような表現にしました。