工具类系列-DataFilterQueue

package com.syk.utils.queue;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 采用队列思想 作用是对一组数据进行条件排序,剔除操作;也可判断当前数据是否在满足的范围内
 *
 */

class DataFilterQueue {
    public static void main(String[] args) {

        NomalClassicVo resPriceClassicVo = new NomalClassicVo(5);
        AtomicInteger atoInteger = new AtomicInteger(119);
        for (int i = 0; i < 9; i++) {
            resPriceClassicVo.countAndRecordDataOnce(new BigDecimal(atoInteger.incrementAndGet()));
        }

        System.out.println(resPriceClassicVo.getLeastChildPriceQueue().getVaules());
        System.out.println(resPriceClassicVo.getLeastChildPriceQueue().isOutOfBound(new BigDecimal(121)));
    }
}


class NomalClassicVo {

    private AtomicInteger atomicInteger = new AtomicInteger(0);

    private DepthBoundedComparableQueue<BigDecimal> leastChildPriceQueue = null;

    public NomalClassicVo(int size) {
        leastChildPriceQueue = new DepthBoundedComparableQueue<BigDecimal>(size);
    }

    public void countAndRecordDataOnce(BigDecimal price) {
        atomicInteger.incrementAndGet();
        leastChildPriceQueue.addItem(price);
    }

    public DepthBoundedComparableQueue<BigDecimal> getLeastChildPriceQueue() {
        return leastChildPriceQueue;
    }

    public void setLeastChildPriceQueue(DepthBoundedComparableQueue<BigDecimal> leastChildPriceQueue) {
        this.leastChildPriceQueue = leastChildPriceQueue;
    }

    class DepthBoundedComparableQueue<T extends Comparable<T>> {

        private int queueDepth;

        private List<T> tempQueueList = null;

        public DepthBoundedComparableQueue(int depth) {
            this.queueDepth = depth;
            tempQueueList = new ArrayList<T>(queueDepth + 1);
        }

        public synchronized void addItem(T item) {
            if (item == null) {
                return;
            }
            tempQueueList.add(item);
            if (tempQueueList.size() >= queueDepth) {
                Collections.sort(tempQueueList);
                tempQueueList = new ArrayList<T>(tempQueueList.subList(0, queueDepth));
            }
        }

        public List<T> getVaules() {
            return tempQueueList;
        }

        /**
         *
         * @param data
         * @return true 时表明入参越界
         */
        public boolean isOutOfBound(T data) {
            if (tempQueueList != null && tempQueueList.size() == 0) {
                return false;
            }
            T lastData = tempQueueList.get(tempQueueList.size() - 1);
            int compareResLast = lastData.compareTo(data);
            T firstData = tempQueueList.get(0);
            int compareResFirst = firstData.compareTo(data);
            if (compareResFirst < 0 && compareResLast > 0) {
                return false;
            }
            return true;
        }
    }

}