Java-类库-Guava

Posted 2020-08-02 07H_JH

　Guava 是一个 Google 的基于java1.6的类库集合的扩展项目，包括 collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O, 等等. 这些高质量的 API 可以使你的JAVa代码更加优雅，更加简洁，让你工作更加轻松愉悦。下面我们就开启优雅Java编程学习之旅！

　　项目相关信息：

　　官方首页：http://code.google.com/p/guava-libraries
　　官方下载：http://code.google.com/p/guava-libraries/downloads/list
　　官方文档：http://docs.guava-libraries.googlecode.com/git/javadoc
http://www.ostools.net/apidocs/apidoc?api=guava

　　源码包的简单说明：
　　com.google.common.annotations：普通注解类型。
　　com.google.common.base：基本工具类库和接口。
　　com.google.common.cache：缓存工具包，非常简单易用且功能强大的JVM内缓存。
　　com.google.common.collect：带泛型的集合接口扩展和实现，以及工具类，这里你会发现很多好玩的集合。
　　com.google.common.eventbus：发布订阅风格的事件总线。
　　com.google.common.hash： 哈希工具包。
　　com.google.common.io：I/O工具包。
　　com.google.common.math：原始算术类型和超大数的运算工具包。
　　com.google.common.net：网络工具包。
　　com.google.common.primitives：八种原始类型和无符号类型的静态工具包。
　　com.google.common.reflect：反射工具包。
　　com.google.common.util.concurrent：多线程工具包。

　　类库使用手册：

　　一. 基本工具类：让使用Java语言更令人愉悦。

　　1. 使用和避免 null：null 有语言歧义， 会产生令人费解的错误， 反正他总是让人不爽。很多 Guava 的工具类在遇到 null 时会直接拒绝或出错，而不是默默地接受他们。
　　2. 前提条件：更容易的对你的方法进行前提条件的测试。
　　3. 常见的对象方法： 简化了Object常用方法的实现， 如 hashCode() 和 toString()。
　　4. 排序： Guava 强大的 “fluent Comparator”比较器， 提供多关键字排序。
　　5. Throwable类： 简化了异常检查和错误传播。

　　二. 集合类：集合类库是 Guava 对 JDK 集合类的扩展， 这是 Guava 项目最完善和为人所知的部分。

　　1. Immutable collections（不变的集合）： 防御性编程， 不可修改的集合，并且提高了效率。
　　2. New collection types(新集合类型)：JDK collections 没有的一些集合类型，主要有：multisets，multimaps，tables， bidirectional maps等等
　　3. Powerful collection utilities（强大的集合工具类）： java.util.Collections 中未包含的常用操作工具类
　　4. Extension utilities（扩展工具类）: 给 Collection 对象添加一个装饰器? 实现迭代器? 我们可以更容易使用这些方法。

　　三. 缓存: 本地缓存，可以很方便的操作缓存对象，并且支持各种缓存失效行为模式。

　　四. Functional idioms（函数式）: 简洁, Guava实现了Java的函数式编程，可以显著简化代码。

　　五. Concurrency（并发）：强大,简单的抽象,让我们更容易实现简单正确的并发性代码。

　　1. ListenableFuture（可监听的Future）: Futures,用于异步完成的回调。
　　2. Service: 控制事件的启动和关闭，为你管理复杂的状态逻辑。

　　六. Strings: 一个非常非常有用的字符串工具类: 提供 splitting，joining， padding 等操作。

　　七. Primitives: 扩展 JDK 中未提供的对原生类型（如int、char等）的操作， 包括某些类型的无符号的变量。

　　八. Ranges: Guava 一个强大的 API，提供 Comparable 类型的范围处理， 包括连续和离散的情况。

　　九. I/O: 简化 I/O 操作, 特别是对 I/O 流和文件的操作, for Java 5 and 6.

　　十. Hashing: 提供比 Object.hashCode() 更复杂的 hash 方法, 提供 Bloom filters.

　　十一. EventBus: 基于发布-订阅模式的组件通信，但是不需要明确地注册在委托对象中。

　　十二. Math: 优化的 math 工具类，经过完整测试。

　　十三. Reflection: Guava 的 Java 反射机制工具类。、
　　

Optional优雅的使用null

　　在我们学习和使用Guava的Optional之前，我们需要来了解一下Java中null。因为，只有我们深入的了解了null的相关知识，我们才能更加深入体会领悟到Guava的Optional设计和使用上的优雅和简单。

　 null代表不确定的对象：

