guava初学

最新推荐文章于 2024-05-09 23:29:43 发布

精神阿祝

最新推荐文章于 2024-05-09 23:29:43 发布

阅读量276

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/weixin_44692308/article/details/125717324

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

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

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

<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>30.0-jre</version>
</dependency>

数据校验

通常数据校验我们写 if(null!=***)，代码多，而使用guava的数据校验则十分简单优雅。

非空判断

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

String name = Preconditions.checkNotNull("非空");
System.out.println(name);

String name2 = Preconditions.checkNotNull(null,"空指针异常！");
System.out.println(name2);
// java.lang.NullPointerException: 空指针异常！

预期值判断

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

String str="123";
String str2="321";
Preconditions.checkArgument(str.equals(str2),"[%s] 404 NOT FOUND", str);
// java.lang.IllegalArgumentException: [123] 404 NOT FOUND

是否越界

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

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

不可变的集合

创建一个不能删除、不能修改、不能增加元素的集合的优点：

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

创建方式

//不可变set  方式of
        ImmutableSet<String> strings = ImmutableSet.of("a", "s", "d", "d");
        strings.forEach(System.out::println);
//        strings.add("12");   //UnsupportedOperationException不支持的操作
        //enum 类型
        ImmutableSet<Tests> tests = Sets.immutableEnumSet(Tests.ONE, Tests.TWO, Tests.THREE);
        tests.forEach(System.out::println);

        //不可变list 方式copyOf
        ArrayList<String> list = Lists.newArrayList("1", "2", "3");
        ImmutableList.copyOf(list).forEach(System.out::println);
        //不可变list 方式 builder
        ImmutableList<Object> build = ImmutableList.builder().add("孙子", "孙子", "孙子").build();
        build.forEach(System.out::println);
        //map
        ImmutableMap<Object, Object> map = ImmutableMap.builder().put("key", "value").put("key2", "value2").build();
        map.entrySet().forEach(en->System.out.println(en));

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

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

ArrayList<String> arrayList = new ArrayList();
arrayList.add("www.wdbyte.com");
arrayList.add("https");
// JDK Collections 创建不可变 List
List<String> list = Collections.unmodifiableList(arrayList);
list.forEach(System.out::println);// www.wdbyte.com https
list.add("未读代码"); // java.lang.UnsupportedOperationException

注意事项

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

		 ArrayList<Object> objects = new ArrayList<>();
        objects.add("23");
        objects.add("ad");

        List<Object> jdk = Collections.unmodifiableList(objects);  //jdk的不可变list
        ImmutableList<Object> guava = ImmutableList.copyOf(objects);  //guava 的不可变list

//        objects.add("1");
        jdk.forEach(System.out::println);
        System.out.println("____________");
        guava.forEach(System.out::println);

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

其他不可变集合

