java基礎--extension package guava（1）

時間 2019-11-18

標籤 java 基礎 extension package guava 欄目 Java 简体版

原文原文鏈接

1.guava 簡介java

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 對象添加一個裝飾器? 實現迭代器? 咱們能夠更容易使用這些方法。oracle

　　三. 緩存: 本地緩存，能夠很方便的操做緩存對象，而且支持各類緩存失效行爲模式。app

　　四. 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;

/**
 * 函數式編程 :解耦
 * 一、Predicate 
 * 二、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;

/**
 * 統計單詞出現的次數
 * 一、HashMap 分揀存儲+面向對象思惟  -->判斷
 * 二、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;

/**
 *  
 * 一、方法
 *  全部的行數據: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*/