[Kotlin]Map型プロパティとメソッド68種のまとめ

KotlinのMap型で定義されているプロパティ/メソッドは合わせて52。これに基底クラス「Any」のメソッドやスコープ関数、MutableMapからのみ呼び出せるメソッドなどを合わせると、その数は70を超えます。

このページではその中から、スコープ関数や一部の特殊なメソッドを除いた「Map/MutableMapから呼び出し可能なプロパティとメソッド」68種を一覧として掲載しています。

ご利用の際には目次クリックでジャンプするか、Ctrl+F(Win)やCommand+F(Mac)でのページ内検索がおすすめ。

表記のルール

アルファベット1文字の表記は基本的に以下を表します。

Map / MutableMapの初期化

//基本形。要素の型が推測できるなら型指定は不要。mutableMapも同様
val map = mapOf(0 to "Kotlin", 1 to "Java")
val mutableMap = mutableMapOf(0 to "Kotlin", 1 to "Java")

//中身はPair型。結果は上の変数mapと等価
val map = mapOf(Pair(0, "Kotlin"), Pair(1, "Java"))

//要素が空のMapは型パラメータによる明示的な型指定が必要。以下2つは等価
val map: Map<Int, String> = mapOf()
val map = mapOf<Int, String>()

//値nullのMap型は型パラメータの後ろに「?」を置き、null許容型とする
val noEntry: Map<Int, String>? = null

Kotlin 1.3.70以降ではビルダー関数を使った初期化も可能。

[Kotlin]ビルダー関数によるコレクション生成/そのハマりポイント

Kotlin1.3.70から追加された新しい機能の一部としてbuildList、...

pouhon.net

Map型のプロパティ

val map = mapOf(0 to "Kotlin", 1 to "Java", 2 to "Python")

map.entries //[0=Kotlin, 1=Java, 2=Python]
map.keys  //[0, 1, 2]
map.size  //3
map.values  //[Kotlin, Java, Python]

//keysは重複が無いためSet、valuesはCollection
map.keys is Set    //true
map.values is Set  //false

Map型のメソッド

以下はMap型から呼び出せるメソッド一覧です。表の下に使用例を掲載していますので、そちらも参照してみてください。

ラムダ式を取り、要素がマッチするか調べる: all/any

val map = mapOf(0 to "Kotlin", 1 to "Java", 2 to "Python")

map.all{it.value is String}   //true
map.all{it.value.contains("o")}   //false
map.any{it.value.contains("o")}   //true

SetやSequenceへキャストする: as系

val map = mapOf(0 to "Kotlin", 1 to "Java", 2 to "Python")

//asIterable
val itr = map.asIterable()
itr is Set   //true
itr is Map<*,*>   //false

//asSequence
val seq = map.asSequence()
seq is Set<*>   //false
seq is Collection<*>   //false

KeyやValueを取り、Booleanを返す : contains系

val map = mapOf(0 to "Kotlin", 1 to "Java", 2 to "Python")

map.contains("Python")   //Error Valueでは不可

//以下3行は等価
map.contains(1)   //true
1 in map  //true
map.containsKey(1)   //true

map.containsValue("Python")   //true

要素数を返す: count

countメソッドは機能が2種類有り。引数無しかラムダ式を取るかで変化します。

val map = mapOf(0 to "Kotlin", 1 to "Java", 2 to "Python")

map.count()   //3
map.count{it.value.count() >= 5}   //2

同値性を調べる: equals

val map = mapOf(0 to "Kotlin", 1 to "Java")
val map2 = mapOf(1 to "Java", 0 to "Kotlin")

//同値性判定。Mapは要素が同じであれば、その順番は問わない
map.equals(map2)   //true
map == map2   //true

map === map2   //false  ===は同一性を調べる

ラムダ式を取り、Mapを返す: filter系

filter系は全てラムダ式を取り、Map(もしくはMutableMap)を返します。
filterTo、filterNotToは引数にM(MutableMap)とラムダ式を取る点に注意。

val map = mapOf(0 to "Kotlin", 1 to "Java", 2 to "Python")

map.filter {it.key >= 1 && it.value != "Python"}   //{1=Java}
map.filterKeys {it > 1 }  //{2=Python}
map.filterNot {it.key >= 1 && it.value != "Python"} //{0=Kotlin, 2=Python}

