Kotlinのmax関数を徹底解説！初心者向けに使い方からエラー解決まで

kotlin.math.max とは

kotlin.math.maxは、Kotlinの標準ライブラリであるkotlin.mathパッケージに含まれる関数です。この関数は、2つの数値のうち大きい方を返します。

使い方

基本的な使い方は非常にシンプルです。2つの数値を引数として渡すだけです。

import kotlin.math.max

fun main() {
    val num1 = 10
    val num2 = 20
    val greaterNum = max(num1, num2)
    println("大きい方の数値: $greaterNum") // 出力: 大きい方の数値: 20

    val a = 5.5
    val b = 3.2
    val maxDouble = max(a, b)
    println("大きい方の数値 (Double): $maxDouble") // 出力: 大きい方の数値 (Double): 5.5
}

特徴と利点

1. 型を問わない（オーバーロードされている）: max関数は、Int、Long、Float、Doubleなど、様々な数値型に対してオーバーロード（多重定義）されています。そのため、引数に渡す数値の型を意識することなく、どの数値型でも使用できます。

   fun max(a: Int, b: Int): Int
   fun max(a: Long, b: Long): Long
   fun max(a: Float, b: Float): Float
   fun max(a: Double, b: Double): Double
   // 他にもある
   

2. importの必要性: kotlin.mathパッケージの関数を使用するには、通常はimport kotlin.math.maxのようにインポート文を記述する必要があります。しかし、Kotlinの多くのIDE（例えばIntelliJ IDEAやAndroid Studio）では、maxと入力すると自動的にインポート文を追加してくれることが多いです。

3. 簡潔なコード: もしmax関数がなければ、大きい方を判定するために以下のような条件分岐を書く必要がありました。

   val greaterNum = if (num1 > num2) num1 else num2
   

   max関数を使うことで、この記述をより簡潔に、かつ意図が明確なコードにすることができます。

• 2つの数値のみ: kotlin.math.maxは、一度に2つの数値しか比較できません。3つ以上の数値の中から最大値を見つけたい場合は、繰り返しmax関数を使うか、コレクション（リストなど）のmaxOrNull()やmaxOf()関数などを使用することを検討してください。

  // 3つの数値の最大値
  val n1 = 10
  val n2 = 5
  val n3 = 15
  val maxOfThree = max(max(n1, n2), n3) // max(10, 15) -> 15
  
  // コレクションの最大値
  val numbers = listOf(10, 5, 15, 8)
  val maxInList = numbers.maxOrNull() // 15
  

---

kotlin.math.max関数自体は非常にシンプルですが、それでも使用方法や引数の型に関する一般的な落とし穴があります。

エラー: "Unresolved reference: max" (未解決の参照: max)

これは最も一般的なエラーの一つです。Kotlinコンパイラがmax関数を見つけられないときに発生します。

• トラブルシューティング:
  1. import kotlin.math.max を追加する: コードの先頭、パッケージ宣言の下にこの行を追加します。多くのIDE（IntelliJ IDEA, Android Studioなど）では、maxと入力してTabキーを押したり、エラー箇所でAlt+Enter（Windows/Linux）/Option+Enter（macOS）を押したりすることで、自動的にインポートが追加されます。

     import kotlin.math.max // これを追加
     
     fun main() {
         val result = max(10, 20)
         println(result)
     }
     

  2. 完全に修飾された名前を使用する（推奨されないが緊急時）: import文を使いたくない場合や、一時的なデバッグ目的で、kotlin.math.maxとフルパスで記述することもできます。ただし、コードの可読性が下がるため、通常は推奨されません。

     fun main() {
         val result = kotlin.math.max(10, 20) // フルパスで指定
         println(result)
     }
     

• 原因: kotlin.math.max関数がインポートされていない、またはkotlin.mathパッケージがクラスパスに含まれていない（非常に稀ですが）。

エラー: "Type inference failed: Not enough information to infer type variable T" / "No overload found that matches the argument types" (型推論に失敗: 型変数Tを推論するための情報が不十分 / 引数の型に一致するオーバーロードが見つからない)

これは、max関数に異なる型の数値を渡した場合や、期待される数値型以外の値を渡した場合に発生することがあります。

