Guava

淩亂°似流年 2023-06-27 05:54 14阅读 0赞

> [https://github.com/google/guava][https_github.com_google_guava]

<dependency>
 <groupId>com.google.guava</groupId>
 <artifactId>guava</artifactId>
 <version>28.0-jre</version>
 </dependency>

--------------------

# 1 使用和避免null #

> 大多数情况下，使用null表明的是某种缺失情况
> 
> Guava引入 Optional<T>表明可能为null的T类型引用，Optional实例可能包含非null的引用（引用存在），也可能什么也不包括（引用缺失）
> 
> 正是受到Guava的启发，Java**8**将Optional类做为一个新特性引入进Java8的类库

## 1.1 学习Java8中的Optional使用方法 ##

import java.util.Optional;

/**
 * 三种创建Optional对象方式
 */
 // 1.创建空的Optional对象
 Optional<Object> optional1 = Optional.empty();
 // 2.使用非null值创建Optional对象
 Optional<String> optional2 = Optional.of("蔡徐坤");
 // 3.使用任意值创建Optional对象
 Optional optional3 = Optional.ofNullable("乔碧萝");

Optional optional = Optional.ofNullable("蔡徐坤");
    /**
     * 判断是否引用缺失的方法(建议不直接使用)
     */
    boolean isNull = optional.isPresent();
    /**
     * 当optional引用存在时执行
     * 类似的方法：map filter flatMap
     */
    optional.ifPresent(System.out::println);

Optional optional = Optional.empty();
    /**
     * 当optional引用缺失时执行
     */
    // 1.引用缺失时的替换值
    Object obj1 = optional.orElse("引用缺失");
    System.out.println(obj1);
    
    // 2.自定义引用缺失时的返回值
    Object obj2 = optional.orElseGet(() -> {
        return "自定义引用缺失";
    });
    System.out.println(obj2);
    
    // 3.抛出异常
    Object obj3 = optional.orElseThrow(() -> {
        throw new RuntimeException("引用缺失异常");
    });

public static void stream(List<String> list) {
 // list.stream().forEach(System.out::println);
 Optional.ofNullable(list)
 .map(List::stream)
 //创建一个空的流
 .orElseGet(Stream::empty)
 .forEach(System.out::println);
 
 }
 public static void main(String[] args) {
 List<String> list = new ArrayList(){
 {
 add("蔡徐坤");
 add("乔碧萝");
 add("卢本伟");
 }};
 stream(list);
 //stream(null);
 }

@Data
    class User {
        private String id;
        private String name;
        public User(){}
        public User(String id,String name){this.id=id;this.name=name;}
    }
    
    public class OptionalTest {
        public static void main(String[] args) {
            User user = new User();
            user.setName("蔡徐坤");
            user  = null;
            String name = Optional.ofNullable(user).map(User::getName).orElse("默认值");
            System.out.println(name);
        }
    }

--------------------

# 2 不可变集合 #

>  *  创建对象的不可变拷贝是一项很好的防御性编程技巧
>  *  Guava为所有JDK标准集合类型和Guava新集合类型都提供了简单易用的不可变版本

## 2.1 不可变对象的优点 ##

> 1.  当对象被不可信的库调用时，不可变形式是安全的
> 2.  不可变对象被多个线程调用时，不存在竞态条件问题
> 3.  不可变集合不需要考虑变化，因此可以节省时间和空间
> 4.  不可变对象因为有固定不变，可以作为常量来安全使用

## 2.2 JDK提供的unmodifiableXxx方法 ##

> 1.  笨重而且累赘
> 2.  不安全
> 3.  低效

public static void test(List<Integer> list) {
 list.remove(0);
 }
 public static void main(String[] args) {
 List<Integer> list = new ArrayList<Integer>() {
 {
 add(1);
 add(2);
 add(3);
 }};
 //创建不可变集合
 List<Integer> newList = Collections.unmodifiableList(list);
 test(newList);
 System.out.println(newList);
 }

> Exception in thread "main" java.lang.UnsupportedOperationException  
>     at java.util.Collections$UnmodifiableList.remove(Collections.java:1317)  
>     at com.imooc.zhangxiaoxi.guava.ImmutableTest.test(ImmutableTest.java:16)  
>     at com.imooc.zhangxiaoxi.guava.ImmutableTest.main(ImmutableTest.java:26)

## 2.3 Guava构造不可变集合对象 ##

import com.google.common.collect.ImmutableSet;
    import com.google.common.collect.Sets;

List<Integer> list = new ArrayList<Integer>() {
 {
 add(1);
 add(2);
 add(3);
 }};
 // 1.通过已经存在的集合创建
 ImmutableSet<Integer> immutable = ImmutableSet.copyOf(list);

// 2.通过初始值，直接创建不可变集合
    ImmutableSet immutableSet = ImmutableSet.of(1, 2, 3);

// 3.以builder方式创建
    ImmutableSet.builder()
            .add(1)
            .addAll(Sets.newHashSet(2, 3))
            .add(4)
            .build();

List<Integer> list = new ArrayList<Integer>() {
 {
 add(1);
 add(2);
 add(3);
 }};
 ImmutableSet<Integer> immutableList = ImmutableSet.copyOf(list);
 //immutableList里面的添加删除方法时不支持的
 for (Integer num : immutableList) {
 System.out.println(num);
 }

--------------------

# 3 新集合类型 #

> Guava引入了很多JDK没有的、但明显有用的新集合类型。这些新类型是为了和JDK集合框架共存，而没有往JDK集合抽象中硬塞其他概念。

## 3.1 Multiset ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

### 3.1.1 Multiset两种视角   ###

> 没有元素顺序限制的ArrayList(E)

![20200104115729175.png][]

>  Map<E, Integer> ，键为元素，值为计数

![20200104120007907.png][]

### 3.1.2 Multiset与Map的区别 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1][]

### 3.1.3 多种Multiset的实现 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2][]

### 3.1.4 Coding ###

import com.google.common.collect.HashMultiset;
 import com.google.common.collect.Multiset;
 import com.google.common.primitives.Chars;
 import org.junit.Test;
 import java.util.Arrays;
 /**
 * 实现：使用Multiset统计一首古诗的文字出现频率
 */
 public class MultisetTest {
 private static final String text =
 "《南陵别儿童入京》" +
 "白酒新熟山中归，黄鸡啄黍秋正肥。" +
 "呼童烹鸡酌白酒，儿女嬉笑牵人衣。" +
 "高歌取醉欲自慰，起舞落日争光辉。" +
 "游说万乘苦不早，著鞭跨马涉远道。" +
 "会稽愚妇轻买臣，余亦辞家西入秦。" +
 "仰天大笑出门去，我辈岂是蓬蒿人。";
 @Test
 public void handle() {
 // multiset创建
 Multiset<Character> multiset = HashMultiset.create();
 // string 转换成 char 数组
 char[] chars = text.toCharArray();
 System.out.println(Arrays.toString(chars));
 // 遍历数组，添加到multiset中
 //multiset.addAll(Chars.asList(chars));
 Chars.asList(chars)
 .stream()
 .forEach(charItem -> {
 multiset.add(charItem);
 });
 System.out.println("size : " + multiset.size());
 System.out.println("count : " + multiset.count('人'));
 }
 }

--------------------

# 4 集合工具类 #

import com.alibaba.fastjson.JSON;
    import com.google.common.collect.Lists;
    import com.google.common.collect.Sets;
    import org.junit.Test;

## 4.1 Sets的使用  ##

private static final Set set1 = Sets.newHashSet(1, 2, 3, 4, 5);
    private static final Set set2 = Sets.newHashSet(4, 5, 6, 7, 8);

### 4.1.1 并集 ###

// 并集
 @Test
 public void union() {
 Set<Integer> set = Sets.union(set1, set2);
 //[1, 2, 3, 4, 5, 6, 7, 8]
 System.out.println(set.stream().sorted().collect(Collectors.toList()));
 }

### 4.1.2 交集 ###

// 交集
 @Test
 public void intersection() {
 Set<Integer> set = Sets.intersection(set1, set2);
 //[4, 5]
 System.out.println(set.stream().sorted().collect(Collectors.toList()));
 }

### 4.1.3 差集 ###

@Test
 public void difference() {
 // 差集：如果元素属于A而且不属于B
 Set<Integer> set = Sets.difference(set1, set2);
 //[1, 2, 3]
 System.out.println(set.stream().sorted().collect(Collectors.toList()));
 }

@Test
 public void difference() {
 // 相对差集：属于A而且不属于B 或者 属于B而且不属于A
 // 两个集合之和-两个集合的交集
 Set<Integer> set = Sets.symmetricDifference(set1, set2);
 //[1, 2, 3, 6, 7, 8]
 System.out.println(set.stream().sorted().collect(Collectors.toList()));
 }

### 4.1.4 分解集合中的所有子集 ###

private static final Set set1 = Sets.newHashSet(1, 2);

// 拆分所有子集合
 @Test
 public void powerSet() {
 Set<Set<Integer>> powerSet = Sets.powerSet(set1);
 //[[],[1],[2],[1,2]]
 System.out.println(JSON.toJSONString(powerSet));
 }

### 4.1.5 计算两个集合笛卡尔积 ###

private static final Set set1 = Sets.newHashSet(1, 2);
    private static final Set set2 = Sets.newHashSet(4);

// 计算两个集合笛卡尔积
 @Test
 public void cartesianProduct() {
 Set<List<Integer>> product = Sets.cartesianProduct(set1, set2);
 //[[1,4],[2,4]]
 System.out.println(JSON.toJSONString(product));
 }

## 4.2 Lists的使用 ##

### 4.2.1 拆分 ###

/**
 * 拆分
 */
 @Test
 public void partition() {
 List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7);
 //拆分成3个3个一组
 List<List<Integer>> partition = Lists.partition(list, 3);
 //[[1,2,3],[4,5,6],[7]]
 System.out.println(JSON.toJSONString(partition));
 }

