1. Guava是什么？

guava就是类库，是java api的增强与扩展，里面有大量的方法供我们使用，使用之前需要引入包

  1. <dependency>
  2.     <groupId>com.google.guava</groupId>
  3.     <artifactId>guava</artifactId>
  4.     <version>28.2-jre</version>
  5. </dependency>

2. 字符串处理

2.1 joiner

joiner 连接器，将集合里元素组合成一个字符串

  1. public class JoinerTest {
  3.     List<String> list1 = Arrays.asList("google", "baidu", "sohu");
  4.     List<String> list2 = Arrays.asList("aa", "bb", "cc", null);
  5.     Map<Integer, String> map;
  7.     @Test
  8.     public void testJoiner(){
  9.         // list转换成String，以#分隔
  10.         String result = Joiner.on("#").join(list1);
  11.         // 断言
  12.         assertThat(result, equalTo("google#baidu#sohu"));
  13.     }
  15.     @Test
  16.     public void testJoiner2(){
  17.         map = new HashMap<Integer, String>();
  18.         map.put(1, "a");
  19.         map.put(2, "b");
  20.         map.put(3, "c");
  21.         // map转换成String，以#分隔,key和value之间用：分隔
  22.         String result = Joiner.on("#").withKeyValueSeparator(":").join(map);
  23.         System.out.println(result);
  24.         // 断言
  25.         assertThat(result, equalTo("1:a#2:b#3:c"));
  26.     }
  28.     @Test
  29.     public void testJoinerWithNoValue(){
  30.         // list转换成String，以#分隔,跳过空格
  31.         String result = Joiner.on("#").skipNulls().join(list2);
  32.         // 断言
  33.         assertThat(result, equalTo("aa#bb#cc"));
  34.     }
  36.     @Test
  37.     public void testJoinerWithNoValueUseDefaultValue(){
  38.         // list转换成String，以#分隔,遇到null替换成"DEFAULT"
  39.         String result = Joiner.on("#").useForNull("DEFAULT").join(list2);
  40.         // 断言
  41.         assertThat(result, equalTo("aa#bb#cc#DEFAULT"));
  42.     }
  43.     @Test
  44.     public void testJoinerAppenedTo(){
  45.         // list转换成String，以#分隔,遇到null替换成"DEFAULT"
  46.         StringBuilder builder = new StringBuilder();
  47.         StringBuilder resultBuilder = Joiner.on("#").useForNull("DEFAULT").appendTo(builder, list2);
  48.         // 断言 判断同一个实例
  49.         assertThat(resultBuilder, sameInstance(builder));
  50.         assertThat(resultBuilder.toString(), equalTo("aa#bb#cc#DEFAULT"));
  51.         assertThat(builder.toString(), equalTo("aa#bb#cc#DEFAULT"));
  52.     }
  53. }

https://github.com/wangwjt/guava/blob/master/src/test/java/JoinerTest.java

2.2 splitter

