文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

Guava - 拯救垃圾代码，写出优雅高效，效率提升N倍

2024-12-03 18:05

关注

最近在看一个同学代码的时候，发现代码中大量使用了 Google 开源的 Guava 核心库中的内容，让代码简单清晰了不少，故学习分享出 Guava 中我认为最实用的功能。

Guava 项目是 Google 公司开源的 Java 核心库，它主要是包含一些在 Java 开发中经常使用到的功能，如数据校验、不可变集合、计数集合，集合增强操作、I/O、缓存、字符串操作等。并且 Guava 广泛用于 Google 内部的 Java 项目中，也被其他公司广泛使用，甚至在新版 JDK 中直接引入了 Guava 中的优秀类库，所以质量毋庸置疑。

使用方式直接 mavan 依赖引入。

  1. -- https://mvnrepository.com/artifact/com.google.guava/guava --> 
  2.  
  3.     com.google.guava 
  4.     guava 
  5.     30.0-jre 
  6.  

数据校验

数据校验说来十分简单，一是非空判断，二是预期值判断。非空判断我想每一个 Java 开发者都很熟悉，一开始都经常和 NullPointException 打交道。处理的方式我们自然是一个 if( xx == null) 就能轻松解决。预期值判断也是类似，检查数据值是不是自己想要的结果即可。

即使这么简单的操作，我们是不是还经常出错呢?而且写起来的代码总是一行判断一行异常抛出，怎么看都觉得那么优雅。还好，现在就来尝试第一次使用 Guava 吧。

非空判断

 

  1. String param = "未读代码"; 
  2. String name = Preconditions.checkNotNull(param); 
  3. System.out.println(name); // 未读代码 
  4. String param2 = null; 
  5. String name2 = Preconditions.checkNotNull(param2); // NullPointerException 
  6. System.out.println(name2); 

引入了 Guava 后可以直接使用 Preconditions.checkNotNull 进行非空判断，好处为觉得有两个，一是语义清晰代码优雅;二是你也可以自定义报错信息，这样如果参数为空，报错的信息清晰，可以直接定位到具体参数。

  1. String param2 = null; 
  2. String name2 = Preconditions.checkNotNull(param2,"param2 is null"); 
  3. // java.lang.NullPointerException: param2 is null 

预期值判断

和非空判断类似，可以比较当前值和预期值，如果不相等可以自定义报错信息抛出。

  1. String param = "www.wdbyte.com2"; 
  2. String wdbyte = "www.wdbyte.com"; 
  3. Preconditions.checkArgument(wdbyte.equals(param), "[%s] 404 NOT FOUND", param); 
  4. // java.lang.IllegalArgumentException: [www.wdbyte.com2] 404 NOT FOUND 

是否越界

Preconditions 类还可以用来检查数组和集合的元素获取是否越界。

  1. // Guava 中快速创建ArrayList 
  2. List list = Lists.newArrayList("a", "b", "c", "d"); 
  3. // 开始校验 
  4. int index = Preconditions.checkElementIndex(5, list.size()); 
  5. // java.lang.IndexOutOfBoundsException: index (5) must be less than size (4) 

代码中快速创建 List 的方式也是 Guava 提供的，后面会详细介绍 Guava 中集合创建的超多姿势。

不可变的集合

创建不可变集合是我个人最喜欢 Guava 的一个原因，因为创建一个不能删除、不能修改、不能增加元素的集合实在是太实用了。这样的集合你完全不用担心发生什么问题，总的来说有下面几个优点：

  1. 线程安全，因为不能修改任何元素，可以随意多线程使用且没有并发问题。
  2. 可以无忧的提供给第三方使用，反正修改不了。
  3. 减少内存占用，因为不能改变，所以内部实现可以最大程度节约内存占用。
  4. 可以用作常量集合。

创建方式