### 4.2.2 反转 ###

// 反转
 @Test
 public void reverse() {
 List<Integer> list = Lists.newLinkedList();
 list.add(1);
 list.add(2);
 list.add(3);
 List<Integer> newList = Lists.reverse(list);
 //[3, 2, 1]
 System.out.println(newList);
 }

--------------------

# 5 I/O #

# 5.1 对字节流/字符流提供的工具方法 #

![20200104124729642.png][]

> 需要手动关闭流

## 5.2 对源（Source）与汇（Sink）的抽象 ##

![20200104124841362.png][]

> 不需要手动关闭流

## 5.3 Coding ##

import com.google.common.base.Charsets;
    import com.google.common.io.CharSink;
    import com.google.common.io.CharSource;
    import com.google.common.io.Files;
    import org.junit.Test;
    import java.io.File;
    import java.io.IOException;

/**
     * 演示如何使用流(Source)与汇(Sink)来对文件进行常用操作
     */
    public class IOTest {
        @Test
        public void copyFile() throws IOException {
            /**
             * 创建对应的Source和Sink
             */
            CharSource charSource = Files.asCharSource(new File("SourceText.txt"), Charsets.UTF_8);
            CharSink charSink = Files.asCharSink(new File("TargetText.txt"), Charsets.UTF_8);
            /**
             * 拷贝
             */
            charSource.copyTo(charSink);
        }
    }

