java基础--extension package guava（1）

时间：2017-11-19 13:33:14 阅读：252 评论：0 收藏：0 [点我收藏+]

标签：ever 完成科学 direction 事件总线防御性编程 lang code 复杂

1.guava 简介

Guava 是一个 Google 的基于java1.6的类库集合的扩展项目，包括 collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O, 等等. 这些高质量的 API 可以使你的JAVa代码更加优雅，更加简洁，让你工作更加轻松愉悦。

2.源码包的简单说明：
　　com.google.common.annotations：普通注解类型。
　　com.google.common.base：基本工具类库和接口。
　　com.google.common.cache：缓存工具包，非常简单易用且功能强大的JVM内缓存。
　　com.google.common.collect：带泛型的集合接口扩展和实现，以及工具类，这里你会发现很多好玩的集合。
　　com.google.common.eventbus：发布订阅风格的事件总线。
　　com.google.common.hash：哈希工具包。
　　com.google.common.io：I/O工具包。
　　com.google.common.math：原始算术类型和超大数的运算工具包。
　　com.google.common.net：网络工具包。
　　com.google.common.primitives：八种原始类型和无符号类型的静态工具包。
　　com.google.common.reflect：反射工具包。
　　com.google.common.util.concurrent：多线程工具包。

3　类库使用手册：

　　一. 基本工具类：让使用Java语言更令人愉悦。

　　1. 使用和避免 null：null 有语言歧义，会产生令人费解的错误，反正他总是让人不爽。很多 Guava 的工具类在遇到 null 时会直接拒绝或出错，而不是默默地接受他们。
　　2. 前提条件：更容易的对你的方法进行前提条件的测试。
　　3. 常见的对象方法：简化了Object常用方法的实现，如 hashCode() 和 toString()。
　　4. 排序： Guava 强大的 "fluent Comparator"比较器，提供多关键字排序。
　　5. Throwable类：简化了异常检查和错误传播。

　　二. 集合类：集合类库是 Guava 对 JDK 集合类的扩展，这是 Guava 项目最完善和为人所知的部分。

　　1. Immutable collections（不变的集合）：防御性编程，不可修改的集合，并且提高了效率。
　　2. New collection types(新集合类型)：JDK collections 没有的一些集合类型，主要有：multisets，multimaps，tables， bidirectional maps等等
　　3. Powerful collection utilities（强大的集合工具类）： java.util.Collections 中未包含的常用操作工具类
　　4. Extension utilities（扩展工具类）: 给 Collection 对象添加一个装饰器? 实现迭代器? 我们可以更容易使用这些方法。

　　三. 缓存: 本地缓存，可以很方便的操作缓存对象，并且支持各种缓存失效行为模式。

　　四. Functional idioms（函数式）: 简洁, Guava实现了Java的函数式编程，可以显著简化代码。

　　五. Concurrency（并发）：强大,简单的抽象,让我们更容易实现简单正确的并发性代码。

　　1. ListenableFuture（可监听的Future）: Futures,用于异步完成的回调。
　　2. Service: 控制事件的启动和关闭，为你管理复杂的状态逻辑。

　　六. Strings: 一个非常非常有用的字符串工具类: 提供 splitting，joining， padding 等操作。

　　七. Primitives: 扩展 JDK 中未提供的对原生类型（如int、char等）的操作，包括某些类型的无符号的变量。

　　八. Ranges: Guava 一个强大的 API，提供 Comparable 类型的范围处理，包括连续和离散的情况。

　　九. I/O: 简化 I/O 操作, 特别是对 I/O 流和文件的操作, for Java 5 and 6.

　　十. Hashing: 提供比 Object.hashCode() 更复杂的 hash 方法, 提供 Bloom filters.

　　十一. EventBus: 基于发布-订阅模式的组件通信，但是不需要明确地注册在委托对象中。

　　十二. Math: 优化的 math 工具类，经过完整测试。

　　十三. Reflection: Guava 的 Java 反射机制工具类。

4.代码区

package com.zwj.gua;


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

import com.google.common.collect.ImmutableList;

/**
 * 只读设置
 * @author Administrator
 *
 */
public class Demo01 {

    /**
     * @param args
     */
    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 视图也一起改变
        System.out.println(readList);
        //对比 查看 初始化List guava对只读设置 安全可靠，并且相对简单
        List<String> immutableList =ImmutableList.of("a", "b", "c"); 
        //immutableList.add("d");//java.lang.UnsupportedOperationException
        System.out.println(immutableList);
        
    }

}

Demo01 只读设置

package com.zwj.gua;
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()组合式函数编程
 * @author Administrator
 *
 */
public class Demo02 {