• トラブルシューティング:
  1. 引数の型を統一する: max関数に渡す2つの数値の型を同じにします。通常は、より表現力の高い型（例: Double）に合わせるのが良いでしょう。

     val num1 = 10    // Int
     val num2 = 20.0  // Double
     
     // 誤った例: max(num1, num2) はエラーになる可能性がある
     // val result = max(num1, num2) // エラーまたは警告
     
     // 正しい例1: IntをDoubleに変換
     val result1 = max(num1.toDouble(), num2) // OK
     println(result1)
     
     // 正しい例2: 両方とも明示的に型指定 (Literalで型推論が期待通りに行かない場合)
     val result2 = max(10.0, 20.0) // OK
     println(result2)
     

  2. 適切な数値型であることを確認する: Stringやカスタムオブジェクトなどを誤って渡していないか確認してください。

     val text = "abc"
     // val result = max(10, text) // エラー: 期待される数値型ではない
     

• 原因:
  • max関数は、同じ型の2つの引数を受け取ります（例: max(Int, Int)、max(Double, Double)）。max(10, 20.0)のようにIntとDoubleを混在させると、コンパイラはどちらのオーバーロードを使用すべきか判断できません。
  • 数値型ではない（例: String）引数を渡した場合。

意図しない結果: 浮動小数点数の比較精度問題

これはエラーではありませんが、浮動小数点数（FloatやDouble）を扱う際に予期せぬ結果を招く可能性があります。

• トラブルシューティング:
  • 誤差を許容する比較: 厳密な等価性ではなく、許容範囲内の誤差で比較を行う必要がある場合は、max関数の結果を直接比較するのではなく、許容誤差（epsilon）を考慮したロジックを実装する必要があります。
  • BigDecimalを使用する: 金銭計算など、高い精度が絶対に必要な場合は、kotlin.mathパッケージではなく、java.math.BigDecimalクラスを使用することを検討してください。これは浮動小数点数の問題を回避できますが、扱いが少し複雑になります。

    import java.math.BigDecimal
    
    fun main() {
        val a = BigDecimal("0.1")
        val b = BigDecimal("0.2")
        val c = BigDecimal("0.3")
    
        // 0.1 + 0.2 は浮動小数点数では0.3と正確にはならない場合がある
        val sum = a.add(b)
    
        // BigDecimal.max() を使用
        val maxBigDecimal = sum.max(c)
        println(maxBigDecimal) // 0.3
    }
    

• 原因: 浮動小数点数は、コンピュータ内部で正確に表現できない場合があり、ごくわずかな誤差が生じることがあります。この誤差がmax関数の比較に影響を与える可能性があります。

論理的な間違い: 複数の値の最大値の取得

これはmax関数の直接的なエラーではありませんが、複数の値から最大値を取得しようとして、誤った方法でmaxを繰り返し使用してしまうことがあります。

• トラブルシューティング:
  1. maxを繰り返し使用する: 最も単純な方法は、max関数をネストして使用することです。

     val n1 = 10
     val n2 = 5
     val n3 = 15
     val maxOfThree = max(max(n1, n2), n3) // max(10, 15) -> 15
     println(maxOfThree)
     

  2. コレクション関数を使用する: より多くの数値がある場合や、数値がリストなどのコレクションに格納されている場合は、KotlinのコレクションAPIのmaxOrNull()やmaxOf()関数を使用する方が適切です。

     val numbers = listOf(10, 5, 15, 8, 22)
     val maxInList = numbers.maxOrNull() // 22 (Int? 型)
     println(maxInList)
     
     // 空のリストの場合にnullを返さない maxOf()
     val maxOfCertainValues = maxOf(10, 5, 15, 8, 22) // 22 (Int 型)
     println(maxOfCertainValues)
     

• 原因: max関数は2つの引数しか受け取らないため、3つ以上の値の最大値を直接求めることはできません。

---

kotlin.math.max の使用例

kotlin.math.maxは、2つの数値のうち大きい方を返す非常に便利な関数です。ここでは、基本的な使い方から、いくつかの応用例までを見ていきましょう。

使用する際は、通常、ファイルの先頭にimport kotlin.math.maxを記述します。

import kotlin.math.max // kotlin.math.max をインポートする

