1. google guava
HashMap： 键盘不可以重复，值可以重复
Multimap： 键可以重复
HashBiMap: 键与值不能重复,插入以后抛出异常
双键的Map-》Table
package com.denganzhi.pp;
import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import org.junit.Test;
import java.util.Set;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.Multimap;
import com.google.common.collect.Table;
import com.google.common.collect.Table.Cell;
import com.google.common.math.BigIntegerMath;
public class GuavaTest {
@Test
public void test1(){
// HashMap： 键盘不可以重复，值可以重复
Map<String,String> map=new HashMap<>();
map.put("a", "小黑");
map.put("b", "小黑");
map.put("c", "小黑");
for(String key:map.keySet()){
String value =map.get(key);
System.out.println(key+"-->"+value);
}
// Multimap： 键可以重复
Multimap<String, String> multimap=ArrayListMultimap.create();
// 迭代器
Iterator<Map.Entry<String, String>> it= map.entrySet().iterator();
while(it.hasNext()){
Map.Entry<String, String> entry= it.next();
String key= entry.getKey();
String value= entry.getValue();
// 对调
multimap.put(value, key);
}
multimap.put("小泽", "d");
// 查看内容
Set<String> keySet= multimap.keySet();
System.out.println(keySet.size());
for (String key : keySet) {
Collection<String> col= multimap.get(key);
System.out.println("key---"+key+"---col:"+col);
}
}
// 键与值不能重复,插入以后抛出异常
@Test
public void test2(){
BiMap<String, String> bitmap= HashBiMap.create();
try{
bitmap.put("a", "xiaoming");
bitmap.put("b", "xiaoming");
bitmap.put("a", "xiaoming");
bitmap.put("b", "xiaoming");
}catch(Exception e){
e.printStackTrace();
}
// for(String key:bitmap.keySet()){
// String value =bitmap.get(key);
// System.out.println(key+"-->"+value);
// }
}
// 双键的Map-》Table->
@Test
public void test3(){
Table<String, String, Integer> tables= HashBasedTable.create();
tables.put("xiaoming", "语文", 100);
tables.put("xiaohei", "数学", 30);
tables.put("xiaoze", "英语", 60);
// 所有行数据
Set<Cell<String,String,Integer>> cells= tables.cellSet();
for (Cell<String, String, Integer> temp : cells) {
// System.out.println(temp.getRowKey()+"--"+temp.getColumnKey()+"--"+temp.getValue());
}
// 根据名字 找 课程和成绩
Set<String> stus = tables.rowKeySet();
// 所有成绩
for (String stu : stus) {
System.out.println(stu);
Map<String,Integer> map= tables.row(stu);
// System.out.println(map);
for (String key : map.keySet()) {
System.out.println(key);
Integer col= map.get(key);
System.out.println(col);
}
}
// 所有课程, 根据课程找 名字和成绩
Set<String> coursSet= tables.columnKeySet();
for (String string : coursSet) {
Map<String,Integer> sources= tables.column(string);
System.out.println(sources);
}
}
}
2. CommonsIO
求集合 并集 | 交集 | 差集
@Test
public void main4_io(){
Set<String> set1=new HashSet<>();
set1.add("a");
set1.add("b");
Set<String> set2=new HashSet<>();
set2.add("b");
set2.add("c");
// 并集
Collection<String> col= CollectionUtils.union(set1, set2);
System.out.println("---并集----"+ col); //---并集----[a, b, c]
// 交集
col= CollectionUtils.intersection(set1, set2);
// CollectionUtils.retainAll(set1, set2); //---交集---[b]
System.out.println("---交集---"+col);
// 差集
col= CollectionUtils.subtract(set1, set2); //---差集---[a]
System.out.println("---差集---"+col);
}循环队列、只读 队列
/**
* 循环队列
*/
@Test
public void main5(){
CircularFifoQueue<String> que=new CircularFifoQueue<>(2);
que.add("a");
que.add("b");
que.add("c"); //长度为2，c进来a 出去了
for (int i = 0; i < que.size(); i++) {
System.out.println(que.get(i));
}
// 设置只读 队列
Queue<String> readOnlyQueue=UnmodifiableQueue.unmodifiableQueue(que);
// 抛异常
readOnlyQueue.add("d");
}去除List 重复元素
// 去除重复元素
@Test
public void main6(){
List<String> list=new ArrayList<>();
list.add("a");
list.add("b");
list.add("a");
// 去除 重复的过滤器
Iterator<String> it=new UniqueFilterIterator<>(list.iterator());
while(it.hasNext()){
System.out.println(it.next());
}
}无序 双向 map , 通过value 找 key
有序双向Map
// 无序 双向 map , 通过value 找 key
BidiMap<String, String> map=new DualHashBidiMap<>();
map.put("bj", "[email protected]");
map.put("sxt", "[email protected]");
// 反转
System.out.println(map.inverseBidiMap().get("[email protected]"));
// 有序双向Map
BidiMap<String, String> map2= new DualTreeBidiMap<>();
map2.put("bj", "[email protected]");
map2.put("sxt", "[email protected]");
// 遍历 查看
MapIterator<String, String> it2=map.inverseBidiMap().mapIterator();
while(it2.hasNext()){
String key = it2.next();
String value= it2.getValue();
System.out.println(key+"---"+value);
} Bag 包允许内容 重复
// 1. HashBag 内容无序
// 2. TreeBag 内容有序，统计字符个数【这里的有序是内容会排序按照compare接口，不是下标有序】
@Test
public void main7(){
// Bag 包允许重复
// 1. HashBag 无序
// Bag<String> bag=new HashBag<>();
// bag.add("c");
// bag.add("a");
// bag.add("a",5); // a 在加 5 次
// bag.remove("a",2); // a 删除2次
// bag.add("1");
// bag.add("b");
// Iterator<String> it1=bag.iterator();
// while(it1.hasNext()){
// System.out.println(it1.next());
// }
// 2. TreeBag 有序
// 有序是指 排列顺序 按照ascII 码
Bag<String> bag2=new TreeBag<>();
bag2.add("b");
bag2.add("c");
bag2.add("a");
bag2.add("a",5); // a 在加 5 次
bag2.remove("a",2); // a 删除2次
Iterator<String> it2=bag2.iterator();
while(it2.hasNext()){
System.out.println(it2.next());
}
// 字符串 个数统计
String str="a b c a b c d d d";
String[] strArray= str.split(" ");
Bag<String> bagArray= new TreeBag<>();
for (String string : strArray) {
bagArray.add(string);
}
Set<String> keys= bagArray.uniqueSet(); // 去除重复内容，并且统计个数
for (String letters : keys) {
System.out.println(letters+"--->"+ bagArray.getCount(letters));
}
}