Google guava工具类库的介绍和使用
Posted 浅殇忆流年
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Google guava工具类库的介绍和使用相关的知识,希望对你有一定的参考价值。
📢📢📢📣📣📣
哈喽!大家好,今天给大家分享一篇有关Google guava工具类库的简单介绍以及使用;并演示了一些集合中常见的操作,附有代码演示示例,便于学习;
✨个人博客:https://blog.csdn.net/weixin_43759352✨
✨公众号:【SimpleMemory】✨
❤️❤️❤️如果有对【后端技术】感兴趣的大佬们,欢迎关注!!!❤️❤️❤️
一、简要概述
工具类就是封装平常用的方法,不需要你重复造轮子,节省开发人员时间,提高工作效率。谷歌作为大公司,当然会从日常的工作中提取中很多高效率的方法出来。所以就诞生了guava!
该工具类库主要有以下优点:
-
高效设计良好的API,被Google的开发者设计,实现和使用;
-
遵循高效的java语法实践;
-
使代码更刻度,简洁,简单;
-
节约时间,资源,提高生产力;
其次,Guava工程包含了若干被Google的 Java项目广泛依赖 的核心库,例如:
-
集合 [collections]
-
缓存 [caching]
-
原生类型支持 [primitives support]
-
并发库 [concurrency libraries]
-
通用注解 [common annotations]
-
字符串处理 [string processing]
-
I/O 等等。
二、如何使用
注:下面演示的是基于Maven的工程一些操作:
首先导入Google guava依赖:
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>21.0</version>
</dependency>
三、常用操作
3.1、创建集合
// 普通Collection的创建 List<String> arrayList = Lists.newArrayList(); Set<String> set = Sets.newHashSet(); Map<String, String> map = Maps.newHashMap(); //不变Collection的创建 ImmutableList<String> immutableList = ImmutableList.of("a", "b", "c"); ImmutableSet<String> immutableSet = ImmutableSet.of("e1", "e2"); ImmutableMap<String, String> immutableMap = ImmutableMap.of("k1", "v1", "k2", "v2");
创建不可变集合,先理解什么是immutable(不可变)对象:
-
在多线程操作下,是线程安全的;
-
所有不可变集合会比可变集合更有效的利用资源;
-
中途不可改变;
ImmutableList<String> immutableList = ImmutableList.of("1","2","3","4");
注:上面声明了一个不可变的List集合,List中有数据1,2,3,4。
类中的 操作集合的方法(譬如add, set, sort, replace等)都被声明过期,并且抛出异常。 而没用guava之前是需要声明并且加各种包裹集合才能实现这个功能。
比如:add方法:
/** @deprecated */ @Deprecated public final void add(int index, E element) throw new UnsupportedOperationException();
3.2、其他黑科技集合
Multiset<String> multiset = HashMultiset.create(); // 特点:元素无序、可重复
演示:
Multiset<String> multiset = HashMultiset.create(); multiset.add("上海"); multiset.add("杭州"); multiset.add("南京"); multiset.add("银川"); multiset.add("上海"); System.out.println("multiset = " + multiset);
multiset = [上海 x 2, 银川, 杭州, 南京]
Multimap<String, String> multimap = ArrayListMultimap.create(); // 特点:元素的 key可以重复
演示:
Multimap<String, String> multimap = ArrayListMultimap.create(); multimap.put("1", "杭州"); multimap.put("2", "深圳"); multimap.put("3", "广州"); multimap.put("2", "北京"); multimap.put("3", "广州"); System.out.println("multimap = " + multimap);
multimap = 1=[杭州], 2=[深圳, 北京], 3=[广州, 广州]
BiMap<String, String> biMap = HashBiMap.create(); // 特点:双向Map(Bidirectional Map) 键与值都不能重复
演示:
BiMap<String, String> biMap = HashBiMap.create(); biMap.put("1", "上海"); biMap.put("1", "深圳"); biMap.put("2", "广州"); biMap.put("2", "北京"); biMap.put("3", "成都"); System.out.println("biMap = " + biMap);
biMap = 1=深圳, 2=北京, 3=成都
Table<String, String, Integer> tables = HashBasedTable.create();
演示:
Table<Integer, Integer, Integer> table = HashBasedTable.<Integer, Integer, Integer>create(); table.put(1, 2, 3); //允许row和column确定的二维点重复 table.put(1, 6, 3); //判断row和column确定的二维点是否存在 if (table.contains(1, 2)) table.put(1, 4, 4); table.put(2, 5, 4); System.out.println("table = " + table); // 1=4=4, 2=3, 6=3, 2=5=4 //获取column为5的数据集 Map<Integer, Integer> column = table.column(5); System.out.println("column = " + column); // 2=4 //获取rowkey为1的数据集 Map<Integer, Integer> row = table.row(1); System.out.println("row = " + row); // 4=4, 2=3, 6=3 //获取rowKey为1,columnKey为2的的结果 Integer value = table.get(1, 2); System.out.println("value = " + value); // 3 //判断是否包含columnKey的值 System.out.println(table.containsColumn(3)); // false //判断是否包含rowKey为1的视图 System.out.println(table.containsRow(1)); // true //判断是否包含值为2的集合 System.out.println(table.containsValue(2)); // false //将table转换为Map套Map格式 Map<Integer, Map<Integer, Integer>> rowMap = table.rowMap(); System.out.println("rowMap = " + rowMap); // 1=4=4, 2=3, 6=3, 2=5=4 //获取所有的rowKey值的集合 Set<Integer> keySet = table.rowKeySet(); System.out.println("keySet = " + keySet); // [1, 2] //删除rowKey为1,columnKey为2的元素,返回删除元素的值 Integer res = table.remove(1, 2); //清空集合 table.clear(); System.out.println(res); // 3 System.out.println(table); // null
3.3、集中常见的操作示例
3.3.1、Map中包含key为String类型,value为List类型
// 之前写法: Map<String,List<Integer>> hashMap = new HashMap<String,List<Integer>>(); List<Integer> arrayList1 = new ArrayList<Integer>(); arrayList1.add(1); arrayList1.add(2); hashMap.put("aa", arrayList1); System.out.println(hashMap.get("aa")); // 现在写法: Multimap<String,Integer> map = ArrayListMultimap.create(); map.put("aa", 1); map.put("aa", 2); System.out.println(map.get("aa"));
3.3.2、将集合转换为特定规则的字符串
// 之前写法: List<String> list = new ArrayList<String>(); list.add("aa"); list.add("bb"); list.add("cc"); String str = ""; for(int i=0; i<list.size(); i++) str = str + "-" +list.get(i); //str 为-aa-bb-cc // 现在写法 List<String> list = new ArrayList<String>(); list.add("aa"); list.add("bb"); list.add("cc"); String result = Joiner.on("-").join(list); //result为 aa-bb-cc
3.3.3、将Map集合转化为特定规则的字符串
Map<String, Integer> newHashMap = Maps.newHashMap(); newHashMap.put("xiaoming", 12); newHashMap.put("xiaohong",13); String join = Joiner.on(",").withKeyValueSeparator("=").join(newHashMap); System.out.println("join = " + join); // join = xiaohong=13,xiaoming=12
3.3.4、将String转化为特定的集合
//之前写法: List<String> list = new ArrayList<String>(); String a = "1-2-3-4-5-6"; String[] strs = a.split("-"); for(int i=0; i<strs.length; i++) list.add(strs[i]); // 现在写法 String str = "1-2-3-4-5-6"; List<String> list = Splitter.on("-").splitToList(str); // list = [1, 2, 3, 4, 5, 6]
如果 str="1-2-3-4- 5- 6 ";
guava还可以使用 omitEmptyStrings().trimResults()
去除空串与空格。
strValue = "1-2-3-4- 5- 6 "; List<String> list2 = Splitter.on("-").omitEmptyStrings().trimResults().splitToList(strValue); System.out.println("list2 = " + list2); // list2 = [1, 2, 3, 4, 5, 6]
3.3.5、将String转化为map
String strValue1 = "1=上海,2=广州"; Map<String,String> stringMap = Splitter.on(",").withKeyValueSeparator("=").split(strValue1); System.out.println("stringMap = " + stringMap); // stringMap = 1=上海, 2=广州
3.3.6、guava支持多个字符的切割,或者特定的正则分割
String inputStr = "aa.dd,,ff,,."; List<String> list3 = Splitter.onPattern("[.|,]") .omitEmptyStrings() .splitToList(inputStr); System.out.println("list3 = " + list3); // list3 = [aa, dd, ff]
关于字符串的操作 都是在Splitter这个类上进行的:
// 判断匹配结果 boolean flag = CharMatcher.inRange('a', 'z').or(CharMatcher.inRange('A', 'Z')).matches('K'); System.out.println("flag = " + flag); // true // 保留数字文本 String s1 = CharMatcher.inRange('0', '9').retainFrom("abc 123 efg"); System.out.println("s1 = " + s1); // s1 = 123 // 删除数字文本 String s2 = CharMatcher.digit().removeFrom("abc 123 efg"); System.out.println("s2 = " + s2); // s2 = abc efg String s2_1 = CharMatcher.inRange('0', '9').removeFrom("abc 123 efg"); // abc efg System.out.println("s2_1 = " + s2_1); // s2_1 = abc efg
3.3.7、集合的过滤
我们对于集合的过滤,思路就是迭代,然后再具体对每一个数判断,这样的代码放在程序中,难免会显得很臃肿,虽然功能都有,但是很不好看。
下面演示的是guava写法:
//按照条件过滤 ImmutableList<String> names = ImmutableList.of("begin", "code", "Guava", "Java"); Iterable<String> fitered = Iterables.filter(names, Predicates.or(Predicates.equalTo("Guava"), Predicates.equalTo("Java"))); System.out.println("fitered = " + fitered); //自定义过滤条件 使用自定义回调方法对Map的每个Value进行操作 ImmutableMap<String, Integer> m = ImmutableMap.of("begin", 12, "code", 15); // Function<F, T> F表示apply()方法input的类型,T表示apply()方法返回类型 Map<String, Integer> m2 = Maps.transformValues(m, new Function<Integer, Integer>() public Integer apply(Integer input) if (input > 12) return input; else return input + 1; ); System.out.println("m2 = " + m2); // fitered = [Guava, Java] // m2 = begin=13, code=15
3.3.8、set的交集、并集、差集
HashSet setA = Sets.newHashSet(1, 2, 3, 4, 5); HashSet setB = Sets.newHashSet(4, 5, 6, 7, 8); Sets.SetView<Integer> union = Sets.union(setA, setB); System.out.println("union:"); for (Integer integer : union) System.out.println(integer); //union 并集:12345867 Sets.SetView<Integer> difference = Sets.difference(setA, setB); System.out.println("difference:"); for (Integer integer : difference) System.out.println(integer); //difference 差集:123 Sets.SetView<Integer> intersection = Sets.intersection(setA, setB); System.out.println("intersection:"); for (Integer integer : intersection) System.out.println(integer); //intersection 交集:45
3.3.9、map的交集、并集、差集
HashMap<String, Integer> mapA = Maps.newHashMap(); mapA.put("a", 1); mapA.put("b", 2); mapA.put("c", 3); HashMap<String, Integer> mapB = Maps.newHashMap(); mapB.put("b", 20); mapB.put("c", 3); mapB.put("d", 4); MapDifference differenceMap = Maps.difference(mapA, mapB); // 比较两个Map是否有差异 boolean flag1 = differenceMap.areEqual(); System.out.println("flag1 = " + flag1); // 返回 键相同但是值不同值映射项 Map entriesDiffering = differenceMap.entriesDiffering(); // 返回 键只存在于左边Map的映射项 Map entriesOnlyOnLeft = differenceMap.entriesOnlyOnLeft(); // 返回 键只存在于右边Map的映射项 Map entriesOnlyOnRight = differenceMap.entriesOnlyOnRight(); // 返回 两个map都有的部分(交集) Map entriesInCommon = differenceMap.entriesInCommon(); System.out.println(entriesDiffering); // b=(2, 20) System.out.println(entriesOnlyOnLeft); // a=1 System.out.println(entriesOnlyOnRight); // d=4 System.out.println(entriesInCommon); // c=3
3.3.10、检查参数
String s1 = ""; if (!Strings.isNullOrEmpty(str)) Preconditions.checkArgument(Strings.isNullOrEmpty(str), "参数不能为空: %s", s1);
免去了很多麻烦!并且会使你的代码看上去更好看。而不是代码里面充斥着 !=null
, !=""
注:检查是否为空,不仅仅是字符串类型,其他类型的判断,全部都封装在 Preconditions类里,里面的方法全为静态。
其中的一个方法的源码:
@CanIgnoreReturnValue public static <T> T checkNotNull(T reference) if (reference == null) throw new NullPointerException(); return reference;
方法声明(不包括额外参数) | 描述 | 检查失败时抛出的异常 |
---|---|---|
checkArgument(boolean) | 检查boolean是否为true,用来检查传递给方法的参数。 | IllegalArgumentException |
checkNotNull(T) | 检查value是否为null,该方法直接返回value,因此可以内嵌使用checkNotNull。 | NullPointerException |
checkState(boolean) | 用来检查对象的某些状态。 | IllegalStateException |
checkElementIndex(int index, int size) | 检查index作为索引值对某个列表、字符串或数组是否有效。 index > 0 && index < size | IndexOutOfBoundsException |
checkPositionIndexes(int start, int end, int size) | 检查[start,end]表示的位置范围对某个列表、字符串或数组是否有效 | IndexOutOfBoundsException |
示例演示:
// 检查boolean是否为true,当值为false时,检查失败抛出 IllegalArgumentException boolean status = true; Preconditions.checkArgument(status); // 检查value是否为null,该方法直接返回value,当值为null时,检查抛出NullPointerException;不为空时,返回当前值 String string = null; String newString = Preconditions.checkNotNull(string); System.out.println("newString = " + newString); // 用来检查对象的某些状态,值为false时,抛出异常IllegalStateException Preconditions.checkState(true);
3.3.11、MoreObjects
该方法是在Objects过期后官方推荐使用的替代品,该类最大的好处就是不用大量的重写 toString
,用一种很优雅的方式实现重写,或者在某个场景定制使用。
User user = new User("001", "xxkfz"); String userStr = MoreObjects.toStringHelper("User") .add("userName", user.getUserName()) .toString(); System.out.println("userStr = " + userStr); // userStr = UseruserName=xxkfz
3.3.12、强大的Ordering排序器
排序器[Ordering]是Guava流畅风格比较器[Comparator]的实现,它可以用来为构建复杂的比较器,以完成集合排序的功能。
natural() 对可排序类型做自然排序,如数字按大小,日期按先后排序 usingToString() 按对象的字符串形式做字典排序[lexicographical ordering] from(Comparator) 把给定的Comparator转化为排序器 reverse() 获取语义相反的排序器 nullsFirst() 使用当前排序器,但额外把null值排到最前面。 nullsLast() 使用当前排序器,但额外把null值排到最后面。 compound(Comparator) 合成另一个比较器,以处理当前排序器中的相等情况。 lexicographical() 基于处理类型T的排序器,返回该类型的可迭代对象Iterable<T>的排序器。 onResultOf(Function) 对集合中元素调用Function,再按返回值用当前排序器排序。
User user1 = new User("user1", 14); User user2 = new User("user2", 13); Ordering<User> byOrdering = Ordering.natural() .nullsFirst() .onResultOf(new Function<User, String>() public String apply(User u) return u.getAge().toString(); ); System.out.println("byOrdering.compare(user1, user2) = " + byOrdering.compare(user1, user2)); // user1 的年龄比user2大 所以输出1 //byOrdering.compare(user1, user2) = 1
3.3.13、计算中间代码的运行时间
Stopwatch stopwatch = Stopwatch.createStarted(); for(int i=0; i<100000; i++) // do something long nanos = stopwatch.elapsed(TimeUnit.MILLISECONDS); System.out.println("nanos = " + nanos);
注:TimeUnit 可以指定时间输出精确到多少时间。
3.3.14、guava缓存
guava的缓存设计的比较巧妙,可以很精巧的使用。guava缓存创建分为两种,一种是CacheLoader,另一种则是callback方式。
CacheLoader方式:
LoadingCache<String,String> cahceBuilder=CacheBuilder .newBuilder() .build(new CacheLoader<String, String>() @Override public String load(String key) throws Exception String strProValue="hello "+key+"!"; return strProValue; ); System.out.println(cahceBuilder.apply("begincode")); //hello begincode! System.out.println(cahceBuilder.get("begincode")); //hello begincode! System.out.println(cahceBuilder.get("wen")); //hello wen! System.out.println(cahceBuilder.apply("wen")); //hello wen! System.out.println(cahceBuilder.apply("da"));//hello da! cahceBuilder.put("begin", "code"); System.out.println(cahceBuilder.get("begin")); //code
api中已经把apply声明为过期,声明中推荐使用get方法获取值。
callback方式:
Cache<String, String> cache = CacheBuilder.newBuilder().maximumSize(1000).build(); String resultVal = cache.get("code", new Callable<String>() public String call() String strProValue="begin "+"code"+"!"; return strProValue; ); System.out.println("value : " + resultVal); //value : begin code
如果这篇【文章】对您有帮助,希望大家点赞、评论、关注、收藏;如果对【后端技术】感兴趣的小可爱,也欢迎关注❤️❤️❤️ 公众号【SimpleMemory】❤️❤️❤️,将会继续给大家带来【收获与惊喜】💕💕!
以上是关于Google guava工具类库的介绍和使用的主要内容,如果未能解决你的问题,请参考以下文章