--------------------

# 6 异常工具类 #

## 6.1 获得字符串类型的堆栈信息 ##

public class ExceptionStackTest {
        public static void main(String[] args) {
            try {
                controller();
            } catch (Throwable e) {
                String stackTrace = Throwables.getStackTraceAsString(e);
                System.out.println(stackTrace);
            }
        }
        private static void controller() {
            service();
        }
        private static void service() {
            dao();
        }
        private static void dao() {
            int a = 1 / 0;
        }
    }
    //java.lang.ArithmeticException: / by zero
    //	at cn.yuanyu.guava.ExceptionStackTest.dao(ExceptionStackTest.java:24)
    //	at cn.yuanyu.guava.ExceptionStackTest.service(ExceptionStackTest.java:21)
    //	at cn.yuanyu.guava.ExceptionStackTest.controller(ExceptionStackTest.java:18)
    //	at cn.yuanyu.guava.ExceptionStackTest.main(ExceptionStackTest.java:11)

--------------------

# 7 字符串处理 #

## 7.1 连接器\[Joiner\] ##

ArrayList<Integer> userIdList = Lists.newArrayList(1, 2, null, 4, 5);
 Joiner joiner = Joiner.on(",")
 //.useForNull("") // null值用什么替换
 .skipNulls() // 跳过null值
 ;
 String jsonStr = joiner.join(userIdList);
 
 System.out.println(jsonStr); //1,2,4,5

