Android getOrDefault 兼容：5 种解决低版本 API 问题的方法

2025-04-24 11:22:38

告别 getOrDefault 烦恼：Android 低版本 API 兼容方案

写 Android 应用时，我们经常和 Map 打交道。一个常见的场景是计算某个元素出现的次数，比如下面这段代码：

for (Set<I> itemset : candidateList2) {
    // 如果 itemset 不存在，则默认为 0，然后加 1；存在则获取值再加 1
    supportCountMap.put(itemset, supportCountMap.getOrDefault(itemset, 0) + 1);
}

代码逻辑很清晰：遍历 candidateList2，然后更新 supportCountMap 中每个 itemset 对应的计数值。getOrDefault(key, defaultValue) 方法在这里简直是神器——它尝试获取 key 对应的 value，如果 key 不存在，就返回指定的 defaultValue（这里是 0）。这避免了我们手动检查 key 是否存在再进行操作的麻烦。

但是，如果在 minSdk 设置为低于 24 的项目中使用 getOrDefault，Android Studio 或者编译过程会立刻给你泼冷水，提示 "Call requires API level 24 (current min is 16)" 这样的错误。这意味着你的应用无法在 Android 7.0 (Nougat) 以下的设备（比如 Android 6.0 Marshmallow 或 5.0 Lollipop）上正常运行，或者说，连编译都可能通不过。

这确实有点恼人，但别担心，解决这个问题的方法有不少。

刨根问底：为什么 getOrDefault 会报错？

答案很简单：Map.getOrDefault(Object key, V defaultValue) 这个方法是 Java 8 标准库的一部分。Android 直到 API Level 24 (Android 7.0 Nougat) 才完全支持 Java 8 的 API。

当你的 minSdk 设置为比如 16 时，你告诉了 Android 构建系统，你的应用需要能够在 API 16 及以上的设备上运行。在这些低于 API 24 的设备上，它们的 Java 运行时环境并不包含 Java 8 引入的 getOrDefault 方法。强行调用一个不存在的方法，自然会导致 NoSuchMethodError 这样的运行时崩溃。编译时的警告（或错误）正是为了防止这种情况发生。

动手解决：兼容低版本 API 的几种办法

既然知道了原因，我们就可以对症下药了。这里有几种常见的处理方式：

方案一：老派但有效：containsKey + get

这是最直观也是最经典的方法。在调用 get 之前，先用 containsKey 检查一下 key 是否存在。

原理与作用：

这个方法的核心思路是“先检查，再操作”。

用 containsKey(itemset) 判断 supportCountMap 中是否已经包含当前的 itemset。
如果包含（返回 true），就用 get(itemset) 获取现有值，然后加 1，再用 put 更新回去。
如果不包含（返回 false），说明这是第一次遇到这个 itemset，直接用 put(itemset, 1) 将它的计数设置为 1（因为 defaultValue 是 0，加 1 就是 1）。

代码示例 (Java):

for (Set<I> itemset : candidateList2) {
    int currentCount;
    if (supportCountMap.containsKey(itemset)) {
        // Key 存在，获取旧值并加 1
        currentCount = supportCountMap.get(itemset);
        supportCountMap.put(itemset, currentCount + 1);
    } else {
        // Key 不存在，直接设置为 1 (相当于 0 + 1)
        supportCountMap.put(itemset, 1);
    }
}

// 或者稍微合并一下 put 操作：
for (Set<I> itemset : candidateList2) {
    int newCount;
    if (supportCountMap.containsKey(itemset)) {
        newCount = supportCountMap.get(itemset) + 1;
    } else {
        newCount = 1; // 默认值 0 + 1
    }
    supportCountMap.put(itemset, newCount);
}

优点：

简单明了，逻辑清晰。
兼容所有 Android API Level。只要你的 minSdk 支持 HashMap（基本上都支持），这段代码就能跑。

缺点：

代码相对啰嗦一点。
对于 Map 的每次更新操作，可能需要进行两次查找：一次 containsKey，一次 get（如果 key 存在的话）。相比 getOrDefault（理想情况下内部优化为一次查找），效率可能略低，但在大多数场景下这点差异可以忽略不计。

安全建议：

如果 supportCountMap 可能在多个线程中被访问和修改，使用普通的 HashMap 是不安全的。这种检查再操作（check-then-act）的模式在并发环境下存在竞态条件（Race Condition）：一个线程检查 containsKey 返回 false 后，在它执行 put 之前，另一个线程可能已经插入了相同的 key。你应该考虑使用 ConcurrentHashMap，并且需要采用更安全的并发更新方式（后面会提到）。

方案二：三元运算符的优雅