splitter拆分

  1. public class SplitterTest {
  3.     /**
  4.      * 分隔字符串
  5.      */
  6.     @Test
  7.     public void testSplitter(){
  8.         // 将字符串按指定字符分割
  9.         List<String> result = Splitter.on("@").splitToList("aa@bb@cc@dd@ee");
  10.         // 断言判断不空
  11.         assertThat(result, notNullValue());
  12.         // 断言判断list长度为5
  13.         assertThat(result.size(), equalTo(5));
  14.         // 断言判断各个元素
  15.         assertThat(result.get(0), equalTo("aa"));
  16.         assertThat(result.get(1), equalTo("bb"));
  17.         assertThat(result.get(2), equalTo("cc"));
  18.         assertThat(result.get(3), equalTo("dd"));
  19.         assertThat(result.get(4), equalTo("ee"));
  20.     }
  22.     /**
  23.      * 分隔字符串（忽略分隔后元素null的情况）
  24.      */
  25.     @Test
  26.     public void testSplitter2(){
  27.         // 将字符串按指定字符分割   omitEmptyStrings()忽略掉null
  28.         List<String> result = Splitter.on("@").omitEmptyStrings().splitToList("aa@bb@cc@dd@ee@@@");
  29.         // 断言判断不空
  30.         assertThat(result, notNullValue());
  31.         // 断言判断list长度为5
  32.         assertThat(result.size(), equalTo(5));
  33.         // 断言判断各个元素
  34.         assertThat(result.get(0), equalTo("aa"));
  35.         assertThat(result.get(1), equalTo("bb"));
  36.         assertThat(result.get(2), equalTo("cc"));
  37.         assertThat(result.get(3), equalTo("dd"));
  38.         assertThat(result.get(4), equalTo("ee"));
  39.     }
  41.     /**
  42.      * 按指定长度截取元素
  43.      */
  44.     @Test
  45.     public void testSplitter3(){
  46.         // 按2位截取放入list
  47.         List<String> list = Splitter.fixedLength(2).splitToList("abcdefg");
  48.         // 断言 判断不空
  49.         assertThat(list, notNullValue());
  50.         // 断言 判断长度
  51.         assertThat(list.size(), equalTo(4));
  52.         // 断言 判断元素
  53.         assertThat(list.get(0), equalTo("ab"));
  54.         assertThat(list.get(1), equalTo("cd"));
  55.         assertThat(list.get(2), equalTo("ef"));
  56.     }
  58.     /**
  59.      * 按指定符号截取
  60.      */
  61.     @Test
  62.     public void testSplitter4(){
  63.         // 按指定符号截取
  64.         List<String> list = Splitter.on("#").limit(3).splitToList("aa#bb#cc#dd#ee#ff#gg");
  65.         // 断言 判断不空
  66.         assertThat(list, notNullValue());
  67.         // 断言 判断长度
  68.         assertThat(list.size(), equalTo(3));
  69.         // 断言 判断元素
  70.         assertThat(list.get(0), equalTo("aa"));
  71.         assertThat(list.get(1), equalTo("bb"));
  72.         assertThat(list.get(2), equalTo("cc#dd#ee#ff#gg"));
  73.     }
  75.     /**
  76.      * 按正则表达式规则截取
  77.      * trimResults()去空格
  78.      * omitEmptyStrings()忽略空
  79.      */
  80.     @Test
  81.     public void testSplitter5(){
  82.         // 按正则表达式截取
  83.         List<String> list = Splitter.onPattern("\\|").trimResults().omitEmptyStrings().splitToList("aa|bb|cc|dd|ee|ff|gg| | ||");
  84.         // 断言 判断不空
  85.         assertThat(list, notNullValue());
  86.         // 断言 判断长度
  87.         assertThat(list.size(), equalTo(7));
  88.     }
  90.     /**
  91.      * 拆出来的放到map里
  92.      */
  93.     @Test
  94.     public void testSplitter6(){
  95.         // 按正则表达式截取
  96.         Map<String, String> map = Splitter.onPattern("\\|").trimResults().omitEmptyStrings().withKeyValueSeparator("=").split("aa=6| |cc=dd|||ff=8|| | ||");
  97.         // 断言 判断不空
  98.         assertThat(map, notNullValue());
  99.         // 断言 判断长度
  100.         assertThat(map.size(), equalTo(3));
  101.     }
  102. }

https://github.com/wangwjt/guava/blob/master/src/test/java/SplitterTest.java

3. 集合

3.1 Lists

  1. public class ListTest {
  3.     /**
  4.      * 使用Lists.newArrayList构造list
  5.      */
  6.     @Test
  7.     public void test1(){
  8.         // 用Lists.newArrayList方式创建对象
  9.         ArrayList<String> list = Lists.newArrayList("aa", "bb");
  10.         System.out.println(list);
  11.     }
  13.     /**
  14.      * 构造笛卡尔积
  15.      */
  16.     @Test
  17.     public void test2(){
  18.         // 构造笛卡尔积
  19.         List<List<String>> lists = Lists.cartesianProduct(Lists.newArrayList("1", "2"),
  20.                 Lists.newArrayList("a", "b"));
  21.         assertThat(lists.toString(), equalTo("[[1, a], [1, b], [2, a], [2, b]]"));
  22.     }
  24.     /**
  25.      * 逆序
  26.      */
  27.     @Test
  28.     public void test3(){
  29.         ArrayList<String> list = Lists.newArrayList("a", "b", "c");
  30.         List<String> reverse = Lists.reverse(list);
  31.         assertThat(reverse.toString(), equalTo("[c, b, a]"));
  32.     }
  34.     /**
  35.      * 分组
  36.      */
  37.     @Test
  38.     public void test4(){
  39.         ArrayList<String> list = Lists.newArrayList("a", "b", "c", "d", "e", "f", "g");
  40.         // 分组
  41.         List<List<String>> partition = Lists.partition(list, 3);
  42.         assertThat(partition.toString(), equalTo("[[a, b, c], [d, e, f], [g]]"));
  43.     }
  44. }

