Guava:谷歌開發的集合庫，通過build path->Add External JARs 把guava.jar包加進去。
版本控制工具：1.CVS 2.SVN 3.git
所以需要下載git客戶端。
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);
readList.add("d");//對這個視圖增操作，錯誤，拋出java.lang.UnsupportedOperationException（不被支持的異常）。
list.add("d"); //正確，改變原有List，視圖也一起改變，沒有達到真正的目的，所以不夠安全。
// guava對只讀設置 安全可靠，並且相對簡單
List<String> immutableList =ImmutableList.of("a", "b", "c"); //初始化List
immutableList.add("d");//java.lang.UnsupportedOperationException
}
}
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","good","happiness");//靜態創建List，
//確保容器中的字符串長度不超過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 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);
}
}
}
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
*/
public class Demo03 {
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 com.google.common.collect.Sets;//谷歌的jar包
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);//3456
}
//差集
System.out.println("差集爲:");
SetView<Integer> diff =Sets.difference(sets, sets2);
for(Integer temp:diff){
System.out.println(temp);//12
}
//並集
System.out.println("並集爲:");
SetView<Integer> union =Sets.union(sets, sets2);
for(Integer temp:union){
System.out.println(temp);//123456789
}
}
}
import com.google.common.collect.HashMultiset;
import com.google.common.collect.Multiset;
/**
* 統計單詞出現的次數
* 1、HashMap 分揀存儲+面向對象思維 -->判斷
* 2、Multiset :無序+可重複 .count() 增強了可讀性 +操作簡單
* @author Administrator
*
*/
public class Demo05 {
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*/
}
}
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
/**
* 分析查看 教師 教授的每門課程
* Multimap :key-value key可以重複
*/
public class Demo06 {
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(".1..", "習主席");
cours.put("..2.", "習主席");
cours.put(".3..", "習主席");
//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);
}
/*鄧爺爺-->[改革開放]
江主席-->[三個代表]
習主席-->[.3.., ..2., .1..]
胡主席-->[科學發展觀, 八榮八恥, 和諧社會]*/
}
}
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
/**
* HashMap 鍵唯一，值可以重複
* BiMap:雙向Map(Bidirectional Map ) 鍵與值都不能重複(unique -valued map)
*/
public class Demo07 {
public static void main(String[] args) {
BiMap<String,String> bimap=HashBiMap.create();
bimap.put("bjsxt", "[email protected]");
bimap.put("good","[email protected]");
//通過郵箱找用戶
String user =bimap.inverse().get("[email protected]");
System.out.println(user);//good
System.out.println(bimap.inverse().inverse()==bimap);//true
}
}
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;
/**
* 雙鍵的Map -->Table -->rowKey+columnKey+value//類似於一個表格，2個作爲key,另外一個作爲value.
* 1、方法
* 所有的行數據:cellSet()
* 所有的學生: rowKeySet()//查看其中一列
* 所有的課程:columnKeySet()//查看另一列
* 所有的成績: values()//查看所有的value
* 學生對應的課程: rowMap() +get(學生)
* row(學生)
* 課程對應的學生: columnMap +get(課程)
* column(課程)
*/
public class Demo08 {
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());
}
}
}
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.PredicateUtils;
import org.apache.commons.collections4.functors.EqualPredicate;
import org.apache.commons.collections4.functors.NotNullPredicate;
import org.apache.commons.collections4.functors.UniquePredicate;
import org.apache.commons.collections4.list.PredicatedList;
/**
函數式編程 之 Predicate 斷言
封裝條件或判別式 if..else替代
1、 new EqualPredicate<類型>(值)
EqualPredicate.equalPredicate(值);
2、NotNullPredicate.INSTANCE
3、UniquePredicate.uniquePredicate()
4、自定義
new Predicate() +evaluate
PredicateUtils.allPredicate(可以傳2個以上的斷言器)，andPredicate(只能傳2個斷言器)，anyPredicate(多個斷言器，只要其中一個 爲true即可)
PredicatedXxx.predicatedXxx(容器,判斷)
* @author Administrator
*
*/
public class Demo01 {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
System.out.println("======自定義判斷======");
//自定義的判別式
Predicate<String> selfPre =new Predicate<String>(){
@Override
public boolean evaluate(String object) {
return object.length()>=5 && object.length()<=20;
}};
Predicate notNull=NotNullPredicate.notNullPredicate();
Predicate all =PredicateUtils.allPredicate(notNull,selfPre);//多個斷言器
List<String> list =PredicatedList.predicatedList(new ArrayList<String>(),all);//用這個斷言器來限制容器。
list.add("bjsxt");
list.add(null);//報異常
list.add("bj");//報異常
}
/**
* 判斷唯一
*/
public static void unique(){
System.out.println("====唯一性判斷====");
Predicate<Long> uniquePre =UniquePredicate.uniquePredicate();
List<Long> list =PredicatedList.predicatedList(new ArrayList<Long>(), uniquePre);
list.add(100L);
list.add(200L);
list.add(100L); //出現重複值，拋出異常
}
/**
* 判斷非空
*/
public static void notNull(){
System.out.println("====非空判斷====");
Predicate notNull0 = NotNullPredicate.INSTANCE;
Predicate notNull = NotNullPredicate.notNullPredicate();
//String str ="bjs";
String str = null;
System.out.println(notNull.evaluate(str)); //如果非空爲true ,否則爲false
//添加容器值的判斷
List<Long> list =PredicatedList.predicatedList(new ArrayList<Long>(), notNull);//要求容器list不能添加null值。
list.add(1000L);
list.add(null); //驗證失敗，出現異常
}
/**
* 比較相等判斷
*/
public static void equal(){
System.out.println("======相等判斷======");
Predicate<String> pre0 =new EqualPredicate<String>("bjsxt");//實例化一個對象
Predicate<String> pre =EqualPredicate.equalPredicate("bjsxt");//創建對象
boolean flag =pre.evaluate("bj");//是否相等
System.out.println(flag);
}
}
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.SwitchTransformer;
/**
解耦，業務處理與判斷進行分類
函數式編程 Transformer 類型轉化
1、new Transformer() +transform
2、SwitchTransformer
CollectionUtils.collect(容器,轉換器)
*/
public class Demo02 {
public static void main(String[] args) {
System.out.println("===自定義類型轉換==");
//判別式
Predicate<Employee> isLow=new Predicate<Employee>(){//匿名內部類
@Override
public boolean evaluate(Employee emp) {
return emp.getSalary()<10000;
}
};
Predicate<Employee> isHigh=new Predicate<Employee>(){//匿名內部類
@Override
public boolean evaluate(Employee emp) {
return emp.getSalary()>=10000;
}
};
Predicate[] pres ={isLow,isHigh};
//轉換，將Employee轉成Level，
Transformer<Employee,Level> lowTrans =new Transformer<Employee,Level>(){
@Override
public Level transform(Employee input) {
return new Level(input.getName(),"賣身中");
}};
Transformer<Employee,Level> highTrans =new Transformer<Employee,Level>(){
@Override
public Level transform(Employee input) {
return new Level(input.getName(),"養身中");
}};
Transformer[] trans ={lowTrans,highTrans};
//二者進行了關聯
Transformer switchTrans =new SwitchTransformer(pres, trans, null);
//容器
List<Employee> list =new ArrayList<Employee>();
list.add(new Employee("老馬",1000000));
list.add(new Employee("老裴",999));
Collection<Level> levelList = CollectionUtils.collect(list,switchTrans);//參數爲容器和轉換規則
//遍歷容器
Iterator<Level> levelIt =levelList.iterator();
while(levelIt.hasNext()){
System.out.println(levelIt.next());
/*(碼農:老馬,水平:養身中)
(碼農:老裴,水平:賣身中)*/
}
}
/**
* 內置類型的轉換
*/
public static void inner(){
System.out.println("===內置類型轉換 長×××時間日期，轉成指定格式的字符串==");
//類型轉換器，將long類型轉成String，
Transformer<Long,String> trans =new Transformer<Long,String>(){
@Override
public String transform(Long input) {
return new SimpleDateFormat("yyyy年MM月dd日").format(input);
}};
//容器
List<Long> list =new ArrayList<Long>();
list.add(999999999999L);
list.add(300000000L);
//工具類 ，程序猿出錢---開發商---農民工出力
Collection<String> result=CollectionUtils.collect(list, trans);//將容器和類型轉換器連接起來
//遍歷查看結果
for(String time:result){
System.out.println(time);
}
}
}
/**
* 員工類
* @author Administrator
*
*/
public class Employee {
private String name;
private double salary;
//alt +/
public Employee() {
}
//alt+shift+s o
public Employee(String name, double salary) {
super();
this.name = name;
this.salary = salary;
}
//alt+shift+s +r tab 回車 shift+tab 回車
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "(碼農:"+this.name+",敲磚錢:"+this.salary+")";
}
}
/**
* 等級類
* @author Administrator
*
*/
public class Level {
private String name;
private String level;
public Level() {
// TODO Auto-generated constructor stub
}
public Level(String name, String level) {
super();
this.name = name;
this.level = level;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLevel() {
return level;
}
public void setLevel(String level) {
this.level = level;
}
@Override
public String toString() {
return "(碼農:"+this.name+",水平:"+this.level+")";
}
}
import org.apache.commons.collections4.Closure;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.functors.ChainedClosure;
import org.apache.commons.collections4.functors.IfClosure;
import org.apache.commons.collections4.functors.WhileClosure;
/**
函數式編程 Closure 閉包 封裝特定的業務功能
1、Closure
2、IfClosure IfClosure.ifClosure(斷言,功能1,功能2)
3、WhileClosure WhileClosure.whileClosure(斷言,功能,標識)
4、ChainedClosure.chainedClosure(功能列表);
CollectionUtils.forAllDo(容器,功能類對象);
*/
public class Demo03 {
public static void main(String[] args) {
basic();
ifClosure();
whileClosure();
chainClosure();
}
/**
* 折上減 先打折商品，進行9折，滿百再減20
*/
public static void chainClosure(){
List<Goods> goodsList =new ArrayList<Goods>();
goodsList.add(new Goods("javase視頻1",120,true));
goodsList.add(new Goods("javaee視頻2",100,false));
goodsList.add(new Goods("高新技術視頻",80,false));
//滿百減20
Closure<Goods> subtract=new Closure<Goods>(){
public void execute(Goods goods) {
if(goods.getPrice()>=100){
goods.setPrice(goods.getPrice()-20);
}
}};
//打折
Closure<Goods> discount=new Closure<Goods>(){
public void execute(Goods goods) {
if(goods.isDiscount()){
goods.setPrice(goods.getPrice()*0.9);
}
}};
//鏈式操作
Closure<Goods> chainClo=ChainedClosure.chainedClosure(discount,subtract);
//關聯
CollectionUtils.forAllDo(goodsList,chainClo);
//查看操作後的數據
for(Goods temp:goodsList){
System.out.println(temp);
/*(商品:javase視頻1,價格:88.0,是否打折:是)
(商品:javaee視頻2,價格:80.0,是否打折:否)
(商品:高新技術視頻,價格:80.0,是否打折:否)*/
}
}
/**
* 確保所有的員工工資都大於10000,如果已經超過的不再上漲
*/
public static void whileClosure(){
//數據
List<Employee> empList =new ArrayList<Employee>();
empList.add(new Employee("bjsxt",20000));
empList.add(new Employee("is",10000));
empList.add(new Employee("good",5000));
//業務功能 每次上漲0.2
Closure<Employee> cols=new Closure<Employee>(){
public void execute(Employee emp) {
emp.setSalary(emp.getSalary()*1.2);
}};
//判斷
Predicate<Employee> empPre=new Predicate<Employee>(){
@Override
public boolean evaluate(Employee emp) {
return emp.getSalary()<10000;
}
};
//false 表示 while結構 先判斷後執行 true do..while 先執行後判斷
Closure<Employee> whileCols =WhileClosure.whileClosure(empPre, cols, false);//empPre爲true則進入cols，
//工具類
CollectionUtils.forAllDo(empList, whileCols) ;
//操作後的數據
Iterator<Employee> empIt=empList.iterator();
while(empIt.hasNext()){
System.out.println(empIt.next());
/*(碼農:bjsxt,敲磚錢:20000.0)
(碼農:is,敲磚錢:10000.0)
(碼農:good,敲磚錢:10368.0) 漲到超過一萬爲止。*/
}
}
/**
* 二選一 如果是打折商品，進行9折，否則滿百減20
*/
public static void ifClosure(){
List<Goods> goodsList =new ArrayList<Goods>();
goodsList.add(new Goods("javase視頻1",120,true));
goodsList.add(new Goods("javaee視頻2",100,false));
goodsList.add(new Goods("高新技術視頻",80,false));
//滿百減20
Closure<Goods> subtract=new Closure<Goods>(){
public void execute(Goods goods) {
if(goods.getPrice()>=100){
goods.setPrice(goods.getPrice()-20);
}
}};
//打折
Closure<Goods> discount=new Closure<Goods>(){
public void execute(Goods goods) {
if(goods.isDiscount()){
goods.setPrice(goods.getPrice()*0.9);
}
}};
//判斷
Predicate<Goods> pre=new Predicate<Goods>(){
public boolean evaluate(Goods goods) {
return goods.isDiscount();
}};
//二選一
Closure<Goods> ifClo=IfClosure.ifClosure(pre,subtract,discount);
//關聯
CollectionUtils.forAllDo(goodsList,ifClo);
//查看操作後的數據
for(Goods temp:goodsList){
System.out.println(temp);
/*(商品:javase視頻,價格:108.0,是否打折:是)
(商品:javaee視頻,價格:80.0,是否打折:否)
(商品:高新技術視頻,價格:80.0,是否打折:否)*/
}
}
/**
* 基本操作
*/
public static void basic(){
//數據
List<Employee> empList =new ArrayList<Employee>();
empList.add(new Employee("bjsxt",20000));
empList.add(new Employee("is",10000));
empList.add(new Employee("good",5000));
//業務功能
Closure<Employee> cols=new Closure<Employee>(){//匿名內部類對象
public void execute(Employee emp) {
emp.setSalary(emp.getSalary()*1.2);//工資加倍
}};
//工具類
CollectionUtils.forAllDo(empList, cols) ;
//操作後的數據
Iterator<Employee> empIt=empList.iterator();
while(empIt.hasNext()){
System.out.println(empIt.next());
/*(碼農:bjsxt,敲磚錢:24000.0)
(碼農:is,敲磚錢:12000.0)
(碼農:good,敲磚錢:6000.0)*/
}
}
}
public class Goods {
private String name;
private double price;
//折扣
private boolean discount;
public Goods() {
// TODO Auto-generated constructor stub
}
public Goods(String name, double price, boolean discount) {
super();
this.name = name;
this.price = price;
this.discount = discount;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public boolean isDiscount() {
return discount;
}
public void setDiscount(boolean discount) {
this.discount = discount;
}
@Override
public String toString() {
return "(商品:"+this.name+",價格:"+this.price+",是否打折:"+(discount?"是":"否")+")";
}
}
import org.apache.commons.collections4.CollectionUtils;
/**
* 集合操作
* 1、並集
* CollectionUtils.union();
* 2、交集
* CollectionUtils.intersection();
* CollectionUtils.retainAll();
* 3、差集
* CollectionUtils.subtract();
*/
public class Demo04 {
public static void main(String[] args) {
Set<Integer> set1 =new HashSet<Integer>();
set1.add(1);
set1.add(2);
set1.add(3);
Set<Integer> set2 =new HashSet<Integer>();
set2.add(2);
set2.add(3);
set2.add(4);
//並集
System.out.println("=========並集============");
Collection<Integer> col =CollectionUtils.union(set1,set2);
for(Integer temp:col){
System.out.println(temp);
}
//交集
System.out.println("=========交集============");
//col =CollectionUtils.intersection(set1, set2);
col =CollectionUtils.retainAll(set1, set2);
for(Integer temp:col){
System.out.println(temp);
}
//差集
System.out.println("=========差集============");
col =CollectionUtils.subtract(set1, set2);
for(Integer temp:col){
System.out.println(temp);
}
}
}
隊列：
import java.util.Queue;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.functors.NotNullPredicate;
import org.apache.commons.collections4.queue.CircularFifoQueue;
import org.apache.commons.collections4.queue.PredicatedQueue;
import org.apache.commons.collections4.queue.UnmodifiableQueue;
/**
Queue隊列(先進先出)，棧(後進先出)
1、循環隊列:CircularFifoQueue
2、只讀隊列:不可改變隊列 UnmodifiableQueue
3、斷言隊列:PredicatedQueue.predicatedQueue()
*/
public class Demo05 {
public static void main(String[] args) {
circular();
readOnly();
predicate();
}
/**
* 斷言隊列
*/
public static void predicate(){
//循環隊列
CircularFifoQueue<String> que =new CircularFifoQueue<String>(2);
que.add("a");
que.add("b");
que.add("c");
Predicate notNull=NotNullPredicate.INSTANCE;
//包裝成對應的隊列
Queue<String> que2=PredicatedQueue.predicatedQueue(que, notNull);
que2.add(null);
}
/**
* 只讀隊列
*/
public static void readOnly(){
//循環隊列
CircularFifoQueue<String> que =new CircularFifoQueue<String>(2);
que.add("a");
que.add("b");
que.add("c");
Queue<String> readOnlyQue =UnmodifiableQueue.unmodifiableQueue(que);
readOnlyQue.add("d");
}
/**
* 循環隊列
*/
public static void circular(){
//循環隊列
CircularFifoQueue<String> que =new CircularFifoQueue<String>(2);
que.add("a");
que.add("b");
que.add("c");
//查看
for(int i=0;i<que.size();i++){
System.out.println(que.get(i));
}
}
}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.IterableMap;
import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.bidimap.DualHashBidiMap;
import org.apache.commons.collections4.iterators.ArrayListIterator;
import org.apache.commons.collections4.iterators.FilterIterator;
import org.apache.commons.collections4.iterators.LoopingIterator;
import org.apache.commons.collections4.iterators.UniqueFilterIterator;
import org.apache.commons.collections4.map.HashedMap;
/**
迭代器的擴展
1、MapIterator 以後不再使用map.keySet.iterator訪問
接口IterableMap，實現類 HashedMap
2、UniqueFilterIterator 去重迭代器
3、FilterIterator 自定義過濾 +Predicate
4、LoopingIterator 循環迭代器
5、ArrayListIterator 數組迭代器
*/
public class Demo06 {
public static void main(String[] args) {
mapIt();
uniqueIt();
filterIt();
loopIt();
arrayIt();
}
/**
* 數組迭代器
*/
public static void arrayIt(){
System.out.println("===== 數組迭代器 ====");
int[] arr ={1,2,3,4,5};
//數組迭代器
Iterator<Integer> it0 =new ArrayListIterator<Integer>(arr);
//指定起始索引和結束索引
Iterator<Integer> it =new ArrayListIterator<Integer>(arr,1,3);
while(it.hasNext()){
System.out.println(it.next());//2，3
}
}
/**
* 循環迭代器
*/
public static void loopIt(){
System.out.println("===== 循環迭代器 ====");
List<String> list =new ArrayList<String>();
list.add("refer");
list.add("dad");
list.add("bjsxt");
list.add("moom");
Iterator<String> it =new LoopingIterator(list);
for(int i=0;i<8;i++){
System.out.println(it.next());
/*refer
dad
bjsxt
moom
refer
dad
bjsxt
moom*/
}
}
/**
* 自定義迭代器
*/
public static void filterIt(){
System.out.println("=====自定義迭代器 ====");
List<String> list =new ArrayList<String>();
list.add("refer");
list.add("dad");
list.add("bjsxt");
list.add("moom");
//自定義條件判斷
Predicate<String> pre =new Predicate<String>(){
public boolean evaluate(String value) {
//迴文判斷
return new StringBuilder(value).reverse().toString().equals(value);
}};
//去除重複的過濾器
Iterator<String> it =new FilterIterator(list.iterator(),pre);
while(it.hasNext()){
System.out.println(it.next());
/*refer
dad
moom*/
}
}
/**
* 去重迭代器
*/
public static void uniqueIt(){
System.out.println("=====去重迭代器 ====");
List<String> list =new ArrayList<String>();
list.add("a");
list.add("b");
list.add("a");
//去除重複的過濾器
Iterator<String> it =new UniqueFilterIterator(list.iterator());
while(it.hasNext()){
System.out.println(it.next());
/*a
b*/
}
}
/**
* map迭代器
*/
public static void mapIt(){
System.out.println("=====map迭代器====");
IterableMap<String,String> map =new HashedMap<String,String>();
map.put("a","bjsxt");
map.put("b", "sxt");
map.put("c", "good");
//使用 MapIterator
MapIterator<String,String> it =map.mapIterator();
while(it.hasNext()){
String key =it.next();
String value =it.getValue();
System.out.println(key+"-->"+value);
/*a-->bjsxt
c-->good
b-->sxt*/
}
}
}
import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.bidimap.DualHashBidiMap;
import org.apache.commons.collections4.bidimap.DualTreeBidiMap;
/**
雙向Map 要求鍵與值都不能重複
接口BidiMap inverseBidiMap()
實現類1、DualTreeBidiMap :有序
實現類2、DualHashBidiMap :無序
*/
public class Demo07 {
public static void main(String[] args) {
hashMap();
treeMap();
}
/**
* 有序的雙向Map(key會自動排列)
*/
public static void treeMap(){
System.out.println("=====有序的雙向Map====");
BidiMap<String,String> map =new DualTreeBidiMap<String,String>();
map.put("zbj", "[email protected]");
map.put("sxt", "[email protected]");//{[email protected], [email protected]}
//遍歷查看
MapIterator<String,String> it =map.inverseBidiMap().mapIterator();//{[email protected]=zbj, [email protected]=sxt}
while(it.hasNext()){
String key =it.next();
String value =it.getValue();
System.out.println(key+"-->"+value);
//[email protected]>zbj
//[email protected]>sxt
}
}
/**
* 無序的雙向Map
*/
public static void hashMap(){
System.out.println("=====無序的雙向Map====");
BidiMap<String,String> map =new DualHashBidiMap<String,String>();
map.put("bj", "[email protected]");
map.put("sxt", "[email protected]");//{[email protected], [email protected]}
//反轉
System.out.println(map.inverseBidiMap().get("[email protected]"));//先要反轉，然後通過value找到key,sxt
//遍歷查看
MapIterator<String,String> it =map.inverseBidiMap().mapIterator();//{[email protected]=sxt, [email protected]=bj}
while(it.hasNext()){
String key =it.next();
String value =it.getValue();
System.out.println(key+"-->"+value);
/*[email protected]>sxt
[email protected]>bj*/
}
}
}
import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.bag.HashBag;
import org.apache.commons.collections4.bag.TreeBag;
/**
接口Bag 包 允許重複
實現類1、HashBag 無序
實現類2、TreeBag 有序
統計單詞的出現次數
*/
public class Demo08 {
/**
* @param args
*/
public static void main(String[] args) {
hashBag();
treeBag();
String str ="this is a cat and that is a mice where is the food";
//分割字符串
String[] strArray =str.split(" ");
Bag<String> bag =new TreeBag<String>();
for(String temp:strArray){
bag.add(temp);//[2:a,1:and,1:cat,1:food,3:is,1:mice,1:that,1:the,1:this,1:where]
}
System.out.println("====統計次數===");
Set<String> keys =bag.uniqueSet();//[a, and, cat, food, is, mice, that, the, this, where]
for(String letter:keys){
System.out.println(letter+"-->"+bag.getCount(letter));
/*a-->2
and-->1
cat-->1
food-->1
is-->3
mice-->1
that-->1
the-->1
this-->1
where-->1*/
}
}
/**
* 有序
*/
public static void treeBag(){
System.out.println("=====有序的包====");
Bag<String> bag =new TreeBag<String>();
bag.add("a");
bag.add("a",5);
bag.remove("a", 2);
bag.add("b");
bag.add("c");//[4:a,1:b,1:c],有序
Iterator<String> it =bag.iterator();
while(it.hasNext()){
System.out.println(it.next());//aaaabc
}
}
/**
* 無序
*/
public static void hashBag(){
System.out.println("=====無序的包====");
Bag<String> bag =new HashBag<String>();
bag.add("a");
bag.add("a",5);//加5次a,[6:a]
bag.remove("a", 2);//移除2個a,[4:a]
bag.add("b");
bag.add("c");//[1:b,1:c,4:a],一個b,一個c,4個a,
Iterator<String> it =bag.iterator();
while(it.hasNext()){
System.out.println(it.next());//bcaaaa
}
}
}
總結：
set沒有順序，順序指的是索引的順序不是指內容。
1.迭代器：Iterator，
2.比較器：實體類可以排序（實現Comparable重寫compareTo），還可以用排序比較器（實現Comparator重寫compare），TreeSet、TreeMap.
3.泛型：反泛型類，泛型方法，泛型接口，泛型擦出，通配符？
4.6個接口：Collection，set,List,Map,Iterator,Comparable
5.9個常用類：
1)
查看多餘修改時推薦使用ArrayList（add,remove,set(修改),get,foreach,）。
2)
修改多餘查看推薦使用LinkList,多了鏈頭與鏈尾的方法。
3)HashSet：元素不能重複，所以要求元素要重寫hashCode和equals方法.
4)Treeset:要求元素可以排序或者提供排序的業務類。
5)HashMap:鍵不能重複必須重寫hashCode和equals方法，值可以重複，put(),remove(),get().
6)Properties:資源配置文件，
7)Hashtable:鍵與值都不能爲null,
8)Stack:棧
9)Collections:工具類原文鏈接：https://www.cnblogs.com/yaowen/p/4833576.html