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

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

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

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

スポンサーリンク
  1. 表記のルール
  2. Map / MutableMapの初期化
  3. Map型のプロパティ
  4. Map型のメソッド
    1. ラムダ式を取り、要素がマッチするか調べる: all/any
    2. SetやSequenceへキャストする: as系
    3. KeyやValueを取り、Booleanを返す : contains系
    4. 要素数を返す: count
    5. 同値性を調べる: equals
    6. ラムダ式を取り、Mapを返す: filter系
    7. ラムダ式を取り、入れ子を展開してListを返す: flatMap系
    8. ラムダ式を取り、戻り値が無い: forEach
    9. Keyを取り、Valueを返す: get系
    10. ハッシュコードを返す: hashCode
    11. 要素の有無を調べ、Anyを返す: ifEmpty
    12. 要素の有無やnullを調べ、Booleanを返す: isEmpty系
    13. イテレータを返す: iterator
    14. ラムダ式を取り、MapやCollection/Listを返す: map系
    15. 要素の大小を比較し、要素を返す: max/min系
    16. Keyを取り、それを除いたMapを返す: minus
    17. 要素が無ければtrue: none
    18. ラムダ式を取り、元のMapを返す: onEach
    19. nullチェックにより、元のMapか空のMapを返す: orEmpty
    20. Pairを取り、それを追加したMapを返す: plus
    21. 他の型に変換する: to系
    22. getValueで例外を出さないための準備: withDefault
  5. MutableMap型のメソッド
    1. 要素を全て削除する: clear
    2. Keyとラムダ式を取り、ValueかMapを返す: getOrPut
    3. 要素を追加/削除する: plus/minusAssign
    4. 要素を追加/置き換える: put系
    5. 要素を削除し、削除したValueを返す: remove
    6. Valueを置き換える: replace系
    7. KeyとValueを取り、それを加えるor置き換える: set

表記のルール

メソッド名欄の表記と引数について
メソッド名のみ => 引数無し
メソッド名() => 引数を取る
メソッド名{…} => ラムダ式を取る

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

KVMCR
KeyValueMutableMapCollectionReturn(ラムダ式の結果)

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、...

Map型のプロパティ

プロパティ名戻り値意味
entriesSetMapの要素全体
keysSetMapのkey
sizeIntMapの要素数
valuesCollectionMapのvalue
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

メソッド名戻り値機能
all{…}Booleanラムダ式に全ての要素がマッチすればtrueを返す
any{…}Booleanラムダ式にどれかの要素がマッチすればtrueを返す
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系

メソッド名戻り値機能
asIterableSetイテラブルオブジェクトを生成
asSequenceSequenceシーケンスオブジェクトを生成
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系

メソッド名戻り値機能
contains(K)BooleanKがMapのkeyに含まれているかどうか
in演算子のオーバーロード
containsKey(K)Boolean働きはcontainsと同じ。実装上の違い
containsValue(V)BooleanVがMapのvalueに含まれてるかどうか
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種類有り。引数無しかラムダ式を取るかで変化します。

メソッド名戻り値機能
countIntsizeプロパティと同じ
count{…}Intラムダ式を取り、マッチした要素数を出力
val map = mapOf(0 to "Kotlin", 1 to "Java", 2 to "Python")

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

同値性を調べる: equals

メソッド名戻り値機能
equals(other)Boolean引数otherとの同値性を調べる
==演算子のオーバーロード
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)を返します。
filterTofilterNotToは引数にM(MutableMap)とラムダ式を取る点に注意。

メソッド名戻り値機能
filter{…}Mapラムダ式にマッチした要素を新たなMapに入れて出力
ラムダ式内は「it」で呼び出し元のMapを参照
filterKeys{…}Map機能はfilterと同じ。ラムダ式内の「it」はMapのkey
filterNot{…}Mapfilterの逆。ラムダ式にマッチしない要素のみを抽出
filterNotTo(M){…}MutableMapfilterNotの結果を別のMutableMapであるMに加える
filterTo(M){…}MutableMapfilterの結果を別のMutableMapであるMに加える
filterValues{…}Map機能はfilterと同じ。ラムダ式内の「it」はMapのvalue
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種類。ラムダ式の結果を最終的にどこに入れるかが異なります。

メソッド名戻り値機能
flatMap{…}List<R>各要素に対してラムダ式を実行し、
その結果Iterable<R>をまとめて1つのListとして返す
flatMapTo(C){…}Cラムダ式の結果をCに加えてCを返す
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では、戻り値無しのメソッドはこれだけ。

メソッド名戻り値機能
forEach{…}Unit呼び出し元の要素それぞれにラムダ式の処理を行う
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が無かったときの挙動。

メソッド名戻り値機能
get(K)V?mapのkeyを引数に取り、Valueを返す。
valueが無ければnullを返す
map[キー]のオーバーロード
getOrDefault(K, default: V)VValueが無ければ設定されたデフォルト値を返す
getOrElse(K){…}VValueが無ければラムダ式の結果を返す
getValue(K)VValueが無ければ例外を送出
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

メソッド名戻り値機能
hashCodeInt呼び出し元のハッシュコードを出力
val map = mapOf(0 to "Kotlin", 1 to "Java", 2 to "Python")
map.hashCode()    //366231650

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