如果你觉得 if-else 结构有点冗长，可以使用三元运算符 (? :) 让代码更紧凑。

原理与作用：

利用三元运算符 condition ? value_if_true : value_if_false，结合 containsKey 和 get，在一行代码里完成计数计算。

代码示例 (Java):

for (Set<I> itemset : candidateList2) {
    // 如果 containsKey 返回 true，就 get(itemset)；否则返回默认值 0。最后统一加 1。
    int currentCount = supportCountMap.containsKey(itemset) ? supportCountMap.get(itemset) : 0;
    supportCountMap.put(itemset, currentCount + 1);
}

优点：

比 if-else 代码更简洁。
同样兼容所有 API Level。

缺点：

本质上还是执行了两次查找（containsKey 和 get）。
对于复杂的逻辑，嵌套的三元运算符可读性会变差（虽然在这个场景下还比较清晰）。

安全建议：

与方案一相同，需要注意多线程环境下的安全性。使用 HashMap 时存在竞态条件。

方案三：拥抱 Kotlin 的扩展函数（如果项目使用 Kotlin）

如果你的项目是 Kotlin 或者 Java/Kotlin 混合项目，那么恭喜你，Kotlin 标准库提供了很多方便的扩展函数来优雅地处理这种情况。

原理与作用：

Kotlin 标准库为 Java 的集合类提供了许多扩展函数，让代码更简洁、易读且安全。针对这个场景，getOrPut 函数非常有用。

map.getOrPut(key) { defaultValue } 的行为是：

查找 map 中是否存在 key。
如果存在，直接返回对应的 value。
如果不存在，它会执行 lambda 表达式 { defaultValue } 来计算默认值，然后将 (key, defaultValue) 这个键值对存入 map 中，最后返回这个计算出的 defaultValue。

虽然 getOrPut 不能直接用于原地递增，但结合 Kotlin 的其他特性，我们可以写出很简洁的代码。最接近 getOrDefault 行为并且适用于计数场景的是结合 get 和 put，或者直接使用 Kotlin 的可空类型和 ?: (elvis operator)。

代码示例 (Kotlin):

// 模拟 Java 代码中的 Map<Set<I>, Int>
val supportCountMap = mutableMapOf<Set<I>, Int>()
val candidateList2: List<Set<I>> = listOf() // 假设的数据

// 方法 1: 使用 get 和 elvis operator (?:)
for (itemset in candidateList2) {
    val currentCount = supportCountMap[itemset] ?: 0 // map[key] 在 Kotlin 中等价于 map.get(key)，如果 key 不存在返回 null
    supportCountMap[itemset] = currentCount + 1
}

// 方法 2: 使用 compute （注意： compute 本身也需要 API 24，但如果启用了 Desugaring，或者你使用了下面的库版本，就可以）
// 这个方法更原子性，但有 API Level 限制或需要 Desugaring
// supportCountMap.compute(itemset) { _, value -> (value ?: 0) + 1 }

// 方法 3: 自己封装一个类似 getOrDefault 的扩展函数（如果不想用 Desugaring）
// 这只是演示，实际项目中很少需要为这么简单的操作写扩展，但原理是这样
fun <K, V> MutableMap<K, V>.getOrDefaultCompat(key: K, defaultValue: V): V {
    return this[key] ?: defaultValue
}

// 使用自定义的扩展函数
for (itemset in candidateList2) {
    val currentCount = supportCountMap.getOrDefaultCompat(itemset, 0)
    supportCountMap[itemset] = currentCount + 1
}

优点：

Kotlin 代码通常更简洁易读，尤其是 elvis 操作符 ?: 处理 null 非常方便。
Kotlin 的标准库考虑了很多这类常见用法。

缺点：

需要项目支持 Kotlin。
直接的 getOrPut 不完全适用于 "获取或默认然后加一" 的场景，需要稍微变通一下。
如果想用 compute 等更高级、原子性更好的操作，可能还是会遇到 API Level 问题（除非启用 Desugaring）。

进阶使用技巧：

Kotlin 的 map[key] = value 语法糖背后是调用 put(key, value)。
利用 Kotlin 的空安全特性，可以有效避免 NullPointerException。

方案四：Android Gradle 插件的 Java 8+ API Desugaring

这可能是最“现代”也最接近“直接使用 getOrDefault”的方案了。Android Gradle 插件提供了一个叫 "Desugaring"（脱糖）的功能，它允许你在较低 API Level 的设备上使用部分 Java 8+ 的语言特性和 API。

原理与作用：

