guava之只读、函数式编程(过滤 转换 约束)、集合与apacheJAVA134-135

来源：http://www.bjsxt.com/
1、S02E134_01guava与apache的准备工作(jar src doc)与git工具
（1）

（2）Apache Commons Collections
——Commons-Collections：提供一个类包来扩展和增加标准的Java Collection框架，处理数据灵活
——下载地址：http://commons.apache.org/collections/
————MapIterator：很好用，以后不用map.keyset.iterator去处理map循环了
——HashedMap
————BidiMap：用于通过value查找key
——TreeBidiMap
————Bag：用于在集合中保存一个对象的多次拷贝
——HashBag
————Queue：用于处理FIFO等定义好移除顺序的集合类
————CollectionUtils：工具类
————Predicate：用来评估某个判别式或者条件，进行筛选，可以将其理解为对if条件的一种封装，该接口的唯一方法evaluate()返回true或false
————Transformer：用来将一个对象作为参数，返回一个经过转换处理后的新的对象
————Closure：闭包，封装功能，实现解耦
2、S02E135_01guava之只读、函数式编程(过滤 转换 约束)、集合

package com.test.guava;

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

import com.google.common.collect.ImmutableList;
/**
 * 只读设置
 */
public class TestGuavaReadOnly {

    public static void main(String[] args) {
        testJavaList();
        testImmutableList();
    }
    public static void testJavaList(){
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        //对原有的list进行包装，相当于原有list的一个视图或快照，不够安全
        List<String> readList = Collections.unmodifiableList(list);
        //readList.add("d");//java.lang.UnsupportedOperationException
        System.out.println(readList.size());//返回3
        list.add("d");//改变原有list，视图readList也一起改变
        System.out.println(readList.size());//返回4
    }
    public static void testImmutableList(){
        List<String> immutableList =  ImmutableList.of("a","b","c");
        //immutableList.add("d");//java.lang.UnsupportedOperationException
        System.out.println(immutableList.size());//返回3
    }
}

package com.test.guava;

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;
/**
 * 函数式编程：解耦
 * 1、Predicate
 * 2、Function
 */
public class TestGuavaFun {

    public static void main(String[] args) {
        testFilter();
        testTransform();
        testCompose();
    }
    /**
     * Collections2.filter() 过滤器
     */
    public static void testFilter(){
        //创建List 静态初始化
        List<String> list = Lists.newArrayList("moom","son","dad","abc","refer");
        //找出回文palindrome backwords mirrorwords
        Collection<String> palindromeList = Collections2
                .filter(list, new Predicate<String>(){

                    @Override
                    public boolean apply(String input) {
                        //业务逻辑
                        return new StringBuffer(input).reverse().toString().equals(input);
                    }
                }
        );
        System.out.println("过滤器：留下回文");
        System.out.println(palindromeList);//[moom, dad, refer]     
    }
    /**
     * Collections2.transform() 转换
     */
    public static void testTransform(){
        Set<Long> timeSet = Sets.newHashSet();
        timeSet.add(1000000000000L);
        timeSet.add(99999999999999999L);
        timeSet.add(8888888888888888888L);
        //类型转换 
        Collection<String> timeStrCol = Collections2
                .transform(timeSet, new Function<Long, String>() {

                    @Override
                    public String apply(Long input) {
                        return new SimpleDateFormat("yyyy-MM-dd").format(input);
                    }
                }
        );
        System.out.println("类型转换：Long转为日期格式");
        System.out.println(timeStrCol);//[281679645-08-13, 2001-09-09, 3170843-11-07]
    }
    /**
     * //Functions.compose() 组合式函数
     */
    public static void testCompose(){
        //确保容器中的字符串长度不超过5，超过进行截取，后全部大写
        List<String> list = Lists.newArrayList("abcde","good","happiness");
        //确保容器中的字符串长度不超过5，超过进行截取
        Function<String,String> f1 = new Function<String,String>(){
            @Override
            public String apply(String input) {
                return input.length()>5 ? input.substring(0,5) : input;
            }
        };
        //转为大写
        Function<String,String> f2 = new Function<String,String>(){
            @Override
            public String apply(String input) {
                return input.toUpperCase();
            }
        };
        //组合 String = f2(f1(String))
        Function<String, String> f = Functions.compose(f1, f2);
        Collection<String> resultCol = Collections2.transform(list, f);
        System.out.println("组合式函数：先判断截取后全转大写");
        System.out.println(resultCol);//[ABCDE, GOOD, HAPPI]
    }
}

Guava18.0中Constraint不可用

package com.test.guava;

import java.util.Set;

import com.google.common.collect.Sets;
import com.google.common.collect.Sets.SetView;
/**
 * 集合的操作：交集、差集、并集
 * Sets.intersection()
 * Sets.difference()
 * Sets.union()
 */
public class TestGuavaSet {

    public static void main(String[] args) {
        Set<Integer> set1 = Sets.newHashSet(1,2,3,4,5,6);
        Set<Integer> set2 = Sets.newHashSet(3,4,5,6,7,8);
        //交集
        System.out.println("交集为：");
        SetView<Integer> intersection = Sets.intersection(set1, set2);
        System.out.println(intersection);//[3, 4, 5, 6]
        //差集
        System.out.println("差集为：");
        SetView<Integer> diff = Sets.difference(set1, set2);
        //返回不包含set2元素的set1子集
        System.out.println(diff);//[1, 2]
        //并集
        System.out.println("并集为：");
        SetView<Integer> union = Sets.union(set1, set2);
        System.out.println(union);//[1, 2, 3, 4, 5, 6, 8, 7]
    }
}