val map = mapOf(0 to "Kotlin", 1 to "Java", 2 to "Python")
val map2 = mutableMapOf(4 to "PHP")

//filterToやfilterNotToは引数2つ
map.filterNotTo(map2) { it.key >= 1 && it.value != "Python"}
println(map2)   //{4=PHP, 0=Kotlin, 2=Python}

ラムダ式を取り、入れ子を展開してListを返す: flatMap系

入れ子の状態を展開するflatMap系は2種類。ラムダ式の結果を最終的にどこに入れるかが異なります。

val nestedMap = mapOf(listOf(1,2) to listOf(3,4),
                      listOf(5,6) to listOf(7,8))

nestedMap.flatMap {it.key + it.value}
//[1, 2] + [3, 4]、[5, 6] + [7, 8]が行われ、Listが2つ作られる
//それらを1つのListにまとめる [1, 2, 3, 4, 5, 6, 7, 8]

nestedMap.flatMap { it } //Error。ラムダ式の結果はイテラブルでなければならない

//flatMapTo
val nestedMap = mapOf(listOf(1,2) to listOf(3,4),
                      listOf(5,6) to listOf(7,8))
val lst = mutableListOf(0,1)

nestedMap.flatMapTo(lst){ it.key }  //[0, 1, 1, 2, 5, 6]

ラムダ式を取り、戻り値が無い: forEach

メジャーなforEach。もちろんMapでも使えます。MutableではないMapでは、戻り値無しのメソッドはこれだけ。

val map = mapOf(0 to "Kotlin", 1 to "Java", 2 to "Python")

map.forEach {
    if (it.value != "Java") {
        println("${it.value}かわいい")
        }else{
            println("${it.value}${it.key}番めんどい")
    }
}
//Kotlinかわいい
//Java1番めんどい
//Pythonかわいい

Keyを取り、Valueを返す: get系

4種類ありますが、違いはValueが無かったときの挙動。

val map = mapOf(0 to "Kotlin", 1 to "Java", 2 to "Python")

map.get(2)   //Python
map[5]   //null

map.getOrDefault(5,"デフォルト")   //デフォルト
map.getOrElse(5){map[0]}   //Kotlin
map.getValue(5)   //NoSuchElementException

ハッシュコードを返す: hashCode

val map = mapOf(0 to "Kotlin", 1 to "Java", 2 to "Python")
map.hashCode()    //366231650

要素の有無を調べ、Anyを返す: ifEmpty

val emptyMap: Map<Int, String> = mapOf()   //空のMap
val nullMap: Map<Int?, String?> = mapOf(null to null) //要素がnullのMap

val ans1 = emptyMap.ifEmpty {"無いよ"}
println(ans1)   //無いよ

//戻り値はAny型。この処理は不可
println(ans1 + "無いわ")

//呼び出し元が空でなければそのまま返す
val ans2 = nullMap.ifEmpty {"無いよ"}
println(ans2)   //{null=null}

要素の有無やnullを調べ、Booleanを返す: isEmpty系

val emptyMap: Map<Int, String> = mapOf()   //空のMap
val nullMap: Map<Int?, String?> = mapOf(null to null) //要素がnullのMap
val noEntry: Map<Int, String>? = null   //null

//isEmptyは要素があるかどうか。Notは真逆の結果
emptyMap.isEmpty()  //true
nullMap.isEmpty()   //false

//nullはそもそもMapですらない
noEntry?.isEmpty()   //null

//isNullOrEmptyは要素が空か、値自体がnullか
emptyMap.isNullOrEmpty()   //true
nullMap.isNullOrEmpty()    //false
noEntry.isNullOrEmpty()    //true

イテレータを返す: iterator

for((k, v) in map){...}
for(i in map){...}
//for文などの裏側で使用され、mapをループ処理可能にする

ラムダ式を取り、MapやCollection/Listを返す: map系

Toが無ければ戻り値は読み込み専用。

ToがあればMutableな型を引数に取り、戻り値はラムダ式の結果が追加されたMutableになります。

val map1 = mapOf<Int?, String?>(null to null, 1 to "ナル", 2 to "ヌル")
val mapM = mutableMapOf<Any?, String?>("1" to null)
val listM = mutableListOf<String?>()