Desugaring 的工作原理是在编译时，将使用了 Java 8+ 特性（比如 Lambda 表达式、getOrDefault 等方法）的代码，转换为能在旧版 Android Java 运行时（通常是基于 Java 7 的 ART 或 Dalvik）上运行的等效字节码。对于库 API（如 getOrDefault），它会引入一个小的伴生库（com.android.tools:desugar_jdk_libs），其中包含了这些 API 的向后兼容实现。

这样一来，你可以在代码中直接写 getOrDefault，构建工具会负责幕后的转换工作，让它能在你指定的 minSdk 设备上运行。

操作步骤：

确保你的 Android Gradle 插件版本足够新（通常 4.0 或更高版本支持良好）。

在你的 app 模块的 build.gradle (或者 build.gradle.kts) 文件中进行配置：

// build.gradle (Groovy DSL)

android {
    // ... 其他配置 ...

    compileOptions {
        // เปิดใช้งานคุณสมบัติภาษา Java 8+
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    // สำหรับ Kotlin 项目, 也需要设置 jvmTarget
    // kotlinOptions {
    //     jvmTarget = '1.8'
    // }

    // เปิดใช้งานการ desugaring สำหรับ API ไลบรารี Java 8+
    coreLibraryDesugaringEnabled true
}

dependencies {
    // ... 其他依赖 ...

    // 添加 desugaring 库依赖
    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.1.5' // 使用较新的稳定版本
}

// build.gradle.kts (Kotlin DSL)

android {
    // ... 其他配置 ...

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }

    // 对于 Kotlin 项目, 也需要设置 jvmTarget
    // kotlinOptions {
    //     jvmTarget = "1.8"
    // }

    // 启用 Java 8+ 库 API 的 Desugaring
    isCoreLibraryDesugaringEnabled = true
}

dependencies {
    // ... 其他依赖 ...

    // 添加 desugaring 库依赖
    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:1.1.5") // 使用较新的稳定版本
}

配置说明：

compileOptions 中的 sourceCompatibility 和 targetCompatibility 设置为 JavaVersion.VERSION_1_8，是启用 Java 8 语言特性支持的前提。
coreLibraryDesugaringEnabled true 是开启 API 脱糖的关键。
dependencies 中添加 coreLibraryDesugaring 依赖，它包含了兼容库的实现。请注意检查并使用最新的稳定版本（可以在 Google Maven Repository 或 Android 开发者文档中查找最新版本号）。

优点：

可以直接在代码中使用 getOrDefault 以及其他许多 Java 8+ API，代码保持简洁现代。
对现有代码的改动最小（如果已经使用了这些 API）。
官方支持，相对可靠。

缺点：

会略微增加编译时间。
会给最终的 APK 增加一点点体积（因为包含了 desugar_jdk_libs 库）。
并非所有 Java 8+ API 都支持脱糖，具体支持列表需要查阅官方文档。不过像 getOrDefault 这种常用的集合 API 通常都在支持之列。
偶尔可能遇到一些脱糖相关的编译或运行时问题（尽管越来越少见）。

方案五：使用兼容库（比如 Apache Commons Collections 或 Guava - 但要慎重）

虽然 Guava 库提供了如 Multiset（可以方便地计数）或 AtomicLongMap（线程安全的计数 Map）等强大的集合工具，Apache Commons Collections 也有丰富的集合工具类，但专门为了替代 getOrDefault 而引入整个大型库可能有点小题大做，除非你的项目中已经因为其他原因使用了它们。

对于 getOrDefault 这个特定的简单功能，前面提到的几种方法通常更轻量、更直接。

如果你已经在使用这些库:

Guava: 你可能会考虑使用 Multiset 来直接管理计数，或者结合其 Map 工具类。但没有直接的 getOrDefault 替代品让你写出和原生一模一样的代码。AtomicLongMap 更适用于并发场景下的原子计数。
Apache Commons Collections: 同样，它提供了很多 Map 的装饰器和工具类，但也没有一个方法签名和用途与 getOrDefault 完全一致且专门用于向后兼容。

结论: 这个方案对于解决 getOrDefault 单点问题来说，通常不是最优选，除非你项目中深度依赖这些库的其他功能。

进阶讨论：性能与线程安全

性能：
- 方案一（containsKey + get）和方案二（三元运算符）通常涉及两次 Map 查找（一次检查存在性，一次获取值）。
- getOrDefault （原生或通过 Desugaring 实现）理想情况下经过优化，可以认为是一次查找操作。
- Kotlin 的 map[itemset] ?: 0 也是一次查找（get），然后判空。
- 在绝大多数应用中，这种微小的性能差异几乎可以忽略不计。只有在极度性能敏感的热点代码路径中（比如每秒执行成千上万次循环），才需要仔细考虑。

线程安全：