不可变集合除了上面演示的 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`

集合操作工厂

      ArrayList<String> strs = Lists.newArrayList();
        ArrayList<String> strs2 = Lists.newArrayList("1", "2", "3", "4")

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

集合交集并集差集

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


 //sets 的交并差
        HashSet<String> hashSet = Sets.newHashSet("1", "2", "3","4");
        HashSet<String> set2 = Sets.newHashSet("4", "5", "6");
        Sets.SetView<String> intersection = Sets.intersection(hashSet, set2);
        System.out.println("交集"+intersection);
        Sets.SetView<String> union = Sets.union(hashSet, set2);
        System.out.println("并集"+union);
        //param1存在的在param2中不存在
        Sets.SetView<String> difference = Sets.difference(hashSet, set2);
        System.out.println("差集"+difference);

计数集合

因为我们经常会需要设计可以计数的集合，或者 value 是 List 的 Map 集合。

统计相同元素出现的次数。

JDK 原生写法：

   // Java 统计相同元素出现的次数。
   List<String> words = Lists.newArrayList("a", "b", "c", "d", "a", "c");
   Map<String, Integer> countMap = new HashMap<String, Integer>();
   for (String word : words) {
       Integer count = countMap.get(word);
       count = (count == null) ? 1 : ++count;
       countMap.put(word, count);
   }
   countMap.forEach((k, v) -> System.out.println(k + ":" + v));
   /**
    * result:
    * a:2
    * b:1
    * c:2
    * d:1
    */

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

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

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

可重复key的Map：HashMultiMap

通常要实现重复key除非是写成这样Map。而HashMultiMap本质上就是HashMap。

假设一个场景，需要把很多动物按照种类进行分类。

JDK 原生写法：

   HashMap<String, Set<String>> animalMap = new HashMap<>();
   HashSet<String> dogSet = new HashSet<>();
   dogSet.add("旺财");
   dogSet.add("大黄");
   animalMap.put("狗", dogSet);
   HashSet<String> catSet = new HashSet<>();
   catSet.add("加菲");
   catSet.add("汤姆");
   animalMap.put("猫", catSet);
   System.out.println(animalMap.get("猫")); // [加菲, 汤姆]

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

   // use guava
   HashMultimap<String, String> multimap = HashMultimap.create();
   multimap.put("狗", "大黄");
   multimap.put("狗", "旺财");
   multimap.put("猫", "加菲");
   multimap.put("猫", "汤姆");
   System.out.println(multimap.get("猫")); // [加菲, 汤姆]

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

散列

Object.hashCode往往很快，但是在预防碰撞上却很弱，也没有对分散性的预期。使用Java内建方法实现的散列码通常是劣质的，部分是因为它们最终都依赖于JDK类中已有的劣质散列码。MurmurHash算法：高运算性能，低碰撞率。

性能

在有定长的hash key需求时，可以使用MD5加密和Hashing类的算法。

但是在性能上普通MD5相对于hashing类并不高。

下面的列子进行10000次计算，看各种算法的差距。

public static void main(String[] args) {
        String str="KFETHGRETWERFSDFWEFWEFWF";
        long startTime;
        long endTime;
        startTime=System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            Demo03.md5Test(str+i);
        }
        endTime=System.currentTimeMillis();
        System.out.println("1万次md5算法程序运行时间： " + (endTime - startTime ) + "ms--------------------------------");

        startTime=System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            Demo03.murmur3Test(str+i);
        }
        endTime=System.currentTimeMillis();
        System.out.println("1万次guava md5算法程序运行时间： " + (endTime - startTime) + "ms");

        startTime=System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            Demo03.murmur3Test2(str+i);
        }
        endTime=System.currentTimeMillis();
        System.out.println("1万次hash32算法程序运行时间： " + (endTime - startTime) + "ms");

        startTime=System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            Demo03.murmur3Test3(str+i);
        }
        endTime=System.currentTimeMillis();
        System.out.println("1万次hash128算法程序运行时间： " + (endTime - startTime) + "ms");
        hash128();
    }
    public static String md5Test(String primaryKey) {
        return DigestUtils.md5Hex(primaryKey)+ "_" + primaryKey;
    }
    public static String murmur3Test(String primaryKey) {
        return Hashing.md5().hashString(primaryKey, StandardCharsets.UTF_8).toString() +
                "_" + primaryKey;
    }
    public static String murmur3Test2(String primaryKey) {
        return Hashing.murmur3_32().hashString(primaryKey, StandardCharsets.UTF_8).toString() +
                "_" + primaryKey;
    }
    public static String murmur3Test3(String primaryKey) {
        return Hashing.murmur3_128().hashString(primaryKey, StandardCharsets.UTF_8).toString() +
                "_" + primaryKey;
    }

算法	加密/非加密	性能（执行10000次耗时）
DigestUtils.md5Hex()	加密	155ms
Hashing.md5()	加密	120ms
Hashing.murmur3_32()	非加密	37ms
Hashing.murmur3_128()	非加密	87ms

hashing的方法

[ goodFastHash(int minimumBits) ]: 返回一个多用途的，临时使用的，非加密的 Hash Function
[ murmur3_32(int seed) ]: 使用指定参数值做种子返回一个 murmur3 算法实现的 32 位的哈希值
[ murmur3_32() ]: 使用零值种子返回一个 murmur3 算法实现的 32 位的哈希值
[ murmur3_128() ]: 使用零值种子返回一个 murmur3 算法实现的128位的哈希值。
[ sipHash24() ]: sipHash24 加密算法
[ sipHash24(long k0, long k1) ]: sipHash24 加密算法
[ md5() ]: md5 加密算法。
[ sha1() ]：sha1算法，hash。
[ sha256() ]: sha256 加密算法
[ sha384() ]: sha384 加密算法
[ sha512() ]: sha512 加密算法
[ hmacMd5(Key key) ]： hmacMd5 加密算法
[ hmacMd5(byte[] key) ]：hmacMd5 加密算法
[ hmacSha1(Key key) ]：hmacSha1 加密算法
[ hmacSha1(byte[] key) ]：hmacSha1 加密算法
[ hmacSha256(Key key) ]：hmacSha256 加密算法
[ hmacSha256(byte[] key) ]：hmacSha256 加密算法
[ hmacSha512(Key key) ]：hmacSha512 加密算法
[ hmacSha512(byte[] key) ]：hmacSha512 加密算法
[ crc32c() ]：CRC32C 校验算法
[ crc32() ]：CRC-32 校验算法
[ adler32() ]：Adler-32 校验算法
[ farmHashFingerprint64() ]
[ consistentHash(HashCode hashCode, int buckets) ]：以给定 buckets 的大小分配一致性哈希，最大限度的减少随 buckets 增长而进行重新映射的需要。
[ consistentHash(long input, int buckets) ]
[ combineOrdered(Iterable hashCodes) ]：以有序的方式使 HashCode 结合起来，如果两个 HashCode 集合采用此种方法结合后的 HashCode 相同，那么这两个 HashCode 集合中的元素可能是顺序相等的。
[ combineUnordered(Iterable hashCodes) ]: 以无序的方式使 HashCode 结合起来，如果两个 HashCode 集合采用此方法结合后的 HashCode 相同，那么这两个 HashCode 集合中的元素可能在某种排序方式下是顺序相等的。
[ concatenating(HashFunction first, HashFunction second, HashFunction… rest) ]: 将多个hash值拼接在一起。比如你想要1024位的一个hash，你就可以Hashing.concatenating(Hashing.sha512(), Hashing.sha512())

一致性hash

使用hashing类的静态方法“consistentHash”，可给出机器下标。

原理：得到这个hash归类到某一个机器，如果增加减少机器他还能够是原先的那台机器就是一致性。

int bucket = Hashing.consistentHash(key, buckets) // bucket 的范围在 0 ~ buckets 之间

示例代码：

HashCode code = Hashing.murmur3_32().hashString("KDJFKJDHFK", StandardCharsets.UTF_8);
        ArrayList<String> list = Lists.newArrayList("server1", "server2", "server3");
        int bucket = Hashing.consistentHash(code, list.size()); // bucket 的范围在 0 ~ buckets 之间
        System.out.println(bucket);

        //加一台机器
        list.add("server4");
        bucket = Hashing.consistentHash(code, list.size());
        System.out.println(bucket);

        //减去两台机器
        list.remove("server4");
        list.remove("server1");
        bucket = Hashing.consistentHash(code, list.size());
        System.out.println(bucket);

精神阿祝

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
guava初学

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

扫一扫

专栏目录