//mapメソッドはListを返す
map1.map{it.value}   //[null, ナル, ヌル]
listM = map.map{it.value}   //Error   戻り値はMutableListではない

//mapKeysは元のMapのkeyを変更して、新たなMapを返す
map1.mapKeys{it.value}   //{null=null, ナル=ナル, ヌル=ヌル}

//Toが付くとmutableMapに要素を追加して返す
map1.mapKeysTo(mapM){it.value}
println(mapM)   //{1=null, null=null, ナル=ナル, ヌル=ヌル}

map1.mapNotNull{it.value}   //[ナル, ヌル]

map1.mapNotNullTo(listM){it.value}
println(listM)  //[ナル, ヌル]

map1.mapTo(listM){it.value}
println(listM)   //[null, ナル, ヌル]

map1.mapValues{it.key}   //{null=null, 1=1, 2=2}

map1.mapValuesTo(mapM){it.key.toString()+it.value}
println(mapM)   //{1=null, 2=2ヌル, null=nullnull, 1=1ナル}

要素の大小を比較し、要素を返す: max/min系

val map = mapOf(-5 to "apple", 0 to "google", 2 to "amazon")

//maxBy
map.maxBy {it.key * -2}    //-5=apple
//戻り値はnull許容型
println(ans?.key)    //-5

//maxWith
//①変数compは、Mapの要素2つをa,bとして取り、それらのkeyの値で大小比較する
val comp = Comparator<Map.Entry<Int, String>> {a, b -> a.key.compareTo(b.key)}

//②maxWithは呼び出し元の要素を順次Comparatorに送り、その結果で最も大きな要素を出力する
map.maxWith(comp)   //2=amazon

Keyを取り、それを除いたMapを返す: minus

val map = mapOf(-5 to "apple", 0 to "google", 2 to "amazon")

map.minus(0)   //{-5=apple, 2=amazon}
map - -5     //{0=google, 2=amazon}
map.minus(listOf(0,2))   //{-5=apple}

要素が無ければtrue: none

val map: Map<Int, Int> = mapOf()
println(map.none())   //true

ラムダ式を取り、元のMapを返す: onEach

val map = mapOf(-5 to "apple", 0 to "google", 2 to "amazon")

//戻り値は呼び出し元そのままのため、メソッドチェーンするのに便利
val ans = map.onEach {print(it.value+" ")}  //各要素がprintされる
        .filter {it.key >= 0}    //要素をフィルタリング
        .flatMap {listOf(it.key*3)}  //残ったキーを×3してリストに
println(ans)   //この場合最終的な戻り値はList

//apple google amazon [0, 6]

nullチェックにより、元のMapか空のMapを返す: orEmpty

val map = mapOf(-5 to "apple", 0 to "google", 2 to "amazon")
val mapNull: Map<Int?, String>? = null

println(map.orEmpty())   //{-5=apple, 0=google, 2=amazon}
println(mapNull.orEmpty())   //{}

Pairを取り、それを追加したMapを返す: plus

val map = mapOf(-5 to "apple", 0 to "google", 2 to "amazon")

//以下2行は等価
map.plus(listOf(1 to "楽天", 3 to "LINE"))
map + listOf(1 to "楽天", 3 to "LINE")

//{-5=apple, 0=google, 2=amazon, 1=楽天, 3=LINE}

他の型に変換する: to系

val map = mapOf("3" to "Unity", "1" to "Go", "2" to "C#", "0" to "C++")

map.toList()   //[(3, Unity), (1, Go), (2, C#), (0, C++)]

//toPropertiesは、呼び出し元のkeyがStringであることが条件。Charも×
val properties = map.toProperties()
println(properties.javaClass)   //class java.util.Properties

//toSortedMap keyでMapをソートする
val sortedMap = map.toSortedMap()
println(sortedMap)   //{0=C++, 1=Go, 2=C#, 3=Unity}

//toSortedMapの引数にComparatorを渡す
val sortedMap = map.toSortedMap(Comparator{a,b -> a.compareTo(b)})
println(sortedMap)   //{0=C++, 1=Go, 2=C#, 3=Unity}

getValueで例外を出さないための準備: withDefault

//あらかじめMapのデフォルト値を決めておく
val map = mapOf("3" to "Unity",
                "1" to "Go",
                "2" to "C#",
                "0" to "C++"
               ).withDefault { "無いよ" }