说了那么多，那么到底怎么使用呢?赶紧撸起代码来。

  1. // 创建方式1：of 
  2. ImmutableSet immutableSet = ImmutableSet.of("a", "b", "c"); 
  3. immutableSet.forEach(System.out::println); 
  4. // a 
  5. // b 
  6. // c 
  7.  
  8. // 创建方式2：builder 
  9. ImmutableSet immutableSet2 = ImmutableSet.builder() 
  10.     .add("hello") 
  11.     .add(new String("未读代码")) 
  12.     .build(); 
  13. immutableSet2.forEach(System.out::println); 
  14. // hello 
  15. // 未读代码 
  16.  
  17. // 创建方式3：从其他集合中拷贝创建 
  18. ArrayList arrayList = new ArrayList(); 
  19. arrayList.add("www.wdbyte.com"); 
  20. arrayList.add("https"); 
  21. ImmutableSet immutableSet3 = ImmutableSet.copyOf(arrayList); 
  22. immutableSet3.forEach(System.out::println); 
  23. // www.wdbyte.com 
  24. // https 

都可以正常打印遍历结果，但是如果进行增删改，会直接报 UnsupportedOperationException .

其实 JDK 中也提供了一个不可变集合，可以像下面这样创建。

  1. ArrayList arrayList = new ArrayList(); 
  2. arrayList.add("www.wdbyte.com"); 
  3. arrayList.add("https"); 
  4. // JDK Collections 创建不可变 List 
  5. List list = Collections.unmodifiableList(arrayList); 
  6. list.forEach(System.out::println);// www.wdbyte.com https 
  7. list.add("未读代码"); // java.lang.UnsupportedOperationException 

注意事项

使用 Guava 创建的不可变集合是拒绝 null 值的，因为在 Google 内部调查中，95% 的情况下都不需要放入 null 值。

使用 JDK 提供的不可变集合创建成功后，原集合添加元素会体现在不可变集合中，而 Guava 的不可变集合不会有这个问题。

  1. List arrayList = new ArrayList<>(); 
  2.    arrayList.add("a"); 
  3.    arrayList.add("b"); 
  4.    List jdkList = Collections.unmodifiableList(arrayList); 
  5.    ImmutableList immutableList = ImmutableList.copyOf(arrayList); 
  6.    arrayList.add("ccc"); 
  7.    jdkList.forEach(System.out::println);// result: a b ccc 
  8.    System.out.println("-------"); 
  9.    immutableList.forEach(System.out::println);// result: a b 

如果不可变集合的元素是引用对象，那么引用对象的属性是可以更改的。

其他不可变集合

不可变集合除了上面演示的 set 之外，还有很多不可变集合，下面是 Guava 中不可变集合和其他集合的对应关系。

可变集合接口 属于JDK还是Guava 不可变版本
Collection JDK ImmutableCollection
List JDK ImmutableList
Set JDK ImmutableSet
SortedSet/NavigableSet JDK ImmutableSortedSet
Map JDK ImmutableMap
SortedMap JDK ImmutableSortedMap
Multiset Guava ImmutableMultiset
SortedMultiset Guava ImmutableSortedMultiset
Multimap Guava ImmutableMultimap
ListMultimap Guava ImmutableListMultimap
SetMultimap Guava ImmutableSetMultimap
BiMap Guava ImmutableBiMap
ClassToInstanceMap Guava ImmutableClassToInstanceMap
Table Guava ImmutableTable

集合操作工厂

其实这里只会介绍一个创建方法，但是为什么还是单独拿出来介绍了呢?看下去你就会大呼好用。虽然 JDK 中已经提供了大量的集合相关的操作方法，用起来也是非常的方便，但是 Guava 还是增加了一些十分好用的方法，保证让你用上一次就爱不释手，