fun main() {
    // --- 1. 基本的な使い方：Int型の場合 ---
    println("--- 1. 基本的な使い方：Int型の場合 ---")
    val a = 10
    val b = 20
    val resultInt = max(a, b)
    println("$a と $b の大きい方: $resultInt") // 出力: 10 と 20 の大きい方: 20

    val c = -5
    val d = -12
    val resultIntNegative = max(c, d)
    println("$c と $d の大きい方: $resultIntNegative") // 出力: -5 と -12 の大きい方: -5

    // --- 2. 異なる数値型の場合 (オーバーロード) ---
    println("\n--- 2. 異なる数値型の場合 (オーバーロード) ---")
    val x = 3.14
    val y = 2.71
    val resultDouble = max(x, y)
    println("$x と $y の大きい方 (Double): $resultDouble") // 出力: 3.14 と 2.71 の大きい方 (Double): 3.14

    val long1 = 1234567890123L
    val long2 = 9876543210987L
    val resultLong = max(long1, long2)
    println("$long1 と $long2 の大きい方 (Long): $resultLong") // 出力: 1234567890123 と 9876543210987 の大きい方 (Long): 9876543210987

    val float1 = 15.6f
    val float2 = 15.61f
    val resultFloat = max(float1, float2)
    println("$float1 と $float2 の大きい方 (Float): $resultFloat") // 出力: 15.6 と 15.61 の大きい方 (Float): 15.61

    // --- 3. 複数の値の最大値を見つける ---
    // max() は2つの引数しか取れないため、3つ以上の場合はネストするか、コレクション関数を使う
    println("\n--- 3. 複数の値の最大値を見つける ---")
    val n1 = 50
    val n2 = 100
    val n3 = 75
    val n4 = 120

    // 方法1: max() をネストして使う
    val maxOfThree = max(max(n1, n2), n3)
    println("3つの数値 ($n1, $n2, $n3) の最大値: $maxOfThree") // 出力: 3つの数値 (50, 100, 75) の最大値: 100

    val maxOfFour = max(max(n1, n2), max(n3, n4))
    println("4つの数値 ($n1, $n2, $n3, $n4) の最大値: $maxOfFour") // 出力: 4つの数値 (50, 100, 75, 120) の最大値: 120

    // 方法2: コレクションの maxOrNull() または maxOf() を使う (推奨)
    // maxOrNull() はリストが空の場合に null を返す
    val numbers = listOf(n1, n2, n3, n4)
    val maxInList = numbers.maxOrNull()
    println("リスト $numbers の最大値 (maxOrNull): $maxInList") // 出力: リスト [50, 100, 75, 120] の最大値 (maxOrNull): 120

    val emptyList = emptyList<Int>()
    val maxInEmptyList = emptyList.maxOrNull()
    println("空のリストの最大値 (maxOrNull): $maxInEmptyList") // 出力: 空のリストの最大値 (maxOrNull): null

    // maxOf() は可変長引数を受け取り、空の場合に NoSuchElementException をスローする
    val maxOfValues = maxOf(n1, n2, n3, n4)
    println("複数の値の最大値 (maxOf): $maxOfValues") // 出力: 複数の値の最大値 (maxOf): 120

    // --- 4. 数値の範囲制限 (Coercion) ---
    // 特定の範囲に値を収めたい場合によく使われる
    println("\n--- 4. 数値の範囲制限 (Coercion) ---")
    val minAllowed = 0
    val maxAllowed = 100
    val score = 120

    // スコアが最小値より小さければ最小値を返す（score が 0 より小さければ 0、そうでなければ score）
    val normalizedScoreMin = max(score, minAllowed)
    println("$score を $minAllowed より小さくしない: $normalizedScoreMin") // 出力: 120 を 0 より小さくしない: 120

    // さらに `coerceAtMost` と組み合わせると、範囲内に収めることができる
    // val clampedScore = max(score, minAllowed).coerceAtMost(maxAllowed)
    // println("スコア $score を $minAllowed から $maxAllowed の範囲に制限: $clampedScore") // 出力: スコア 120 を 0 から 100 の範囲に制限: 100

    // または Kotlin 1.3 以降の Int.coerceIn() (推奨)
    val clampedScoreKotlin = score.coerceIn(minAllowed, maxAllowed)
    println("スコア $score を $minAllowed から $maxAllowed の範囲に制限 (coerceIn): $clampedScoreKotlin") // 出力: スコア 120 を 0 から 100 の範囲に制限 (coerceIn): 100

    val negativeScore = -5
    val clampedNegativeScore = negativeScore.coerceIn(minAllowed, maxAllowed)
    println("スコア $negativeScore を $minAllowed から $maxAllowed の範囲に制限 (coerceIn): $clampedNegativeScore") // 出力: スコア -5 を 0 から 100 の範囲に制限 (coerceIn): 0

    // --- 5. ゲームやシミュレーションでの使用例 ---
    println("\n--- 5. ゲームやシミュレーションでの使用例 ---")

    var health = 80
    val damage = 30
    val healing = 25
    val maxHealth = 100

    // ダメージ後のヘルス（最小値は0とする）
    health -= damage
    health = max(health, 0) // ヘルスが負にならないように0と比較
    println("ダメージ後のヘルス: $health") // 出力: ダメージ後のヘルス: 50

    // 回復後のヘルス（最大値はmaxHealthとする）
    health += healing
    health = kotlin.math.min(health, maxHealth) // min() を使って最大値を超えないようにする
    println("回復後のヘルス: $health") // 出力: 回復後のヘルス: 75

    // もう一度回復 (最大値を超えない例)
    health += healing // health は 75 + 25 = 100
    health = kotlin.math.min(health, maxHealth)
    println("再度回復後のヘルス (最大値制限あり): $health") // 出力: 再度回復後のヘルス (最大値制限あり): 100

    health += healing // health は 100 + 25 = 125
    health = kotlin.math.min(health, maxHealth)
    println("再度回復後のヘルス (最大値を超えないことを確認): $health") // 出力: 再度回復後のヘルス (最大値を超えないことを確認): 100

    // --- 6. ユーザー入力のバリデーション ---
    println("\n--- 6. ユーザー入力のバリデーション ---")
    val userInput = "50" // ユーザーが入力した文字列
    val defaultVal = 10

    val parsedInt = userInput.toIntOrNull() // 文字列をIntに変換。変換できない場合はnull
    val finalValue = if (parsedInt != null) max(parsedInt, defaultVal) else defaultVal
    // あるいは、デフォルト値より小さくならないようにするなら max(parsedInt ?: defaultVal, defaultVal)
    // parsedIntがnullでない場合はparsedIntとdefaultValの大きい方、nullの場合はdefaultVal

    println("ユーザー入力 '$userInput' とデフォルト値 $defaultVal の大きい方: $finalValue") // 出力: ユーザー入力 '50' とデフォルト値 10 の大きい方: 50

    val invalidInput = "abc"
    val parsedInvalidInt = invalidInput.toIntOrNull()
    val finalInvalidValue = if (parsedInvalidInt != null) max(parsedInvalidInt, defaultVal) else defaultVal
    println("無効な入力 '$invalidInput' とデフォルト値 $defaultVal の大きい方: $finalInvalidValue") // 出力: 無効な入力 'abc' とデフォルト値 10 の大きい方: 10
}

