Google Guava工具包使用

一个很肥的肥仔
2,535 阅读4分钟

Guava 是什么

Guava是一组来自Google的核心Java库，其中包括新的集合类型（如multimap和multiset）、不可变集合、图形库和用于并发、I/O、哈希、缓存、原语、字符串等的实用程序！它被广泛应用于Google中的大多数Java项目，也被许多其他公司广泛使用。 （GitHub搬来的解释）说白了就是个工具包

guava 使用

  1. 避免null(Optional)
package gom.gc.guoshicheng.lambda.guava;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

/**
 * 学习Java8中的Optional
 */
public class OptionalTest {

    @Test
    public void test() throws Throwable {

        /**
         * 三种创建Optional对象方式
         */
        //创建空的Optional对象
        Optional.empty();

        //使用非null值创建Optional对象
        Optional.of("guoacheng");

        //使用任意值创建Optional对象
        Optional o = Optional.ofNullable(null);

        /**
         * 判断是否引用缺失的方法(建议不直接使用)
         */
        o.isPresent();

        /**
         * 当optional引用存在时执行
         * 类似的方法： map filter flatMap
         */
        o.ifPresent(System.out::println);

        /**
         * 当optional引用缺失时执行
         */
        o.orElse("引用缺失");
        o.orElseGet(() -> {
            //自定义引用缺失时的返回值
            return "自定义引用缺失";
        });
        o.orElseThrow(() -> {
            throw new RuntimeException("引用缺失异常");
        });

    }

    public static void stream(List<String> list) {
        //一般使用 不判空会报错
        list.stream().forEach(System.out::println);

        //使用optional
        Optional.ofNullable(list)
                .map(List::stream)
                .orElseGet(Stream:: empty)
                .forEach(System.out::println);
    }

    public static void main(String[] args) {
        OptionalTest.stream(new ArrayList<String>());
    }
}
  1. 不可变集合 Immutable
package gom.gc.guoshicheng.lambda.guava;

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

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

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

    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);
            }
        };
        test(list);
        //输出结果集合被改变
        System.out.println(list);

        //2、jdk创建不可变集合 这样比较繁琐 1、创建集合 2、使用Collections包装 3、然后再使用返回的这个集合
        List<Integer> nwwList = Collections.unmodifiableList(list);
    }
    public void immutable(){
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        /**
         * 构造不可变集合对象三种方式
         */
        //通过已经存在的集合创建
        ImmutableSet<Integer> integers = ImmutableSet.copyOf(list);

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

        //以builder方式创建
        ImmutableSet<Object> build = ImmutableSet.builder()
                .add(1)
                .addAll(Sets.newHashSet(2, 3))
                .add(4)
                .build();
        //你可以试下 执行add 等改变集合的操作就不可用了


    }
}
  1. 新集合类型
package gom.gc.guoshicheng.lambda.guava;

import com.google.common.collect.HashMultiset;
import com.google.common.primitives.Chars;
import org.junit.Test;

/**
 * 没有元素顺序限制的ArrayList(E)
 * 实现：使用Multiset统计一段的文字出现频率
 */
public class MultisetTest {

    private static final String text =
            "java" +
                    "java" +
                    "java" +
                    "c#" +
                    "c#" +
                    "c#" +
                    "python" +
                    "python" +
                    "python" +
                    "java" +
                    "java";

    @Test
    public void handle() {
        //multiset创建
        HashMultiset<Character> objects = HashMultiset.create();

        //String 转换成 char数组
        char[] chars = text.toCharArray();

        //遍历数组，添加到multiset中
        Chars.asList(chars)
                .stream()
                .forEach(charItem ->{
                    objects.add(charItem);
                });
        System.out.println("Size : "+ objects.size());
        System.out.println("Count : "+ objects.count("java"));
    }

}
  1. 集合工具类使用
package gom.gc.guoshicheng.lambda.guava;

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

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

/**
 * Lists / Sets 使用
 */
public class SetsAndListsTest {

    /**
     * Sets 工具类的常用方法
     * 并集 /交集 /差集 /分解集合中所有的子集 /  求两个集合的笛卡尔积
     * <p>
     * Lists 工具类的常用方式
     * 反转/拆分
     */
    private static final Set set1 =
            Sets.newHashSet(4, 5, 6);
    private static final Set set2 =
            Sets.newHashSet(1, 2, 3);

    /**
     * 并集
     */
    @Test
    public void union() {
        Set<Integer> set = Sets.union(set1, set2);
        System.out.println(set);
    }

    /**
     * 交集
     */
    @Test
    public void intersection() {
        Set<Integer> set = Sets.intersection(set1, set2);
        System.out.println(set);
    }

    /**
     * 差集： 如果元素属于A而且不属于B
     */
    @Test
    public void difference(){
        Set<Integer> set = Sets.difference(set1,set2);
        System.out.println(set);

        //相对差集： 属于A而且不属于B 或者 属于B而且不属于A
        set = Sets.symmetricDifference(set1,set2);

        System.out.println(set);
    }

    /**
     * 拆分所有子集合
     */
    @Test
    public void powerSet(){
        Set<Set<Integer>> powerSet = Sets.powerSet(set1);
        System.out.println(powerSet);
    }

    /**
     * 计算两个集合的笛卡尔积
     */
    @Test
    public void cartesianProduct(){
        Set<List<Integer>> set = Sets.cartesianProduct(set1, set2);
        System.out.println(set);
    }    /**
     * 拆分
     */
    @Test
    public void partition(){
        ArrayList<Integer> integers = Lists.newArrayList(1, 2, 3, 4);
        List<List<Integer>> partition = Lists.partition(integers, 3);
        System.out.println(partition);
    }

    @Test
    public void reverse(){
        LinkedList<Integer> linkedList = Lists.newLinkedList();
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        List<Integer> reverse = Lists.reverse(linkedList);
        System.out.println(reverse);
    }
}
  1. IO操作
package gom.gc.guoshicheng.lambda.guava;

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 java.io.File;
import java.io.IOException;

/**
 * 演示如何使用流(Source)与汇(Sink) 来对文件进行常用操作
 */
public class IOTest {
    public void copyFile() throws IOException {
        CharSource charSource = Files.asCharSource(
                new File("SourceTest.txt"),
                Charsets.UTF_8
        );

        CharSink charSink = Files.asCharSink(
                new File("TargetText.txt"),
                Charsets.UTF_8
        );

        /**
         * 拷贝
         */
        long l = charSource.copyTo(charSink);

        //Files 还有很多操作如
        Files.isDirectory(); //是否是文件夹
        Files.createTempDir();//创建一个临时文件
    }
}

guava 还有很多操作自己研究吧

guava git地址 github.com/google/guav…

avatar
文章
阅读
粉丝