    /**
     * @param args  
     *  组合式函数编程 过滤出字符长度小于5并且全部大写
     */
    public static void main(String[] args) {
        //组合式函数编程
        //确保容器中的字符串长度不超过5，超过进行截取，后全部大写
        List<String> list =Lists.newArrayList("bjsxt","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);
        
        for(String temp:resultCol){
            System.out.println(temp);
        }
        
    /*BJSXT
GOOD
HAPPI*/
    }
    /**
     * 转换
     */
    public static void test2(){
        //类型转换
        Set<Long> timeSet =Sets.newHashSet();
        timeSet.add(10000000L);
        timeSet.add(99999999999999999L);
        timeSet.add(2000000000L);
        
        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);
        }

    }
    /**
     * 过滤器     过滤出 反转后字符串 和 之前一致的
     */
    public static void test1(){
        //创建List 静态初始化
        List<String> list =Lists.newArrayList("moom","son","dad","bjsxt","refer");
        //找出回文 palindrome  backwords  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);
        }
    }
    
}

Demo02 函数式编程 :解耦

package com.zwj.gua;

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;

/**
 * 加入约束条件: 非空、长度验证 的集合
 * Constraint
 * Preconditions
 * Constraints
 * @author Administrator
 *
 */
public class Demo03 {

    /**
     * @param args
     */
    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);
        }
                
        
    }

}

Demo03 加入约束条件: 非空、长度验证的集合

package com.zwj.gua;
import java.util.Set;

import com.google.common.collect.Sets;
import com.google.common.collect.Sets.SetView;

/**
 * 集合的操作:交集、差集、并集
 * Sets.intersection()
 * Sets.difference()
 * Sets.union();
 * @author Administrator
 *
 */
public class Demo04 {

    /**
     * @param args
     */
    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);
        }
        
    }

}

Demo04 集合的操作:交集、差集、并集

package com.zwj.gua;


import java.util.Set;

import com.google.common.collect.HashMultiset;
import com.google.common.collect.Multiset;

/**
 * 统计单词出现的次数
 * 1、HashMap 分拣存储+面向对象思维  -->判断
 * 2、Multiset :无序+可重复   .count()  增强了可读性 +操作简单
 * @author Administrator
 *
 */
public class Demo05 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String str ="this is a cat and that is a mice where is the food";
        //分割字符串
        String[] strArray =str.split(" ");
        //存储到Multiset中
        Multiset<String> set =HashMultiset.create();
        for(String strTemp:strArray){
            set.add(strTemp);
        }
        
        //获取所有的单词 Set
        Set<String> letters =set.elementSet();
        for(String temp:letters){
            System.out.println(temp+"-->"+set.count(temp));
        }
        
        
    }

}
/*mice-->1
that-->1
cat-->1
is-->3
food-->1
a-->2
the-->1
where-->1
this-->1
and-->1
*/

Demo05 统计单词出现的次数

package com.zwj.gua;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;

/**
 * 分析查看 教师  教授的每门课程
 * Multimap :key-value  key可以重复
 * 
 * 
 * @author Administrator
 *
 */
public class Demo06 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Map<String,String> cours =new HashMap<String,String>();
        //加入测试数据
        cours.put("改革开放", "邓爷爷");
        cours.put("三个代表", "江主席");
        cours.put("科学发展观", "胡主席");
        cours.put("和谐社会", "胡主席");
        cours.put("八荣八耻", "胡主席");
        cours.put("....", "习主席");
        
        //Multimap
        Multimap<String,String> teachers =ArrayListMultimap.create();
        //迭代器
        Iterator<Map.Entry<String,String>> it =cours.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry<String,String> entry =it.next();
            String key =entry.getKey(); //课程
            String value =entry.getValue(); //教师
            
            //教师 -->课程
            teachers.put(value, key);
        }
        
        
        //查看Multimap
        Set<String> keyset =teachers.keySet();
        for(String key:keyset){
            Collection<String> col =teachers.get(key);
            System.out.println(key+"-->"+col);
        }
        
        
        
    }

}

Demo06 分析查看教师教授的每门课程

package com.zwj.gua;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;

/**
 * 分析查看 教师  教授的每门课程
 * Multimap :key-value  key可以重复
 * 
 * 
 * @author Administrator
 *
 */