原始代码片段和方案一、二、三（使用 HashMap 或标准 mutableMapOf）都不是线程安全的。如果在多线程环境中共用并修改同一个 supportCountMap，你需要采取措施。
使用 ConcurrentHashMap： 这是 Java 中线程安全的 Map 实现。但是，即使用了 ConcurrentHashMap，像 containsKey 之后再 put 的操作（方案一）仍然不是原子（Atomic）的。两个线程可能同时判断 key 不存在，然后都尝试 put，或者一个线程 put 了新值后，另一个线程基于旧值计算并覆盖。

ConcurrentHashMap 的原子操作： 对于计数场景，ConcurrentHashMap 提供了更安全的原子操作，比如 compute() (Java 8+, API 24+)， merge() (Java 8+, API 24+)。

// 需要 API 24+ 或启用 Desugaring
ConcurrentHashMap<Set<I>, Integer> concurrentSupportCountMap = new ConcurrentHashMap<>();
// ...
for (Set<I> itemset : candidateList2) {
    // 原子地更新计数
    concurrentSupportCountMap.compute(itemset, (key, value) -> (value == null) ? 1 : value + 1);
    // 或者使用 merge
    // concurrentSupportCountMap.merge(itemset, 1, Integer::sum);
}

如果不能用 API 24+ 原子操作 (也无法用 Desugaring): 实现 ConcurrentHashMap 的原子计数会麻烦一些，可能需要用到 putIfAbsent 结合循环和 replace，或者使用 AtomicInteger 作为 Map 的 Value 类型。

// 使用 AtomicInteger 作为 Value，配合 ConcurrentHashMap
ConcurrentHashMap<Set<I>, AtomicInteger> atomicSupportCountMap = new ConcurrentHashMap<>();
// ...
for (Set<I> itemset : candidateList2) {
     // 尝试放入新的 AtomicInteger(1) 如果 key 不存在
    AtomicInteger count = atomicSupportCountMap.putIfAbsent(itemset, new AtomicInteger(1));
    // 如果放入成功 (count == null)，说明是第一次，计数已为1
    // 如果放入失败 (count != null)，说明 key 已存在，获取已有的 AtomicInteger 并自增
    if (count != null) {
        count.incrementAndGet(); // 原子自增
    }
}
// 注意：putIfAbsent 返回的是之前的值，如果key不存在则返回null

// 更简洁的方式是循环+replace (CAS操作)
for (Set<I> itemset : candidateList2) {
     while (true) {
         AtomicInteger existingCounter = atomicSupportCountMap.get(itemset);
         if (existingCounter == null) {
             // 尝试插入新的计数器
             if (atomicSupportCountMap.putIfAbsent(itemset, new AtomicInteger(1)) == null) {
                 break; // 插入成功，完成
             }
             // 如果 putIfAbsent 失败，说明有其他线程刚好插入了，循环继续，会走到下面的 replace 逻辑
         } else {
             // 尝试原子地增加现有计数器的值
             int oldValue = existingCounter.get();
             if (existingCounter.compareAndSet(oldValue, oldValue + 1)) {
                 break; // CAS 成功，完成
             }
             // 如果 CAS 失败，说明值被其他线程修改了，循环继续重试
         }
     }
 }

这比 compute 或 merge 复杂多了，但它能在低版本 API 上实现并发安全计数。不过 AtomicInteger 本身也是有 API Level 要求的 (API 9)，但通常远低于 24。

Desugaring 与线程安全： 启用 Desugaring 可以让你直接使用 getOrDefault 语法，或者甚至 ConcurrentHashMap.compute/merge，这大大简化了线程安全代码的编写。

如何选择？

选择哪种方案取决于你的项目具体情况：

项目使用 Kotlin？ 优先考虑 Kotlin 的方式（方案三），代码简洁易懂。
项目是纯 Java 或 Java 为主，且希望代码风格统一，能用上 Java 8+ 的便利？ 强烈推荐启用 Desugaring（方案四）。这是目前 Android 开发的主流做法，可以让你直接使用 getOrDefault 和许多其他现代 API。
不想启用 Desugaring（比如担心构建时间、APK 体积增加或潜在的兼容性问题），或者项目非常老旧？ 使用经典的 containsKey + get（方案一）或三元运算符（方案二）。它们足够可靠，兼容性最好。
多线程环境？ 无论选择哪种方法获取/计算值，都要确保 Map 的更新操作是线程安全的。优先考虑 ConcurrentHashMap，并尽量使用其原子操作（如 compute, merge，可能需要 Desugaring）。如果不能使用原子操作，请采用上面讨论的更复杂的 CAS 或 AtomicInteger 方式。