Guava的只读、函数式编程、集合——高淇JAVA300讲笔记之Guava

Guava简介

　　Guava是谷歌工程师开发的集合库，它是对jdk提供的扩展，提供了很多实用的类来简化代码。

　　一下例子使用的是guava-20.0版本。

案例一：只读设置

package com.bjsxt.others.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<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        
        //对原有的list进行包装，相当于原有List的一个视图，快照，不够安全
        List<String> readList = Collections.unmodifiableList(list);
        //java.lang.UnsupportedOperationException
//        readList.add("d");  //会报错
        list.add("d");  //改变原有List 视图也一起改变
        
        //对比查看 初始化List guava对只读设置 安全可靠，并且相对简单
        List<String> immutableList = ImmutableList.of("a","b","c");
        immutableList.add("d");  //java.lang.UnsupportedOperationException
    }
}

案例二：函数式编程：解耦

package com.bjsxt.others.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
 *
 * 工具：Collections2.filter() 过滤器
 * Collections2.transfer() 转换
 * Functions.compose() 组合式函数编程
 */
public class Demo02 {
    public static void main(String[] args) {
        //组合式函数编程
        //确保容器中的字符串长度不超过5，超过进行截取，后全部大写
        List<String> list = Lists.newArrayList("bjsxt","goods","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);
        
        for(String temp:resultCol) {
            System.out.println(temp);
        }
        
    }
    /**
     * 过滤器
     */
    public static void test1() {
        //创建List 静态初始化
        List<String> list = Lists.newArrayList("moom","son","dad","bjsxt","refer");
        //找出回文 palindrome backwoeds mirror words（指单词正着写和倒着写是一样的）
        //匿名内部类对象：匿名内部类，同时创建类对象
        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);
        }
    }
    
    /**
     * 转换
     */
    public static void test2() {
        //类型转换
        Set<Long> timeSet = Sets.newHashSet();
        timeSet.add(10000000L);
        timeSet.add(9999999999990099L);
        timeSet.add(200000000000L);
        
        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 temp:timeStrCol) {
            System.out.println(temp);
        }
    }
}

test1的运行结果：

moom
dad
refer

test2的运行结果：

318857-05-21
1976-05-04
1970-01-01

主函数的运行结果：

BJSXT
GOODS
HAPPI

案例三：约束，Constraint，这个类在新版本里已经删除了。

案例四：集合的操作：交集、差集、并集

package com.bjsxt.others.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 Demo04 {
    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);
        }
    }
}

运行结果：

交集为：
3
4
5
6
差集为：
1
2
并集为：
1
2
3
4
5
6
7
8
9