1. 基本的な使い方 (Int型): max(10, 20)のように、最もシンプルな形で使います。正の数だけでなく、負の数同士の比較も可能です。

2. 異なる数値型の場合 (オーバーロード): max関数はInt、Long、Float、Doubleなど、様々な数値型に対してオーバーロードされています。引数に渡す型によって、適切なmax関数が自動的に呼び出されます。

3. 複数の値の最大値を見つける: kotlin.math.maxは常に2つの引数しか取りません。

   • 3つ以上の値の最大値が必要な場合は、max(max(n1, n2), n3)のようにネストして呼び出すことができます。
   • しかし、よりKotlinらしい方法としては、Listなどのコレクションの拡張関数であるmaxOrNull()やmaxOf()を使用することを推奨します。これらの関数は、複数の要素の中から最大値を見つけるのに最適です。maxOrNull()は空のコレクションに対してnullを返しますが、maxOf()はNoSuchElementExceptionをスローします。

4. 数値の範囲制限 (Coercion): ある値が特定の下限値より小さくならないようにしたい場合、max(値, 下限値)という形で使えます。これにより、値が下限値を下回ることを防ぎます。 より厳密に上下限を設定したい場合は、Kotlinの拡張関数であるcoerceIn(minimumValue, maximumValue)が非常に便利で、推奨される方法です。