创建集合。

  1. // 创建一个 ArrayList 集合 
  2. List list1 = Lists.newArrayList(); 
  3. // 创建一个 ArrayList 集合，同时塞入3个数据 
  4. List list2 = Lists.newArrayList("a", "b", "c"); 
  5. // 创建一个 ArrayList 集合，容量初始化为10 
  6. List list3 = Lists.newArrayListWithCapacity(10); 
  7.  
  8. LinkedList linkedList1 = Lists.newLinkedList(); 
  9. CopyOnWriteArrayList cowArrayList = Lists.newCopyOnWriteArrayList(); 
  10.  
  11. HashMap hashMap = Maps.newHashMap(); 
  12. ConcurrentMap concurrentMap = Maps.newConcurrentMap(); 
  13. TreeMap treeMap = Maps.newTreeMap(); 
  14.  
  15. HashSet hashSet = Sets.newHashSet(); 
  16. HashSet newHashSet = Sets.newHashSet("a", "a", "b", "c"); 
    17. 

    Guava  为每一个集合都添加了工厂方法创建方式，上面已经展示了部分集合的工厂方法创建方式。是不是十分的好用呢。而且可以在创建时直接扔进去几个元素，这个简直太赞了，再也不用一个个  add 了。
    

    集合交集并集差集
    

    过于简单，直接看代码和输出结果吧。
    

    1. Set newHashSet1 = Sets.newHashSet("a", "a", "b", "c"); 
    2. Set newHashSet2 = Sets.newHashSet("b", "b", "c", "d"); 
    3.  
    4. // 交集 
    5. SetView intersectionSet = Sets.intersection(newHashSet1, newHashSet2); 
    6. System.out.println(intersectionSet); // [b, c] 
    7.  
    8. // 并集 
    9. SetView unionSet = Sets.union(newHashSet1, newHashSet2); 
    10. System.out.println(unionSet); // [a, b, c, d] 
    11.  
    12. // newHashSet1 中存在，newHashSet2 中不存在 
    13. SetView setView = Sets.difference(newHashSet1, newHashSet2); 
    14. System.out.println(setView); // [a] 
    

    有数量的集合
    

    这个真的太有用了，因为我们经常会需要设计可以计数的集合，或者 value 是 List 的 Map  集合，如果说你不太明白，看下面这段代码，是否某天夜里你也这样写过。
    

    统计相同元素出现的次数(下面的代码我已经尽可能精简写法了)。
    

    JDK  原生写法：
    

    1. // Java 统计相同元素出现的次数。 
    2.    List words = Lists.newArrayList("a", "b", "c", "d", "a", "c"); 
    3.    MapInteger> countMap = new HashMapInteger>(); 
    4.    for (String word : words) { 
    5.        Integer count = countMap.get(word); 
    6.        count = (count == null) ? 1 : ++count; 
    7.        countMap.put(word, count); 
    8.    } 
    9.    countMap.forEach((k, v) -> System.out.println(k + ":" + v)); 
    10.     
    

    尽管已经尽量优化代码，代码量还是不少的，那么在 Guava 中有什么不一样呢?在 Guava. 中主要是使用 HashMultiset  类，看下面。
    

    1. ArrayList arrayList = Lists.newArrayList("a", "b", "c", "d", "a", "c"); 
    2.    HashMultiset multiset = HashMultiset.create(arrayList); 
    3.    multiset.elementSet().forEach(s -> System.out.println(s + ":" + multiset.count(s))); 
    4.     
    

    是的，只要把元素添加进去就行了，不用在乎是否重复，最后都可以使用 count  方法统计重复元素数量。看着舒服，写着优雅，HashMultiset 是 Guava 中实现的 Collection 类，可以轻松统计元素数量。
    

    一对多，value 是 List 的 Map 集合。
    

    假设一个场景，需要把很多动物按照种类进行分类，我相信最后你会写出类似的代码。
    

    JDK 原生写法：
    

    1. HashMapSet> animalMap = new HashMap<>(); 
    2.   HashSet dogSet = new HashSet<>(); 
    3.   dogSet.add("旺财"); 
    4.   dogSet.add("大黄"); 
    5.   animalMap.put("狗", dogSet); 
    6.   HashSet catSet = new HashSet<>(); 
    7.   catSet.add("加菲"); 
    8.   catSet.add("汤姆"); 
    9.   animalMap.put("猫", catSet); 
    10.   System.out.println(animalMap.get("猫")); // [加菲, 汤姆] 
    

    最后一行查询猫得到了猫类的 "加菲" 和 ”汤姆“。这个代码简直太烦做了，如果使用 Guava 呢?
    

    1. // use guava 
    2.    HashMultimap multimap = HashMultimap.create(); 
    3.    multimap.put("狗", "大黄"); 
    4.    multimap.put("狗", "旺财"); 
    5.    multimap.put("猫", "加菲"); 
    6.    multimap.put("猫", "汤姆"); 
    7.    System.out.println(multimap.get("猫")); // [加菲, 汤姆] 
    

    HashMultimap 可以扔进去重复的 key 值，最后获取时可以得到所有的 value 值，可以看到输出结果和 JDK  写法上是一样的，但是代码已经无比清爽。
    

    字符串操作
    

    作为开发中最长使用的数据类型，字符串操作的增强可以让开发更加高效。
    

    字符拼接
    

    JDK 8 中其实已经内置了字符串拼接方法，但是它只是简单的拼接，没有额外操作，比如过滤掉 null 元素，去除前后空格等。先看一下  JDK 8 中字符串拼接的几种方式。
    

    

    1. // JDK 方式一 
    2. ArrayList list = Lists.newArrayList("a", "b", "c", null); 
    3. String join = String.join(",", list); 
    4. System.out.println(join); // a,b,c,null 
    5. // JDK 方式二 
    6. String result = list.stream().collect(Collectors.joining(",")); 
    7. System.out.println(result); // a,b,c,null 
    8. // JDK 方式三 
    9. StringJoiner stringJoiner = new StringJoiner(","); 
    10. list.forEach(stringJoiner::add); 
    11. System.out.println(stringJoiner.toString()); // a,b,c,null 
    

    可以看到 null 值也被拼接到了字符串里，这有时候不是我们想要的，那么使用 Guava 有什么不一样呢?
    

    1. ArrayList list = Lists.newArrayList("a", "b", "c", null); 
    2. String join = Joiner.on(",").skipNulls().join(list); 
    3. System.out.println(join); // a,b,c 
    4.  
    5. String join1 = Joiner.on(",").useForNull("空值").join("旺财", "汤姆", "杰瑞", null); 
    6. System.out.println(join1); // 旺财,汤姆,杰瑞,空值 
    

    可以看到使用 skipNulls()  可以跳过空值，使用 useFornull(String) 可以为空值自定义显示文本。
    

    字符串分割
    

    JDK  中是自带字符串分割的，我想你也一定用过，那就是 String 的 split  方法，但是这个方法有一个问题，就是如果最后一个元素为空，那么就会丢弃，奇怪的是第一个元素为空却不会丢弃，这就十分迷惑，下面通过一个例子演示这个问题。
    

    1. String str = ",a,,b,"; 
    2. String[] splitArr = str.split(","); 
    3. Arrays.stream(splitArr).forEach(System.out::println); 
    4. System.out.println("------"); 
    5.  
    

    你也可以自己测试下，最后一个元素不是空，直接消失了。
    

    如果使用 Guava  是怎样的操作方式呢?Guava 提供了 Splitter 类，并且有一系列的操作方式可以直观的控制分割逻辑。
    

    1. String str = ",a ,,b ,"; 
    2. Iterable split = Splitter.on(",") 
    3.     .omitEmptyStrings() // 忽略空值 
    4.     .trimResults() // 过滤结果中的空白 
    5.     .split(str); 
    6. split.forEach(System.out::println); 
    7.  
    

    缓存
    

    在开发中我们可能需要使用小规模的缓存，来提高访问速度。这时引入专业的缓存中间件可能又觉得浪费。现在可以了， Guava  中提供了简单的缓存类，且可以根据预计容量、过期时间等自动过期已经添加的元素。即使这样我们也要预估好可能占用的内存空间，以防内存占用过多。
    

    现在看一下在 Guava 中缓存该怎么用。
    

    1. @Test 
    2. public void testCache() throws ExecutionException, InterruptedException { 
    3.  
    4.     CacheLoader cacheLoader = new CacheLoader() { 
    5.         // 如果找不到元素，会调用这里 
    6.         @Override 
    7.         public Animal load(String s) { 
    8.             return null; 
    9.         } 
    10.     }; 
    11.     LoadingCache loadingCache = CacheBuilder.newBuilder() 
    12.         .maximumSize(1000) // 容量 
    13.         .expireAfterWrite(3, TimeUnit.SECONDS) // 过期时间 
    14.         .removalListener(new MyRemovalListener()) // 失效监听器 
    15.         .build(cacheLoader); // 
    16.     loadingCache.put("狗", new Animal("旺财", 1)); 
    17.     loadingCache.put("猫", new Animal("汤姆", 3)); 
    18.     loadingCache.put("狼", new Animal("灰太狼", 4)); 
    19.  
    20.     loadingCache.invalidate("猫"); // 手动失效 
    21.  
    22.     Animal animal = loadingCache.get("狼"); 
    23.     System.out.println(animal); 
    24.     Thread.sleep(4 * 1000); 
    25.     // 狼已经自动过去，获取为 null 值报错 
    26.     System.out.println(loadingCache.get("狼")); 
    27.      
    28. } 
    29.  
    30.  
    31. class MyRemovalListener implements RemovalListener { 
    32.  
    33.     @Override 
    34.     public void onRemoval(RemovalNotification notification) { 
    35.         String reason = String.format("key=%s,value=%s,reason=%s", notification.getKey(), notification.getValue(), notification.getCause()); 
    36.         System.out.println(reason); 
    37.     } 
    38. } 
    39.  
    40. class Animal { 
    41.     private String name; 
    42.     private Integer age; 
    43.  
    44.     @Override 
    45.     public String toString() { 
    46.         return "Animal{" + 
    47.             "name='" + name + '\'' + 
    48.             ", age=" + age + 
    49.             '}'; 
    50.     } 
    51.  
    52.     public Animal(String name, Integer age) { 
    53.         this.name = name; 
    54.         this.age = age; 
    55.     } 
    56. } 
    

    这个例子中主要分为  CacheLoader、MyRemovalListener、LoadingCache。
    

    CacheLoader 中重写了 load  方法，这个方法会在查询缓存没有命中时被调用，我这里直接返回了 null，其实这样会在没有命中时抛出 CacheLoader returned null for  key 异常信息。
    

    MyRemovalListener 作为缓存元素失效时的监听类，在有元素缓存失效时会自动调用 onRemoval  方法，这里需要注意的是这个方法是同步方法，如果这里耗时较长，会阻塞直到处理完成。
    

    LoadingCache  就是缓存的主要操作对象了，常用的就是其中的 put 和 get 方法了。
    

    总结
    

    上面介绍了我认为最常用的 Guava 功能，Guava  作为 Google 公司开源的 Java  开发核心库，个人觉得实用性还是很高的。引入后不仅能快速的实现一些开发中常用的功能，而且还可以让代码更加的优雅简洁。我觉得适用于每一个 Java 项目。Guava  的其他的功能你也可以自己去发现。它的 Github 地址是：https://github.com/google/guava.
    

    参考
    

    https://github.com/google/guava/wiki
    

     
    


     
    来源：Java知音内容投诉
    免责声明：
    ① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。 
    ② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
    软考中级精品资料免费领 
    • 历年真题答案解析
    • 备考技巧名师总结
    • 高频考点精准押题
    • 资料下载
    • 历年真题
    • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）
       难度      813人已做 
       查看 
    • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析
       难度      354人已做 
       查看 
    • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析
       难度      318人已做 
       查看 
    • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）
       难度      435人已做 
       查看 
    • 2024年上半年系统架构设计师考试综合知识真题
       难度      224人已做 
       查看 
    相关文章
    发现更多好内容
    猜你喜欢
    AI推送时光机
    Guava - 拯救垃圾代码，写出优雅高效，效率提升N倍
    后端开发GuavaJava2024-12-03
     位置：首页-资讯-后端开发
     咦！没有更多了？去看看其它编程学习网 内容吧 
    首页课程
    资料下载    问答资讯