//設定していない場合、getValueで指定したキーが無ければ例外が送出される
println(map.getValue["9"])
//java.util.NoSuchElementException: Key 9 is missing in the map.

//設定していればそのデフォルト値が返される
println(map.getValue["9"])
//無いよ

MutableMap型のメソッド

以下はMutableMapからのみ呼び出し可能なメソッド。数は11種類とそれほど多くありません。

要素を全て削除する: clear

val map = mutableMapOf(0 to "Kotlin", 1 to "Java")

map.clear()
println(map)   //{}

Keyとラムダ式を取り、ValueかMapを返す: getOrPut

val map = mutableMapOf(0 to "Kotlin", 1 to "Java")

map.getOrPut(0){"プログラミング言語"}   //Kotlin

//指定keyが無ければラムダ式の結果を出力
map.getOrPut(2){"プログラミング言語"}   //プログラミング言語

//さらに引数をKey、ラムダ式の結果をValueとして呼び出し元に加える
println(map)   //{0=Kotlin, 1=Java, 2=プログラミング言語}

要素を追加/削除する: plus/minusAssign

val map = mutableMapOf(0 to "Kotlin", 1 to "Java")

//minusAssign
map.minusAssign(0)
//以下も等価
map -= 0
println(map)     //{1=Java}

//複数項目を削除
map.minusAssign(listOf(0, 1))
println(map)    //{}

//plusAssign
map.plusAssign(2 to "PHP")
println(map)    //{0=Kotlin, 1=Java, 2=PHP}

//複数項目を追加するならListなどで渡す
map.plusAssign(listOf(0 to "PHP", 2 to "Python"))
//以下も等価
map += listOf(0 to "PHP", 2 to "Python")

println(map)   //{0=PHP, 1=Java, 2=Python}

要素を追加/置き換える: put系

val map = mutableMapOf(0 to "Kotlin", 1 to "Java")
val map2 = mapOf(0 to "PHP", 2 to "Ruby")

//putは引数が2つ、戻り値はnull許容型
val a: String? = map.put(1, "Swift")

//入れ替えた時、戻り値は入れ替え前のvalue
println(a)   //Java
println(map)   //{0=Kotlin, 1=Swift}

//putAllの引数は1つのPairか、Pairを含んだイテラブル
map.putAll(listOf(Pair(1, "JavaScript")))
println(map)     //{0=Kotlin, 1=JavaScript}

map.putAll(map2)
println(map)     //{0=PHP, 1=JavaScript, 2=Ruby}

//putIfAbsentの戻り値はnull許容型。追加できればnull
val a: String? = map.putIfAbsent(2, "Swift")
println(a)   //null
println(map)   //{0=Kotlin, 1=Java, 2=Swift}

//追加できなければ該当場所のvalueが戻り値
val a: String? = map.putIfAbsent(0, "Swift")
println(a)   //Kotlin
println(map)   //{0=Kotlin, 1=Java}

要素を削除し、削除したValueを返す: remove

val map = mutableMapOf(0 to "Kotlin", 1 to "Java")

//引数がkey1つの場合:
//削除したvalueが戻り値
val a = map.remove(1)   //Java
println(map)  //{0=Kotlin}

//削除できなければ戻り値はnull
val a = map.remove(5)   //null

//引数がkey,value2つの場合:
//削除できれば戻り値はtrue、できなければfalse
val a = map.remove(0,"Kotlin")   //true

Valueを置き換える: replace系

val map = mutableMapOf(0 to "Kotlin", 1 to "Java")

//replaceもremoveと同様、引数の数によって戻り値が変化
//引数2つの場合、戻り値は入れ替えられたvalue
val a = map.replace(0, "PHP")   //Kotlin

//3つの場合はtrue/false
val a = map.replace(0, "Kotlin", "PHP")   //true
println(map)   //{0=PHP, 1=Java}

//replaceAll
map.replaceAll{k,v->"${v}lang"}
println(map)   //{0=Kotlinlang, 1=Javalang}

KeyとValueを取り、それを加えるor置き換える: set

val map = mutableMapOf(0 to "Kotlin", 1 to "Java")

//putとは違い、戻り値はUnit。
map.set(2, "Python")
println(map)   //{0=Kotlin, 1=Java, 2=Python}