Guava

介绍

Guava 是来自 Google 的一组核心 Java 库, 包含

1. 新的集合类型(collections)（例如 multimap 和 multiset）
2. 不可变集合
3. 图形库
4. 并发(concurrency)
5. I/O
6. 散列
7. 缓存(caching)
8. 基元(primitives support)
9. 字符串(string processing)

​​Google Guava 提供了很多工具方法, 并不是一个传统意义上的功能库. 比较分散

有jre(jdk8)和 Android 两种风格

• com.google.guava:guava:31.1-jre 完整功能
• com.google.guava:guava:31.1-android 精简功能 (移除部分 JDK 依赖，适配 Android 的受限运行时和性能优化需求)

示例

1. partition---将集合分块处理 (分批处理)

ArrayList<String> testList = Lists.newArrayList("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15");
Lists.partition(testList, 5).forEach(item->{
  System.out.println(item);
  System.out.println("=========");
});

• 使用场景：可以去查询数据库的使用in的方式，来控制查询的次数

List<Long> groupSysSkuIdList = new ArrayList<>();
List<Object> resultList = new ArrayList<>();
//将集合拆分以200个为单位，每个会执行下面forEach的逻辑
Lists.partition(groupSysSkuIdList,200).forEach(item->{
  Example example = new Example();
  //构造查询器，类比MybatisPlus的查询构造器
  example.createCriteria().
    //这里每次用拆分后的idList，用in的方式拆开查询
    .andGroupSysSkuIdIn(item);
  	//最后都加入到结果集合中
  resultList.addAll(xxxMapper.selectByExample(example));
});

2. cartesianProduct---实现集合间 笛卡尔积

ArrayList<String> listA = Lists.newArrayList("1", "2");
ArrayList<String> listB = Lists.newArrayList("3", "4");
ArrayList<String> listC = Lists.newArrayList("5", "6");

System.out.println(Lists.cartesianProduct(listA, listB,listC));

3. reverse---将元素位置反转

ArrayList<String> oldList = Lists.newArrayList("1", "2", "3"); System.out.println(oldList); System.out.println(Lists.reverse(oldList));

4. 不可变对象

- 初始化速度和查询速度要比可变集合快的;
- 内存占用也比可变集合低 (arrayList 1.5 倍扩容)

5. 分页

将一个可迭代对象（Iterable）按指定大小分割成多个子列表（类似于分块或分页）

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
// Iterable 是惰性的
Iterable<List<Integer>> partitions = Iterables.partition(numbers, 3);
for (List<Integer> chunk : partitions) {
    System.out.println(chunk);
}
// 每次遍历会重新计算分块，若需重复使用，建议缓存为 List
List<List<Integer>> cachedPartitions = ImmutableList.copyOf(Iterables.partition(numbers, 3));

---

(待更新)

其他

深拷贝

Guava 不提供深拷贝

• 浅拷贝

设计哲学​​：Java 倾向于让开发者显式控制拷贝行为（如通过 Cloneable 接口）

// 浅拷贝示例
int[][] original = {{1, 2}, {3, 4}};
List<int[]> list = Arrays.asList(original); // 浅拷贝
int[][] list2 = Arrays.copyOf(original, original.length); // 浅拷贝
// 修改原数组
original[0][0] = 99;
// 验证
System.out.println(list.get(0)[0]); // 输出 99（同步修改）
System.out.println(list2[0][0]); // 输出 99

• 深拷贝
  使用三方库 Apache Commons Lang

// Apache Commons Lang
int[][] deepCopy = SerializationUtils.clone(original);

• 还有一些别的方法, 但都有明显缺陷:

1. 手动逐层复制: 性能高，可控性强, but 代码冗长，需处理复杂结构
2. 序列化/反序列化: 通用性强，适合复杂对象, but 性能低，要求 Serializable
3. JSON 序列化: 无需 Serializable, but 性能较低，丢失类型信息

数字四舍五入

Math.ceil(double)  // 天花板; 向上 -1.5 = -1; 不是 cell 细胞
Math.floor(double) // 地板; 向下取整 -1.5 = -2
Math.round(double) // 四舍五入
Integer.parseInt(str)  // 直接舍去小数部分; 负数向上, 正数向下 -1.5 = -1