guava之只读、函数式编程(过滤、转换、组合 ）、约束和集合

guava之只读

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<>();
        list.add("a");
        list.add("b");
        list.add("c");

        List<String> readlist = Collections.unmodifiableList(list);
        readlist.add("d");
        list.add("d");   //改变原有list 并不会被只读报错

        //对比,这样就算原有list也可以添加元素，保证了视图的不变形
        List<String> immutablelist = ImmutableList.of("a","b","c");
        //immutablelist.add("d");-->java.lang.UnsupportedOperationException
    }
}

函数式编程(过滤、转换、组合 ）

使用Lists.transform可以轻松完成从一种类型的到另一种类型的转换。

List<Integer> intList = Lists.newArrayList(1000000, 200000);
List<Integer> intList1 = Lists.transform(intList, new Function<Integer, Integer>() {
    public Integer apply(Integer input) {
        return input + 100000000;
    }
});

上面的代码比较简单，就是对int List加工后返回int List1。所以Collections2.transform(Collection<>, new Function

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
 * 函数式编程 :解耦
 * 1.Predicate
     Predicate<T> pre=new Predicate<T>() {
        @Override
        public boolean apply(T input) {
            return false;
        }
    };

 * 2.Function
 *   Function<F, T> fun=new Function<F, T>() {
        @Override
        public T apply(F input) {
            return null;
        }
     };
 * @author Administrator
 *
 */
public class Demo02 {

    public static void main(String[] args) {
        //组合式编程，确保容器中的字符串长度不超过5，如果超过5就进行截取，然后全部大写
        List<String> list = Lists.newArrayList("lf","jiushi","really","shuai");
        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();
            }
        };

        Function f = Functions.compose(f1, f2); //这里就是把函数组合起来，类似于f2(f1(x))
        Collection<String> col = Collections2.transform(list, f);
        for(String temp:col){
            System.out.println(temp);
        }
    }

    public static void test02(){
        //类型转换，便于将容器和业务进行解耦
        Set<Long> timeSet = Sets.newHashSet();
        timeSet.add(10000000L);
        timeSet.add(212513113132L);
        timeSet.add(2120000000L);

        Collection<String> timeStr = Collections2.transform(timeSet, new Function<Long,String>(){

            public String apply(Long input) {

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

        for(String temp:timeStr){
            System.out.println(temp);
        }
    }

    public static void test01(){
        //简称过滤器，顾名思义，就是经过过滤取得我们需要的东西
        List<String> list = Lists.newArrayList("moom","son","dad","lf");
        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 temp:palindromelist){
            System.out.println(temp);
        }

    }
}

约束

package guava.collection;

import java.util.Set;

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

/**
 * 加入约束条件:Constraint,Preconditions,Constraints
 * Constraint<E> constraint=new Constraint<E>() {
        @Override
        public E checkElement(E element) {
        Preconditions.checkNotNull(element);//非空验证
        Preconditions.checkArgument(element.length()>=5 && element.length()<=20);//长度验证
            return element;
        }
    };
 * Constraints.constrained_xxx(需要约束的容器, constraint);//返回一个容器
 */
public class Test03_Constraint {
    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);
                return element;
            }
        };
        Set<String> cs =Constraints.constrainedSet(sets, constraint);
//      cs.add(null); //java.lang.NullPointerException
//      cs.add("good"); //java.lang.IllegalArgumentException
        cs.add("bjsxt");
        for(String str:cs){
            System.out.println(str);
        }
    }
}

集合的运算

import java.util.Set;

import com.google.common.collect.Sets;
import com.google.common.collect.Sets.SetView;
/**
 * 集合的操作:
 * 1. 交集
 *    Sets.intersection()
 * 2. 差集
 *    Sets.difference()
 * 3. 并集
 *    Sets.union();
 */
public class Test04_GatherOperation {
    public static void main(String[] args) {
        Set<Integer> sets =Sets.newHashSet(1,2,3,4,5,6);
        Set<Integer> sets2 =Sets.newHashSet(3,4,5,6,7,8,9);

        //交集
        System.out.println("交集为:");
        SetView<Integer> intersection =Sets.intersection(sets, sets2);
        for(Integer temp:intersection){
            System.out.println(temp);
        }
        //差集
        System.out.println("差集为:");
        SetView<Integer> diff =Sets.difference(sets, sets2);
        for(Integer temp:diff){
            System.out.println(temp);
        }
        //并集
        System.out.println("并集为:");
        SetView<Integer> union =Sets.union(sets, sets2);
        for(Integer temp:union){
            System.out.println(temp);
        }
    }
}