guava初学

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)

不可变的集合

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

  1. 线程安全,因为不能修改任何元素,可以随意多线程使用且没有并发问题。
  2. 可以无忧的提供给第三方使用,反正修改不了。
  3. 减少内存占用,因为不能改变,所以内部实现可以最大程度节约内存占用。
  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);
  1. 如果不可变集合的元素是引用对象,那么引用对象的属性是可以更改的。

其他不可变集合

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

可变集合接口属于JDK还是Guava不可变版本
CollectionJDKImmutableCollection
ListJDKImmutableList
SetJDKImmutableSet
SortedSet/NavigableSetJDKImmutableSortedSet
MapJDKImmutableMap
SortedMapJDKImmutableSortedMap
MultisetGuavaImmutableMultiset
SortedMultisetGuavaImmutableSortedMultiset
MultimapGuavaImmutableMultimap
ListMultimapGuavaImmutableListMultimap
SetMultimapGuavaImmutableSetMultimap
BiMapGuavaImmutableBiMap
ClassToInstanceMapGuavaImmutableClassToInstanceMap
TableGuavaImmutableTable

集合操作工厂

      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 是 ListMap 集合。

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

    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

  1. 通常要实现重复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
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值