メソッド名戻り値機能
ifEmpty{…}Any呼び出し元が空であればラムダ式の結果を返す
戻り値がAny型であることに注意
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系

メソッド名戻り値機能
isEmptyBoolean呼び出し元に要素が無ければtrue
isNotEmptyBoolean呼び出し元に要素があればtrue
isNullOrEmptyBoolean呼び出し元がnullか空であればtrue
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

メソッド名戻り値機能
iteratorIterator呼び出し元のイテレータを返す
for((k, v) in map){...}
for(i in map){...}
//for文などの裏側で使用され、mapをループ処理可能にする

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

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

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

メソッド名戻り値機能
map{…}List<R>各要素に対してラムダ式を実行し、
その結果Rをまとめて新たなListとして返す
mapKeys{…}Map<R, V>結果Rを呼び出し元のkeyとしてMapを返す
keyの型が変わる場合、書き換えは不可
mapKeysTo(M){…}M<R, V>結果RをMのkey、
呼び出し元のvalueをMのvalueとして追加し、Mを返す
mapNotNull{…}List<R>ラムダの結果R?からnullを除いてListを返す
mapNotNullTo(C){…}C結果R?からnullを除いてCを返す
mapTo(C){…}C結果RをCの要素として加え、Cを返す
mapValues{…}Map<K, R>結果Rを呼び出し元のvalueとして返す
mapValuesTo(M){…}M<K, R>結果RをMのvalue、
呼び出し元のkeyをMのkeyとして追加し、Mを返す
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系

メソッド名戻り値機能
maxBy{…}Entry<K, V>?呼び出し元の各要素をラムダ式に通し、
その結果が最も大きい要素を出力
要素が無ければnullを返す
maxWith(Comparator)Entry<K, V>?引数にComparatorオブジェクトを取る。
それによって各要素を比較し、最も結果が大きい要素を出力
要素が無ければnullを返す
minBy{…}Entry<K, V>?呼び出し元の各要素をラムダ式に通し、
その結果が最も小さい要素を出力
要素が無ければnullを返す
minWith(Comparator)Entry<K, V>?引数にComparatorオブジェクトを取る。
それによって各要素を比較し、最も結果が小さい要素を出力
要素が無ければnullを返す
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

メソッド名戻り値機能
minus(K)Map引数に呼び出し元のkeyを取り、その要素を除いたMapを返す
「Map – key」のオーバーロード
引数はイテラブルオブジェクトでも可
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

メソッド名戻り値機能
noneBoolean呼び出し元に要素が無ければtrueを返す
val map: Map<Int, Int> = mapOf()
println(map.none())   //true

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

メソッド名戻り値機能
onEach{…}Mapラムダ式を実行し、元のMapを返す
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

メソッド名戻り値機能
orEmptyMap呼び出し元がnullでなければそのまま返し、
nullであれば空のMapを返す
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

メソッド名戻り値機能
plus(Pair<K, V>)
plus(Iterable<K, V>)
Map引数にPairやPairを含むイテラブルを取り、
呼び出し元に追加/置き換える
「Map + Pair」のオーバーロード
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系

メソッド名戻り値機能
toListList<Pair<K, V>>key/valueペアを要素とするListに変換
toMapMap読み取り専用Mapに変換
toMutableMapMutableMapMutableMapに変換
toPropertiesjava.util.PropertiesPropertiesに変換
toSortedMap
toSortedMap(comparator)
SortedMapSortedMapに変換
toStringString文字列に変換
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

メソッド名戻り値機能
withDefault{…}MapgetValueが例外を返す時、代わりにデフォルト値が返される
//あらかじめ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

メソッド名戻り値機能
clearUnitMutableMapから全ての要素を削除して書き換える
val map = mutableMapOf(0 to "Kotlin", 1 to "Java")

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

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

メソッド名戻り値機能
getOrPut(K){…}V / R引数Kが呼び出し元にあれば、そのvalueを出力
無ければラムダ式の結果を出力し、引数をKeyとして呼び出し元に加える
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

メソッド名戻り値機能
minusAssign(K / Keys)Unitkeyかkeyのイテラブルを受け取り、その要素を削除する
-=演算子のオーバーロード
plusAssign(Pair)UnitPairかPairのイテラブルを受け取り、その要素を追加する
既存のkeyがある場合は入れ替える
+=演算子のオーバーロード
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系

メソッド名戻り値機能
put(K, V)V?K, VをMutableMapに追加 or 置き換え
putAll(Pairs)Unit引数のPairsを全て呼び出し元に追加 or 置き換え
putIfAbsent(K, V)V?指定したkeyが呼び出し元に無ければ追加
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

メソッド名戻り値機能
remove(K)
remove(K, V)
V?
Boolean
指定した要素を削除し、削除した値が戻り値となる
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系

メソッド名戻り値機能
replace(K, V)
replace(K, oldV, newV)
V?指定したkeyのvalueをVに置き換える
replaceAll{K, V->R}Unit全てのvalueをラムダ式の結果と入れ替える
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

メソッド名戻り値機能
set(K, V)Unit引数を呼び出し元に加える or 置き換える
MutableMap[Key] = Valueのオーバーロード
val map = mutableMapOf(0 to "Kotlin", 1 to "Java")

//putとは違い、戻り値はUnit。
map.set(2, "Python")
println(map)   //{0=Kotlin, 1=Java, 2=Python}
タイトルとURLをコピーしました