　　Java中，null是一个关键字，用来标识一个不确定的对象。因此可以将null赋给引用类型变量，但不可以将null赋给基本类型变量。

　　Java中，变量的使用都遵循一个原则：先定义，并且初始化后，才可以使用。例如如下代码中，我们不能定义int age后，不给age指定值，就去打印age的值。这条对对于引用类型变量也是适用的（String name也同样适用），在编译的时候就会提示为初始化。
　

　public class NullTest {
    public static void testNull(){
        int age;
        System.out.println("user age:"+age);

        long money;
        money=10L;
        System.out.println("user money"+money);

        String name;
        System.out.println("user name:"+name);
    }
}

在Java中，Java默认给变量赋值：在定义变量的时候，如果定义后没有给变量赋值，则Java在运行时会自动给变量赋值。赋值原则是整数类型int、byte、short、long的自动赋值为0，带小数点的float、double自动赋值为0.0，boolean的自动赋值为false，其他各供引用类型变量自动赋值为null。上面代码会变为如下可运行代码：

public class NullTest {
    public static void testNull(){
        int age = 0;
        System.out.println("user Age:"+age);

        long money;
        money=10L;
        System.out.println("user money"+money);

        String name = null;
        System.out.println("user name:"+name);
    }
}

null本身不是对象，也不是Objcet的实例：

　　null只是一个关键字，用来标识一个不确定的对象，他既不是对象，也不是Objcet对象的实例。下面我们通过代码确定一下null是不是Object对象实例：

　　public class NullTest {
    public static void main(String[] args) {
        testNullObject();
    }

    public static void testNullObject() {
        if (null instanceof java.lang.Object) {
            System.out.println("null属于java.lang.Object类型");
        } else {
            System.out.println("null不属于java.lang.Object类型");
        }
    }
}

运行上面代码，输出：null不属于java.lang.Object类型，可见，null对象不是Object对象的实例。
null对象的使用：

　　1.常见使用场景：

　　有时候，我们定义一个引用类型变量，在刚开始的时候，无法给出一个确定的值，但是不指定值，程序可能会在try语句块中初始化值。这时候，我们下面使用变量的时候就会报错。这时候，可以先给变量指定一个null值，问题就解决了。例如：

　　 Connection conn = null;
 try {
　　conn = DriverManager.getConnection("url", "user", "password");
 } catch (SQLException e) {
　　 e.printStackTrace();
 }
 String catalog = conn.getCatalog();

2.容器类型与null：
List：允许重复元素，可以加入任意多个null。
Set：不允许重复元素，最多可以加入一个null。
Map：Map的key最多可以加入一个null，value字段没有限制。
数组：基本类型数组，定义后，如果不给定初始值，则java运行时会自动给定值。引用类型数组，不给定初始值，则所有的元素值为null。
3.null的其他作用
1>、判断一个引用类型数据是否null。 用==来判断。
2>、释放内存，让一个非null的引用类型变量指向null。这样这个对象就不再被任何对象应用了。等待JVM垃圾回收机制去回收。
4.null的使用建议：
1>. 在Set或者Map中使用null作为键值指向的value，千万别这么用。很显然，在Set和Map的查询操作中，将null作为特殊的例子可以使查询结果更浅显易懂。
　　2>. 在Map中包含value是null值的键值对，你应该把这种键值对移出map，使用一个独立的Set来包含所有null或者非null的键。很容易混淆的是，一个Map是不是包含value是　null的key，还是说这个Map中没有这样的键值对。最好的办法就是把这类key值分立开来，并且好好想想到底一个value是null的键值对对于你的程序来说到底意味着什么。
　　3>. 在列表中使用null，并且这个列表的数据是稀疏的，或许你最好应该使用一个Map

import com.google.common.base.Optional;

public class OptionalTest {

    public void testOptional() throws Exception { 
        Optional<Integer> possible=Optional.of(6);
        if(possible.isPresent()){
            System.out.println("possible isPresent:"+possible.isPresent());
            System.out.println("possible value:"+possible.get());
        }
    } 
}

由于这些原因，Guava库设计了Optional来解决null的问题。许多Guava的工具被设计成如果有null值存在即刻报错而不是只要上下文接受处理null值就默认使用null值继续运行。而且，Guava提供了Optional等一些工具让你在不得不使用null值的时候，可以更加简便的使用null并帮助你避免直接使用null。

　　Optional的最常用价值在于，例如，假设一个方法返回某一个数据类型，调用这个方法的代码来根据这个方法的返回值来做下一步的动作，若该方法可以返回一个null值表示成功，或者表示失败，在这里看来都是意义含糊的，所以使用Optional作为返回值，则后续代码可以通过isPresent()来判断是否返回了期望的值（原本期望返回null或者返回不为null，其意义不清晰），并且可以使用get()来获得实际的返回值。