public class Demo06 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Map<String,String> cours =new HashMap<String,String>();
        //加入测试数据
        cours.put("改革开放", "邓爷爷");
        cours.put("三个代表", "江主席");
        cours.put("科学发展观", "胡主席");
        cours.put("和谐社会", "胡主席");
        cours.put("八荣八耻", "胡主席");
        cours.put("....", "习主席");
        
        //Multimap
        Multimap<String,String> teachers =ArrayListMultimap.create();
        //迭代器
        Iterator<Map.Entry<String,String>> it =cours.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry<String,String> entry =it.next();
            String key =entry.getKey(); //课程
            String value =entry.getValue(); //教师
            
            //教师 -->课程
            teachers.put(value, key);
        }
        
        
        //查看Multimap
        Set<String> keyset =teachers.keySet();
        for(String key:keyset){
            Collection<String> col =teachers.get(key);
            System.out.println(key+"-->"+col);
        }
        
        
        
    }

}
/*邓爷爷-->[改革开放]
江主席-->[三个代表]
习主席-->[....]
胡主席-->[科学发展观, 八荣八耻, 和谐社会]*/

Demo06 分析查看教师教授的每门课程

package com.zwj.gua;


import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;

/**
 * HashMap 键唯一，值可以重复
 * BiMap:双向Map(Bidirectional Map ) 键与值都不能重复(unique -valued map)
 * @author Administrator
 *
 */
public class Demo07 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        BiMap<String,String> bimap=HashBiMap.create();
        bimap.put("bjsxt", "bjsxt@sina.com");
        bimap.put("good","good@qq.com");
        //通过邮箱找用户
        String user =bimap.inverse().get("good@qq.com");
        System.out.println(user);
        System.out.println(bimap.inverse().inverse()==bimap);
        /*good
          true
        */
    }

}

Demo07 :双向Map(Bidirectional Map ) 键与值都不能重复(unique -valued map)

package com.zwj.gua;
import java.util.Map;
import java.util.Set;

import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;
import com.google.common.collect.Table.Cell;
import com.google.common.collect.Tables;

/**
 *  
 * 1、方法
 *  所有的行数据:cellSet()
 *  所有的学生: rowKeySet()
 *  所有的课程:columnKeySet()
 *  所有的成绩: values()
 *  学生对应的课程: rowMap() +get(学生)
 *                  row(学生)
 *  课程对应的学生: columnMap +get(课程)
 *                  column(课程)
 * @author Administrator
 *
 */
public class Demo08 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Table<String,String,Integer> tables=HashBasedTable.create();
        //测试数据
        tables.put("a", "javase", 80);
        tables.put("b", "javase", 90);
        tables.put("a", "oracle", 100);
        tables.put("c", "oracle", 95);
        //所有的行数据
        Set<Cell<String,String,Integer>> cells =tables.cellSet();
        for(Cell<String,String,Integer> temp:cells){
            System.out.println(temp.getRowKey()+"-->"+temp.getColumnKey()+"-->"+temp.getValue());
        }
        
        System.out.println("==========学生查看成绩==============");
        System.out.print("学生\t");
        //所有的课程
        Set<String> cours =tables.columnKeySet();
        for(String t:cours){
            System.out.print(t+"\t");
        }
        System.out.println();
        //所有的学生
        Set<String> stus =tables.rowKeySet();
        for(String stu:stus){
            System.out.print(stu+"\t");
            Map<String,Integer> scores =tables.row(stu);
            for(String c:cours){
                System.out.print(scores.get(c)+"\t");
            }
            System.out.println();
        }
        
        System.out.println("==========课程查看成绩==============");
        System.out.print("课程\t");
        //所有的学生
        Set<String> stuSet =tables.rowKeySet();
        for(String t:stuSet){
            System.out.print(t+"\t");
        }
        System.out.println();
        //所有的课程
        Set<String> courSet =tables.columnKeySet();
        for(String c:courSet){
            System.out.print(c+"\t");
            Map<String,Integer> scores =tables.column(c);
            for(String s:stuSet){
                System.out.print(scores.get(s)+"\t");
            }
            System.out.println();
        }
        System.out.println("===========转换===========");
        Table<String,String,Integer> tables2 =Tables.transpose(tables);
        //所有的行数据
        Set<Cell<String,String,Integer>> cells2 =tables2.cellSet();
        for(Cell<String,String,Integer> temp:cells2){
            System.out.println(temp.getRowKey()+"-->"+temp.getColumnKey()+"-->"+temp.getValue());
        }
        
    }

}
/*b-->javase-->90
c-->oracle-->95
a-->oracle-->100
a-->javase-->80
==========学生查看成绩==============
学生    javase    oracle    
b    90    null    
c    null    95    
a    80    100    
==========课程查看成绩==============
课程    b    c    a    
javase    90    null    80    
oracle    null    95    100    
===========转换===========
javase-->b-->90
oracle-->c-->95
oracle-->a-->100
javase-->a-->80*/

Demo08 双键的Map -->Table -->rowKey+columnKey+value

java基础--extension package guava（1）

标签：ever 完成科学 direction 事件总线防御性编程 lang code 复杂

原文地址：http://www.cnblogs.com/ou-pc/p/7859440.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行