Apache容器扩展类和常用方法_apache predicatedqueue-优快云博客

本文链接：https://blog.youkuaiyun.com/wo_aisilebiancheng/article/details/48881359

1. 新单词：

symmetric 对称的
exclusive 独有的
disjunction 分离
cardinality 基数
equivalent 相等的

2. 闭包Closure

业务操作：重写execute()方法

工具类：CollectionUtils.forAllDo()关联操作

1) IfClosure.ifClosure(断言，业务，业务) 二选一操作

2) ChainedClosure.chainedClosure(业务，业务) 链式操作

3) WhileClosure.whileClosure(断言，业务， boolean(false是先进行判断再进行操作，true是先进行操作再进行判断)) 循环操作

3. 交集、差集、并集

1)交集：CollectionUtils.intersection()
CollectionUtils.retainAll()
2)差集：CollectionUtils.subtract()
3)并集：CollectionUtils.union()
4)不同元素： CollectionUtils.disjunction()

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);

		// 求交集
		// Collection<Integer> inter = CollectionUtils.intersection(set1, set2);
		Collection<Integer> inter = CollectionUtils.retainAll(set1, set2);
		System.out.println("交集：" + inter);

		// 求差集
		Collection<Integer> diff = CollectionUtils.subtract(set1, set2);
		System.out.println("差集：" + diff);

		// 求并集
		Collection<Integer> union = CollectionUtils.union(set1, set2);
		System.out.println("交集：" + union);

		// 求出不同的元素
		Collection<Integer> dist = CollectionUtils.disjunction(set1, set2);
		System.out.println("不同元素：" + dist);
	}
}
	/*
	Output:
		交集：[2, 3]
		差集：[1]
		交集：[1, 2, 3, 4]
		不同元素：[1, 4]
	*/

4. 队列的扩展：

1）循环队列：CircularFifoQueue

2）只读队列： UnmodifiableQueue.unmodifiableQueue()

3）断言队列：PredicatedQueue.predicatedQueue()

public static void main(String[] args) {
		// circularQueue();
		// readOnlyQueue();
		// predicateQueue();
	}

	// 循环队列
	public static void circularQueue() {
		CircularFifoQueue<String> circular = new CircularFifoQueue<String>(2);// 长度为2
		circular.add("a");
		circular.add("b");
		circular.add("c");
		System.out.println(circular);
		// Output: [b, c]
	}

	// 只读队列
	public static void readOnlyQueue() {
		CircularFifoQueue<String> circular = new CircularFifoQueue<String>();// 默认长度为32
		circular.add("a");
		circular.add("b");
		circular.add("c");
		// 变为只读队列
		Queue<String> que = UnmodifiableQueue.unmodifiableQueue(circular);
		// que.add("d"); 报错
	}

	// 断言队列
	public static void predicateQueue() {
		CircularFifoQueue<String> circular = new CircularFifoQueue<String>();// 默认长度为32
		Predicate<String> notNull = NotNullPredicate.notNullPredicate();
		// 设置为断言队列
		Queue<String> que = PredicatedQueue.predicatedQueue(circular, notNull);
		que.add("a");
		que.add("b");
		// que.add(null) 报错
	}

5. 迭代器的扩展：

1)JDK中Map的两种遍历方法keySet()和entrySet()

2)Apache中的迭代器MapIterator和mapiterator()方法

但是这个迭代器要Apache中使用

IterableMap的HashedMap（简单来说IterableMap相当于Map；HashedMap相当于HashMap）

3)去重迭代器，相当于过滤器：UniqueFilterIterator

4)自定义迭代器：FilterIterator + Predicate 断言

5)循环迭代器：LoopingIterator（注意一下参数和访问）