注意Joiner连接对象类型，它会把对象的toString()值连接起来

@Data
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
 public class User {
 private Integer userId;
 private String name;
 }
 
 ArrayList<User> userIdList = Lists.newArrayList(
 User.builder().userId(null).name("张三").build(),
 User.builder().userId(2).name("李四").build(),
 User.builder().userId(3).name("王五").build()
 );
 Joiner joiner = Joiner.on(",").skipNulls();
 String jsonStr = joiner.join(userIdList);
 String jsonStr2 = joiner.join(userIdList.stream().map(User::getUserId).collect(Collectors.toList()));
 
 System.out.println(jsonStr); // User(userId=null, name=张三),User(userId=2, name=李四),User(userId=3, name=王五)
 System.out.println(jsonStr2); // 2,3

## 7.2 拆分器\[Splitter\] ##

/**
     * String.split悄悄丢弃了尾部的分隔符
     */
    String str = ",a,,b,";
    System.out.println(Arrays.toString(str.split(",")));  // [, a, , b]
    System.out.println(Splitter.on(',').splitToList(str));      // [, a, , b, ]

**拆分器工厂**

<table> 
 <tbody> 
 <tr> 
 <td>方法</td> 
 <td style="width:382px;">描述</td> 
 <td style="width:136px;">范例</td> 
 </tr> 
 <tr> 
 <td>Splitter.on(char)</td> 
 <td style="width:382px;">按单个字符拆分</td> 
 <td style="width:136px;"> Splitter.on(";").splitToList("1;2;3") &nbsp;// [1, 2, 3] </td> 
 </tr> 
 <tr> 
 <td>Splitter.on(String)</td> 
 <td style="width:382px;">按字符串拆分</td> 
 <td style="width:136px;"> Splitter.on("_,_").splitToList("1_,_2_,_3") // [1, 2, 3] </td> 
 </tr> 
 <tr> 
 <td>Splitter.on(Pattern) Splitter.onPattern(String)</td> 
 <td style="width:382px;">按正则表达式拆分</td> 
 <td style="width:136px;"> Splitter.onPattern("\r\n").splitToList("ab\r\nc") // [ab, c] </td> 
 </tr> 
 <tr> 
 <td>Splitter.fixedLength(int)</td> 
 <td style="width:382px;">按固定长度拆分，最后一段可能比给定长度短，但不会为空</td> 
 <td style="width:136px;"> Splitter.fixedLength(3).splitToList("123456789") // [123, 456, 789] </td> 
 </tr> 
 <tr> 
 <td>Splitter.on(CharMatcher)</td> 
 <td style="width:382px;">按字符匹配器拆分</td> 
 <td style="width:136px;">Splitter.on(CharMatcher.BREAKING_WHITESPACE)</td> 
 </tr> 
 </tbody> 