5. ゲームやシミュレーションでの使用例: ゲームのヘルスポイント（HP）のように、値が0より小さくならないようにする（例えばhealth = max(health, 0)）といった状況で役立ちます。また、HPが最大値を超えることを防ぐためにkotlin.math.minと組み合わせて使用する例も示しています。

6. ユーザー入力のバリデーション: ユーザーからの入力値が期待される最小値を下回らないようにする際にも利用できます。例えば、数値としてパースできなかったり、デフォルト値よりも小さい場合に、デフォルト値を保証するといった使い方です。

---

kotlin.math.maxは2つの数値の比較に特化していますが、より汎用的なケースや特定の意図を強調したい場合に他の方法が有効です。

if-else 文 / 三項演算子に相当するもの

最も基本的な代替手段は、条件分岐を使って手動で大きい方を判断する方法です。KotlinにはJavaのような三項演算子はありませんが、ifが式なので同様の表現が可能です。

• 欠点: 記述が冗長になりがち。
• 利点: 外部ライブラリや特定のインポートが不要。
• 用途: 非常にシンプルで、max関数をインポートしたくない場合や、ごく基本的な比較を行う場合。

例

fun main() {
    val num1 = 10
    val num2 = 20

    // if-else 式を使った代替
    val greaterNum = if (num1 > num2) num1 else num2
    println("if-elseを使った大きい方: $greaterNum") // 出力: if-elseを使った大きい方: 20

    val x = 3.14
    val y = 2.71
    val greaterDouble = if (x > y) x else y
    println("if-elseを使った大きい方 (Double): $greaterDouble") // 出力: if-elseを使った大きい方 (Double): 3.14
}

コレクションの拡張関数: maxOf() / maxOrNull()

3つ以上の数値や、リストなどのコレクション内の最大値を取得したい場合に最も推奨される方法です。

• 欠点: 2つの数値の比較だけならkotlin.math.maxの方が意図が明確な場合もある。
• 利点:
  • 複数の値を直接比較できる（maxOf）。
  • コレクション内の最大値を簡潔に取得できる。
  • 空のコレクションの場合の挙動を選べる（maxOrNullはnullを返し、maxOfはNoSuchElementExceptionをスロー）。
• 用途: 複数の数値（可変長引数）や、リスト、セット、配列などのコレクション内の最大値を見つける場合。

例

fun main() {
    // maxOf() を使って複数のIntの最大値
    val n1 = 50
    val n2 = 100
    val n3 = 75
    val n4 = 120
    val maxOfMultiple = maxOf(n1, n2, n3, n4)
    println("maxOf()を使った複数の値の最大値: $maxOfMultiple") // 出力: maxOf()を使った複数の値の最大値: 120

    // リストの最大値 (maxOrNull)
    val numbers = listOf(10, 5, 15, 8, 22)
    val maxInList = numbers.maxOrNull()
    println("リストの最大値 (maxOrNull): $maxInList") // 出力: リストの最大値 (maxOrNull): 22

    val emptyList = emptyList<Int>()
    val maxInEmptyList = emptyList.maxOrNull()
    println("空のリストの最大値 (maxOrNull): $maxInEmptyList") // 出力: 空のリストの最大値 (maxOrNull): null

    // maxOf() と maxByOrNull() / maxWithOrNull() の違い
    data class Person(val name: String, val age: Int)
    val people = listOf(Person("Alice", 30), Person("Bob", 25), Person("Charlie", 35))

    // maxOf() は比較可能な型ならそのまま使える
    val oldestPersonByAge = people.maxOfOrNull { it.age }
    println("最も高齢な人の年齢 (maxOfOrNull): $oldestPersonByAge") // 出力: 最も高齢な人の年齢 (maxOfOrNull): 35

    // maxByOrNull() は比較するプロパティを指定して要素そのものを返す
    val oldestPersonObject = people.maxByOrNull { it.age }
    println("最も高齢な人 (maxByOrNull): $oldestPersonObject") // 出力: 最も高齢な人 (maxByOrNull): Person(name=Charlie, age=35)

    // maxWithOrNull() はカスタムComparatorを使って要素そのものを返す
    val peopleSortedByNameLength = people.maxWithOrNull(Comparator { p1, p2 -> p1.name.length.compareTo(p2.name.length) })
    println("名前の長さが最も長い人 (maxWithOrNull): $peopleSortedByNameByNameLength") // 出力: 名前の長さが最も長い人 (maxWithOrNull): Person(name=Charlie, age=35)
}

