com.google.guava工具（1）

最近花了点时间看了下com.google.guava里面的Guava的API，感觉有些确实比common有些工具好用，也简便。对于里面常用的工具做一个笔记方便以后自己查看（后面会继续）

package cn.gov.zcy.admin;

import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.collect.*;
import com.google.common.primitives.Ints;
import com.sun.istack.internal.Nullable;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import java.util.*;

import static com.google.common.base.Preconditions.*;
import static jdk.nashorn.internal.objects.NativeMath.log;

/**
 * Created by shiwenxue on 16/7/13.
 */
public class GuavaTest {
    private static final DateTimeFormatter DATE_TIME_FORMAT = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss");

    /**
     * Optional傻瓜式防护类
     */
    public void optionalTest() {

        // 创建指定引用的Optional实例，若引用为null则快速失败
        Optional<Integer> possible1 = Optional.of(5);

        // 创建指定引用的Optional实例，若引用为null则表示缺失
        Optional<Integer> possible = Optional.fromNullable(5);

        // 判断引用是否缺失
        boolean present = possible.isPresent();

        // 返回Optional所包含的引用，若引用缺失，则抛出java.lang.IllegalStateException
        Integer num3 = possible.get();

        // or:若引用缺失,返回or(T)中的T,否则返回引用对象
        Integer num2 = possible.or(6);

        // orNull:若引用缺失,返回or(T)中的T,否则返回引用对象
        Integer num = possible.orNull();

        // 返回Optional所包含引用的单例不可变集，如果引用存在，返回一个只有单一元素的集合，如果引用缺失，返回一个空集合。
        Set<Integer> set = possible.asSet();

        System.out.println(set.size());
        System.out.println(num2);
    }

    /**
     * check 静态检查函数
     */
    public void checkArgTest() {

        try {
            String str1 = "sss";
            String str2 = null;

            // 检查参数
            checkArgument(!"".equals(str1), "str is empty");

            // 用来检查对象是否null。
            checkNotNull(str2, "str is null");

            // 用来检查对象的某些状态。
            checkState(!"".equals(str1));

            // 检查指针是否越界
            // checkElementIndex(int index, int size)

            // 检查[start, end]表示的位置范围对某个列表、字符串或数组是否有效*
            // checkPositionIndexes(int start, int end, int size)
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * ComparisonChain 比较链
     */
    public int compareTo(A a1, A a2) {
        return ComparisonChain.start()
                .compare(a1.getGender(), a2.getGender())
                .compare(a1.getName(), a2.getName())
                .result();
    }

    /**
     * Ordering 排序器
     */
    public void orderTest(List<A> aList) {

        // 多重排序组合,从后往前;按照age倒序
        Ordering<A> ordering = Ordering.natural().nullsFirst().onResultOf(new Function<A, Integer>() {
            public Integer apply(A a) {
                return a.getAge();
            }
        });

        // 字符串长度排序:倒序
        Ordering<String> byLengthOrdering = new Ordering<String>() {
            public int compare(String left, String right) {
                return Ints.compare(left.length(), right.length());
            }
        };

        // 字符串长度排序-->取名字排序
        Ordering<A> byLengthOrdering2 = new Ordering<A>() {
            public int compare(A left, A right) {
                return Ints.compare(left.getName().length(), right.getName().length());
            }
        };

        // 获取排序结果
        List<A> result = byLengthOrdering2.greatestOf(aList.iterator(), aList.size());

        // 获取排序后的前2个结果
        List<A> result2 = ordering.greatestOf(aList.iterator(), 2);

        // 返回排序结果最小的那个(按名字)
        A aa = byLengthOrdering2.min(aList.iterator());

        // 判断是否准确排序
        // boolean is = ordering.isOrdered((Iterable<A>) aList.iterator());
    }

    /**
     * ImmutableList:不可变集合
     */
    public void immutableCollectionTest() {
        List<String> temp = new ArrayList<>();
        temp.add("m");
        temp.add("n");

        // 获取不可变集合,下面三种效果相似
        List<String> list = ImmutableList.<String>builder().addAll(temp).build();
        List<String> list2 = ImmutableList.copyOf(temp);