https://github.com/wangwjt/guava/blob/master/src/test/java/ListTest.java

3.2 Sets

  1. public class SetTest {
  3.     @Test
  4.     public void test1(){
  5.         // 创建set
  6.         HashSet<String> set = Sets.newHashSet("1", "2", "3");
  7.         assertThat(set.size(), equalTo(3));
  9.         ArrayList<String> list = Lists.newArrayList("a", "b", "b", "c");
  10.         // 由list数据创建set(去重)
  11.         HashSet<String> set2 = Sets.newHashSet(list);
  12.         assertThat(set2.size(), equalTo(3));
  14.         // 笛卡尔集
  15.         Set<List<String>> set3 = Sets.cartesianProduct(Sets.newHashSet("1", "2"), Sets.newHashSet("1", "3"));
  16.         assertThat(set3.toString(), equalTo("[[1, 1], [1, 3], [2, 1], [2, 3]]"));
  18.         // 产生子集
  19.         HashSet<String> set4 = Sets.newHashSet("1", "2", "3");
  20.         Set<Set<String>> combinations = Sets.combinations(set4, 2);
  21.         /**
  22.          * [1, 2]
  23.          * [1, 3]
  24.          * [2, 3]
  25.          */
  26.         combinations.forEach(System.out::println);
  27.     }
  29.     /**
  30.      * 两个集合的差集
  31.      */
  32.     @Test
  33.     public void test2(){
  34.         HashSet<Integer> set5 = Sets.newHashSet(1, 2, 3);
  35.         HashSet<Integer> set6 = Sets.newHashSet(1, 4, 5);
  36.         // 差集：在set5里不在set6里
  37.         Sets.SetView<Integer> difference = Sets.difference(set5, set6);
  38.         // [2, 3]
  39.         System.out.println(difference);
  40.     }
  42.     /**
  43.      * 两个集合的交集
  44.      */
  45.     @Test
  46.     public void test3(){
  47.         HashSet<Integer> set7 = Sets.newHashSet(1, 2, 3);
  48.         HashSet<Integer> set8 = Sets.newHashSet(1, 4, 5);
  49.         Sets.SetView<Integer> intersection = Sets.intersection(set7, set8);
  50.         // [1]
  51.         System.out.println(intersection);
  52.     }
  54.     /**
  55.      * 两个集合的并集
  56.      */
  57.     @Test
  58.     public void test4(){
  59.         HashSet<Integer> set1 = Sets.newHashSet(1, 2, 3);
  60.         HashSet<Integer> set2 = Sets.newHashSet(1, 4, 5);
  61.         Sets.SetView<Integer> intersection = Sets.union(set1, set2);
  62.         // [1, 2, 3, 4, 5]
  63.         System.out.println(intersection);
  64.     }
  65. }

https://github.com/wangwjt/guava/blob/master/src/test/java/SetTest.java

3.3 MultiMap

特点：key可以相同，保存不同value。
业务场景：当需要构造像Map>或者Map>这样比较复杂的数据结构时，可以采用Multimap

  1. public class MultimapTest {
  4.     /**
  5.      * ArrayListMultimap用法
  6.      * 注意：同一个key下，不同值可以同时存在
  7.      */
  8.     @Test
  9.     public void test1(){
  10.         ArrayListMultimap<Integer, String> map = ArrayListMultimap.create();
  11.         map.put(1, "a");
  12.         map.put(1, "a");
  13.         map.put(1, "b");
  14.         map.put(1, "c");
  15.         map.put(2, "d");
  16.         map.put(3, "d");
  17.         map.put(3, "e");
  18.         // {1=[a, a, b, c], 2=[d], 3=[d, e]}
  19.         System.out.println(map);
  20.     }
  21.     /**
  22.      * HashMultimap用法
  23.      * 注意：同一个key下，不同值"不"可以同时存在
  24.      */
  25.     @Test
  26.     public void test2(){
  27.         HashMultimap<Integer, String> map = HashMultimap.create();
  28.         map.put(1, "a");
  29.         map.put(1, "a");
  30.         map.put(1, "b");
  31.         map.put(1, "c");
  32.         map.put(2, "d");
  33.         map.put(3, "d");
  34.         map.put(3, "e");
  35.         // {1=[a, b, c], 2=[d], 3=[d, e]}
  36.         System.out.println(map);
  37.     }
  38. }

https://github.com/wangwjt/guava/blob/master/src/test/java/MultimapTest.java

未完 待整理