</table>

**拆分器修饰符**

<table> 
 <tbody> 
 <tr> 
 <td style="width:158px;">方法</td> 
 <td style="width:172px;">描述</td> 
 <td style="width:339px;">范例</td> 
 </tr> 
 <tr> 
 <td style="width:158px;">omitEmptyStrings()</td> 
 <td style="width:172px;">从结果中自动忽略空字符串</td> 
 <td style="width:339px;"> Splitter.on(",").splitToList("1,2,3,,4") // [1, 2, 3, , 4] Splitter.on(",").omitEmptyStrings().splitToList("1,2,3,,4") // [1, 2, 3, 4] </td> 
 </tr> 
 <tr> 
 <td style="width:158px;">trimResults()</td> 
 <td style="width:172px;">移除结果字符串的前导空白和尾部空白</td> 
 <td style="width:339px;"> Splitter.on(",").splitToList("1,2, &nbsp; 3,4") // [1, 2, &nbsp; &nbsp;3, 4] Splitter.on(",").trimResults().splitToList("1,2, 3,4") // [1, 2, 3, 4] </td> 
 </tr> 
 <tr> 
 <td style="width:158px;">limit(int)</td> 
 <td style="width:172px;">限制拆分出的字符串数量</td> 
 <td style="width:339px;"> List&lt;String&gt; splitList = Splitter.on(",").limit(3).splitToList("12345,6,7,8"); splitList.forEach(System.out::println); //12345 //6 //7,8 </td> 
 </tr> 
 <tr> 
 <td style="width:158px;">trimResults(CharMatcher)</td> 
 <td style="width:172px;">给定匹配器，移除结果字符串的前导匹配字符和尾部匹配字符</td> 
 <td style="width:339px;"></td> 
 </tr> 
 </tbody> 
</table>

String str = "foo,bar , ,qux,";
 Arrays.stream(str.split(",")).forEach(item -> {
 System.out.println(item.length() + ":" + item);
 });
 System.out.println("-------------------- jdk --------------------");
 
 List<String> iterator = Splitter.on(',')
 .trimResults() // 每个结果trim一下
 .omitEmptyStrings() // 忽略空字符
 .splitToList(str); // 切分成List split splitToList splitToStream
 iterator.forEach(item -> {
 System.out.println(item.length() + ":" + item);
 });
 System.out.println("-------------------- guava --------------------");
 //3:foo
 //4:bar 
 //2: 
 //3:qux
 //-------------------- jdk --------------------
 //3:foo
 //3:bar
 //3:qux
 //-------------------- guava --------------------

String input = "hello=HELLO| world=WORLD|||";
 Map<String,String> result = Splitter.on(Pattern.compile("\\|"))
 .trimResults() // 去掉非空字符串两端的空格
 .omitEmptyStrings() // 去掉空字符串
 .withKeyValueSeparator("=") // map中的key-value分隔符
 .split(input);
 
 System.out.println(result); // {hello=HELLO, world=WORLD}

> [https://www.jianshu.com/p/f529a5d7d914][https_www.jianshu.com_p_f529a5d7d914]
> 
> [https://www.jinnianshizhunian.vip/790.html][https_www.jinnianshizhunian.vip_790.html]

[https_github.com_google_guava]: https://github.com/google/guava
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200104115301714.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20200104115729175.png]: https://img-blog.csdnimg.cn/20200104115729175.png
[20200104120007907.png]: https://img-blog.csdnimg.cn/20200104120007907.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200104120252640.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200104120446971.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[20200104124729642.png]: https://img-blog.csdnimg.cn/20200104124729642.png
[20200104124841362.png]: https://img-blog.csdnimg.cn/20200104124841362.png
[https_www.jianshu.com_p_f529a5d7d914]: https://www.jianshu.com/p/f529a5d7d914
[https_www.jinnianshizhunian.vip_790.html]: https://www.jinnianshizhunian.vip/790.html