　1.常用静态方法：

　　Optional.of(T)：获得一个Optional对象，其内部包含了一个非null的T数据类型实例，若T=null，则立刻报错。
　　Optional.absent()：获得一个Optional对象，其内部包含了空值
　　Optional.fromNullable(T)：将一个T的实例转换为Optional对象，T的实例可以不为空，也可以为空[Optional.fromNullable(null)，和Optional.absent()等价。
　

　import com.google.common.base.Optional;


public class OptionalTest {

    @Test
    public void testOptional() throws Exception { 
        Optional<Integer> possible=Optional.of(6);
        Optional<Integer> absentOpt=Optional.absent();
        Optional<Integer> NullableOpt=Optional.fromNullable(null);
        Optional<Integer> NoNullableOpt=Optional.fromNullable(10);
        if(possible.isPresent()){
            System.out.println("possible isPresent:"+possible.isPresent());
            System.out.println("possible value:"+possible.get());
        }
        if(absentOpt.isPresent()){
            System.out.println("absentOpt isPresent:"+absentOpt.isPresent()); ;
        }
        if(NullableOpt.isPresent()){
            System.out.println("fromNullableOpt isPresent:"+NullableOpt.isPresent()); ;
        }
        if(NoNullableOpt.isPresent()){
            System.out.println("NoNullableOpt isPresent:"+NoNullableOpt.isPresent()); ;
        }
    } 
}

　2.实例方法：

　　1>. boolean isPresent()：如果Optional包含的T实例不为null，则返回true；若T实例为null，返回false
　　2>. T get()：返回Optional包含的T实例，该T实例必须不为空；否则，对包含null的Optional实例调用get()会抛出一个IllegalStateException异常
　　3>. T or(T)：若Optional实例中包含了传入的T的相同实例，返回Optional包含的该T实例，否则返回输入的T实例作为默认值
　　4>. T orNull()：返回Optional实例中包含的非空T实例，如果Optional中包含的是空值，返回null，逆操作是fromNullable()
　　5>. Set asSet()：返回一个不可修改的Set，该Set中包含Optional实例中包含的所有非空存在的T实例，且在该Set中，每个T实例都是单态，如果Optional中没有非空存在的T实例，返回的将是一个空的不可修改的Set。

　　import java.util.Set;
import com.google.common.base.Optional;

public class OptionalTest {

    public void testMethodReturn() {
        Optional<Long> value = method();
        if(value.isPresent()==true){
            System.out.println("获得返回值: " + value.get());     
        }else{

            System.out.println("获得返回值: " + value.or(-12L));    
        }

        System.out.println("获得返回值 orNull: " + value.orNull());

        Optional<Long> valueNoNull = methodNoNull();
        if(valueNoNull.isPresent()==true){
            Set<Long> set=valueNoNull.asSet();
            System.out.println("获得返回值 set 的 size : " + set.size());    
            System.out.println("获得返回值: " + valueNoNull.get());     
        }else{
            System.out.println("获得返回值: " + valueNoNull.or(-12L));    
        }

        System.out.println("获得返回值 orNull: " + valueNoNull.orNull());
    }

    private Optional<Long> method() {
        return Optional.fromNullable(null);
    }
    private Optional<Long> methodNoNull() {
        return Optional.fromNullable(15L);
    }

}

　Optional除了给null值命名所带来的代码可阅读性的提高，最大的好处莫过于Optional是傻瓜式的。Optional对象的使用强迫你去积极的思考这样一种情况，如果你想让你的程序返回null值，这null值代表的含义是什么，因为你想要取得返回值，必然从Optional对象内部去获得，所以你必然会这么去思考。但是只是简单的使用一个Null值会很轻易的让人忘记去思索代码所要表达的含义到底是什么，尽管FindBugs有些帮助，但是我们还是认为它并没有尽可能的解决好帮助程序员去思索null值代表的含义这个问题。
　　这种思考会在你返回某些存在的值或者不存在的值的时候显得特别相关。和其他人一样，你绝对很可能会忘记别人写的方法method(a,b)可能会返回一个null值，就好像当你去写method(a,b)的实现时，你也很可能忘记输入参数a也可以是null。如果返回的是Optional对象，对于调用者来说，就可以忘却怎么去度量null代表的是什么含义，因为他们始终要从optional对象中去获得真正的返回值。