Guava类库学习--只读设置+函数编程+约束条件+集合操作

README：Guava使用了很多匿名内部类，在创建对象的同时重写方法

1.只读设置
在java集合框架中，有时候需要将集合设置为只读，也就是我们不能操作更改集合内元素，如果更改了集合元素就会在运行时出现错误：java.lang.UnsupportedOperationException （不支持功能异常）

在已有的集合下，我们需要新创建一个新的集合，这个集合实现了只读设置，它是对原有list包装，相当于原有list的一个视图

不使用Guava提供的类库及方法 VS 使用Guava
（1 前者代码复杂，后者简单
（2 后者设置更加安全可靠
（3 前者改变原有集合，视图也会随之改变，而后者改变原有集合，视图不发生改变

下面用代码实现只读设置：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import com.google.common.collect.ImmutableList;

public class Demo01 {
    public static void main(String[] args) {

        List<String> list=new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");

        //不使用Guava提供的类库及方法
        List<String> readList=Collections.unmodifiableList(list);
        //readList.add("d"); 运行报错

        //使用Guava
        List<String> imutableList=ImmutableList.of("a","b","c");
        //imutableList.add("a"); 运行报错
    }
}

2.函数式编程+组合式函数编程
Guava对原有容器包含方法进行扩展，使得容器和业务逻辑绑定在一起

函数一：找出集合众的回文字符串，回文又称 mirror word ,backword，是指字符串从前面或者后面读都是一样的，比如moom
Collections2.filter

import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import com.google.common.base.Function;
import com.google.common.base.Functions;
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;

public class Demo02 {
    public static void main(String[] args) {
        // 利用Lists静态初始化
        List<String> list = Lists.newArrayList("dog", "cat", "pig", "moom");

        // 匿名内部类，同时创建对象,Collections2.filter类似过滤器
        Collection<String> palindromeList = Collections2.filter(list,
                new Predicate<String>() {

                    @Override
                    public boolean apply(String input) {
                        // 业务逻辑
                        return new StringBuilder(input).reverse().toString().equals(input);
                    }
                });

        for (String str : palindromeList) {
            System.out.println(str);
        }
    }   
}

输出结果为 ：moom

函数二：Long类型到String型日期的转换
比如：100000000000L——1979-07-05
Collections2.transform

public static void test02(){
        Set<Long> timeSet=Sets.newHashSet();
        timeSet.add(100000000000L);
        timeSet.add(200000000000L);
        timeSet.add(300000000000L);

        //Collections2.transform类型转化
        Collection<String> timeStrCol=Collections2.transform(timeSet, new Function<Long,String>(){

            @Override
            public String apply(Long input) {

                return new SimpleDateFormat("yyyy-MM-dd").format(input);
            }

        });

        for(String str:timeStrCol){
            System.out.print(str+" ");
        }
    }

输出结果：1979-07-05 1973-03-03 1976-05-04

函数三：组合式函数编程，确保容器中的字符串长度不超过5，超过进行截取，全部大写
1）分别编写两个函数，f1-字符串长度不超过5，超过进行截取；f2-全部大写
2）将f1，f2这两个函数组合在一起，如同String =f2(f1(String))
Functions.compose(f1, f2)
3）得到符合要求的List Collections2.transform(list, f)

public static void test03() {

        List<String> list = Lists.newArrayList("happy", "sad", "wahaha");

        // 截取5个字母
        Function<String, String> f1 = new Function<String, String>() {

            @Override
            public String apply(String input) {
                // TODO Auto-generated method stub
                return input.length() > 5 ? input.substring(0, 5) : input;
            }

        };

        // 全部大写
        Function<String, String> f2 = new Function<String, String>() {

            @Override
            public String apply(String input) {
                // TODO Auto-generated method stub
                return input.toUpperCase();
            }

        };

        Function<String, String> f = Functions.compose(f1, f2);

        Collection<String> resultCol = Collections2.transform(list, f);

        for (String str : resultCol) {
            System.out.print(str+" ");
        }
    }

输出结果为 ：HAPPY SAD WAHAH

3.加入约束条件
加入这些约束条件，比如 非空或者有长度限制，这样当你添加不符合条件的元素时，就会报错

import java.util.Set;
import com.google.common.base.Preconditions;
import com.google.common.collect.Constraint;
import com.google.common.collect.Constraints;
import com.google.common.collect.Sets;

public class Demo3 {
    public static void main(String[] args) {
        Set<String> sets = Sets.newHashSet();
        // 创建约束
        Constraint<String> constraint = new Constraint<String>() {

            @Override
            public String checkElement(String element) {
                // 非空验证
                Preconditions.checkNotNull(element);

                // 长度限制 5-20,否则报错
                Preconditions.checkArgument(
                        element.length() >= 5 && element.length() <= 20,
                        element);
                return element;
            }

        };

        Set<String> cs = Constraints.constrainedSet(sets, constraint);

        // cs.add(null); 报错java.lang.NullPointerException
        //cs.add("qaz"); 报错java.lang.IllegalArgumentException: qaz
    }
}

4.集合的操作 ：交集，并集，差集

import java.util.Set;
import com.google.common.collect.Sets;
import com.google.common.collect.Sets.SetView;

public class Demo04 {
    public static void main(String[] args) {
        Set<Integer> sets=Sets.newHashSet(1,2,3,4,5,6);
        Set<Integer> set2=Sets.newHashSet(3,4,5,6,7,8,9);

        //交集
        SetView<Integer> intersection =Sets.intersection(sets, set2);
        for(Integer in:intersection){
            System.out.print(in+" ");
        }
        System.out.println();

        // 差集 sets-set2
        SetView<Integer> intersection2 = Sets.difference(sets, set2);
        for (Integer in : intersection2) {
            System.out.print(in + " ");
        }
        System.out.println();

        // 并集
        SetView<Integer> intersection3 = Sets.union(sets, set2);
        for (Integer in : intersection3) {
            System.out.print(in + " ");
        }

    }
}

输出结果为：
3 4 5 6
1 2
1 2 3 4 5 6 7 8 9