coerceAtLeast() 拡張関数

特定の値を「最低でもこれ以上」にしたいという意図がある場合に非常に適しています。これはkotlin.math.maxの特定のユースケース（下限値の制限）をより意味的に表現できます。

• 欠点: 2つの値を単純に比較して大きい方を返す、という汎用的な目的には向かない。
• 利点: コードの意図がmaxを使うよりも明確になる（「この値は少なくともXであるべき」）。
• 用途: 値が特定の下限値より小さくならないように強制する場合。

例

fun main() {
    val score = 85
    val minScore = 50

    // スコアが最低でも minScore であることを保証
    val clampedScore = score.coerceAtLeast(minScore)
    println("スコア $score は最低 $minScore でなければならない: $clampedScore") // 出力: スコア 85 は最低 50 でなければならない: 85

    val lowScore = 30
    val clampedLowScore = lowScore.coerceAtLeast(minScore)
    println("スコア $lowScore は最低 $minScore でなければならない: $clampedLowScore") // 出力: スコア 30 は最低 50 でなければならない: 50

    // 上限も設定したい場合は coerceIn() を使う
    val maxScore = 100
    val finalScore = score.coerceIn(minScore, maxScore)
    println("スコア $score を $minScore から $maxScore の範囲に制限: $finalScore") // 出力: スコア 85 を 50 から 100 の範囲に制限: 85

    val veryHighScore = 120
    val finalVeryHighScore = veryHighScore.coerceIn(minScore, maxScore)
    println("スコア $veryHighScore を $minScore から $maxScore の範囲に制限: $finalVeryHighScore") // 出力: スコア 120 を 50 から 100 の範囲に制限: 100
}

Comparable インターフェースとカスタム比較

Kotlinの数値型はすべてComparableインターフェースを実装しており、それによって>や<といった比較演算子を使用できます。また、カスタムオブジェクトの最大値を比較する際には、このComparableまたはComparatorを利用します。

• 欠点: 比較ロジックを自分で書く必要がある。
• 利点: 柔軟性が高く、あらゆるオブジェクトの比較ロジックを定義できる。
• 用途: 自作のクラスや複雑なオブジェクト間で「最大」を定義し、比較する場合。

// Comparable を実装したカスタムクラス
data class Product(val name: String, val price: Double) : Comparable<Product> {
    // 価格に基づいて比較する
    override fun compareTo(other: Product): Int {
        return this.price.compareTo(other.price)
    }
}

fun main() {
    val productA = Product("Laptop", 1200.0)
    val productB = Product("Keyboard", 150.0)
    val productC = Product("Monitor", 300.0)

    // Comparable を使って2つのProductを比較
    // maxOf は Comparable を受け取るオーバーロードがある
    val mostExpensiveProduct = maxOf(productA, productB)
    println("最も高価な製品 (maxOf with Comparable): $mostExpensiveProduct") // 出力: 最も高価な製品 (maxOf with Comparable): Product(name=Laptop, price=1200.0)

    // リスト内の最も高価な製品 (maxOrNull と Comparable)
    val products = listOf(productA, productB, productC)
    val mostExpensiveInList = products.maxOrNull() // Product が Comparable を実装しているのでそのまま使える
    println("リスト内で最も高価な製品 (maxOrNull): $mostExpensiveInList") // 出力: リスト内で最も高価な製品 (maxOrNull): Product(name=Laptop, price=1200.0)

    // Comparator を使って、異なる基準で比較する例 (ここでは名前の長さ)
    val productWithLongestName = products.maxWithOrNull(Comparator { p1, p2 ->
        p1.name.length.compareTo(p2.name.length)
    })
    println("名前が最も長い製品 (maxWithOrNull): $productWithLongestName") // 出力: 名前が最も長い製品 (maxWithOrNull): Product(name=Keyboard, price=150.0)
}

• 下限値の強制: coerceAtLeast() を使うと、コードの意図がより明確になります。
• コレクション内の最大値: maxOrNull() や maxOf()、あるいは特定のプロパティで比較する maxByOrNull() やカスタムの比較ロジックを使う maxWithOrNull() が適しています。
• 複数の数値の比較: maxOf()（可変長引数）が推奨されます。
• 2つの数値の単純な比較: kotlin.math.max が最も簡潔で意図が明確です。