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

来源：互联网发布：linux sleep longer 编辑：程序博客网时间：2024/05/22 04:32

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

0 0