public static void main(String[] args) {
		// testMap();
		// mapIt();
		// uniqueIt();
		// selfIt();
		loopingIt();
	}

	// JDK中Map的两种遍历方式
	public static void testMap() {
		Map<String, String> map = new HashMap<String, String>();
		map.put("a", "first");
		map.put("b", "second");
		map.put("c", "third");
		// 第一种 keySet()
		Set<String> keys = map.keySet();
		Iterator<String> iter = keys.iterator();
		while (iter.hasNext()) {
			String key = iter.next();
			String value = map.get(key);
			System.out.println(key + "-->" + value);
		}

		System.out.println("===================");

		// 第二种 entrySet()
		Set<Entry<String, String>> entry = map.entrySet();
		Iterator<Entry<String, String>> iter2 = entry.iterator();
		while (iter2.hasNext()) {
			Entry<String, String> tempMap = iter2.next();
			String key = tempMap.getKey();
			String value = tempMap.getValue();
			System.out.println(key + "-->" + value);
		}

	}

	// Apache中的迭代器
	public static void mapIt() {
		IterableMap<String, String> map = new HashedMap<String, String>();
		map.put("a", "first");
		map.put("b", "second");
		map.put("c", "third");
		// 迭代器
		MapIterator<String, String> iter = map.mapIterator();
		while (iter.hasNext()) {
			String key = iter.next();
			String value = map.get(key);
			System.out.println(key + "-->" + value);
		}
	}

	// 去重迭代器
	public static void uniqueIt() {
		List<String> list = new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("a");
		// 去重迭代器
		Iterator<String> iter = new UniqueFilterIterator(list.iterator());
		while (iter.hasNext()) {
			System.out.println(iter.next());
		}
	}// Output:a b

	// 自定义迭代器
	public static void selfIt() {
		List<String> list = new ArrayList<String>();
		list.add("refer");
		list.add("fsdd");
		list.add("mom");
		// 断言 :寻找回文
		Predicate<String> pre = new Predicate<String>() {
			@Override
			public boolean evaluate(String input) {

				return new StringBuilder(input).reverse().toString()
						.equals(input);
			}
		};

		// 关联
		Iterator<String> iter = new FilterIterator(list.iterator(), pre);
		while (iter.hasNext()) {
			System.out.println(iter.next());
		}
	}

	// 循环迭代器
	public static void loopingIt() {
		List<String> list = new ArrayList<String>();
		list.add("refer");
		list.add("fsdd");
		list.add("mom");
		Iterator<String> iter = new LoopingIterator(list);// 不再是list.iterator()
		for (int i = 0; i < 5; i++) {// 不再是iter.hasNext()
			System.out.println(iter.next());
		}
	}// Output:refer fdss mom refer fdss

6. 双向(key和value都是唯一的)Map--> BidiMap
1） inverseBidiMap()反转
2）实现类：DualHashMap 无序

DualTreeMap 有序

public static void main(String[] args) {
		
		BidiMap<String, String> map = new DualTreeBidiMap<String, String>();
		map.put("新浪", "www.sina.com");
		map.put("百度", "www.baidu.com");
		map.put("途牛", "www.tuniu.com");


		// 通过value找key值
		String str = map.inverseBidiMap().get("www.baidu.com");
		System.out.println(str);
		// 遍历
		MapIterator<String, String> iter = map.mapIterator();
		while(iter.hasNext()) {
			String key = iter.next();
		  //String key = iter.getKey();可以这样，但必须有iter.next()
			String value = iter.getValue();
			System.out.println(key+"-->"+value);
		}
	}
	/*
	Output:
		百度
		新浪-->www.sina.com
		百度-->www.baidu.com
		途牛-->www.tuniu.com
		这里貌似不是有顺序的输出？
		解释：Unicode(新)<Unicode(百)<Unicode(途)，因此是有顺序的
	*/

7. 包——Bag 允许重复(可以用来统计单词的个数)
实现类：
HashBag 无序
TreeBag 有序

public static void main(String[] args) {
	  //testBag();
		wordsCount();
		
	}
	
	// Bag的基本用法
	public static void testBag() {
		Bag<String> bag = new TreeBag<String>();
		bag.add("a");
		bag.add("b", 4);// 加入4个"b"
		bag.remove("b", 3);// 删除3个"b"
		Iterator<String> iter = bag.iterator();
		while(iter.hasNext()) {
			System.out.println(iter.next());
		}// Output:a b
	}
	
	// 统计单词个数
	public static void wordsCount() {
		Bag<String> bag = new TreeBag<String>();
		String str = "today is mine moneny is mine";
		String[] strArray = str.split(" ");
		// 分拣存储
		for(int i = 0; i < strArray.length; i++) {
			bag.add(strArray[i]);
		}
		// 遍历
		Set<String> keys = bag.uniqueSet();// 这里用Set是因为Set中存储的值不能相同
		Iterator<String> iter = keys.iterator();
		while(iter.hasNext()) {
			String key = iter.next();
			System.out.println(key+"-->"+bag.getCount(key));
		}
	}