集合操作

• Test04_GatherOperation.java

package commons.collection;

import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

import org.apache.commons.collections4.CollectionUtils;

/**
 * 集合操作
 * 1.并集
 * CollectionUtils.union();
 * 2.交集
 * CollectionUtils.intersection();
 * CollectionUtils.retainAll();
 * 3.差集
 * CollectionUtils.subtract();
 */

public class Test04_GatherOperation {
    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);
        }       
    }
}

队列

• Test05_Queue.java

package commons.collection;

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 Test05_Queue {
    public static void main(String[] args) {
        //circularFifoQueue();
        //unmodifiableQueue();
        predicatedQueue();
    }
    /**
     * 1.循环队列-CircularFifoQueue
     */
    public static void circularFifoQueue(){
        //循环队列
        CircularFifoQueue<String> que =new CircularFifoQueue<String>(2);
        que.add("a");
        que.add("b");
        que.add("c");
        //查看c进来a就出去了
        for(int i=0;i<que.size();i++){
            System.out.println(que.get(i));
        }
    }
    /**
     * 2.只读队列-UnmodifiableQueue
     */
    public static void unmodifiableQueue(){
        //只读循环队列
        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");
    }
    /**
     * 3.断言队列-PredicatedQueue
     */
    public static void predicatedQueue(){
        //循环队列
        CircularFifoQueue<String> que =new CircularFifoQueue<String>(2);
        que.add("a");
        que.add("b");
        que.add("c");
        @SuppressWarnings("unchecked")
        Predicate<String> notNull=NotNullPredicate.INSTANCE;
        //包装成对应的队列
        Queue<String> que2=PredicatedQueue.predicatedQueue(que, notNull);
        que2.add(null);
    }
}