Queue接口分析

add(E e)：增加元素；
remove(Object o)：删除元素；
clear()：清除集合中所有元素；
size()：集合元素的大小；
isEmpty()：集合是否没有元素；
contains(Object o)：集合是否包含元素o。

put(E e);   //阻塞
take();    //阻塞

putFirst(E e)：在队首插入元素，如果队列满了，阻塞等待，直到被中断为止。
putLast(E e)：在队尾插入元素，如果队列满了，阻塞等待，直到被中断为止。
offerFirst(E e, long timeout, TimeUnit unit)：向队首插入元素。如果队列满了，阻塞等待timeout个时长，如果到了超时时间还没有空间，抛弃该元素。
offerLast(E e, long timeout, TimeUnit unit)：向队尾插入元素。如果队列满了，阻塞等待timeout个时长，如果到了超时时间还没有空间，抛弃该元素。
takeFirst()：获取并移除队首的元素。如果队列为空，阻塞等待，直到被中断为止。
takeLast()：获取并移除队尾的元素。如果队列为空，阻塞等待，直到被中断为止。
pollFirst(long timeout, TimeUnit unit)：获取并移除队首的元素。如果队列为空，阻塞等待timeout个时长，如果到了超时时间还没有元素，则返回null。
pollLast(long timeout, TimeUnit unit)：获取并移除队尾的元素。如果队列为空，阻塞等待timeout个时长，如果到了超时时间还没有元素，则返回null。
removeFirstOccurrence(Object o)：从队首开始移除第一个和o相等的元素。
removeLastOccurrence(Object o)：从队尾开始移除第一个和o相等的元素。

tryTransfer(E e)：若当前存在一个正在等待获取的消费者线程（使用take()或者poll()函数），使用该方法会即刻转移/传输对象元素e并立即返回true；若不存在，则返回false，并且不进入队列。这是一个不阻塞的操作。
transfer(E e)：若当前存在一个正在等待获取的消费者线程，即立刻移交之；否则，会插入当前元素e到队列尾部，并且等待进入阻塞状态，到有消费者线程取走该元素。
tryTransfer(E e, long timeout, TimeUnit unit)：若当前存在一个正在等待获取的消费者线程，会立即传输给它;否则将插入元素e到队列尾部，并且等待被消费者线程获取消费掉；若在指定的时间内元素e无法被消费者线程获取，则返回false，同时该元素被移除。
hasWaitingConsumer()：判断是否存在消费者线程。
getWaitingConsumerCount()：获取所有等待获取元素的消费线程数量。

/**
     * 入口
     *      101. 对称二叉树
     *      1.创建链表root
     * 输入：
     *      TreeNode root = [1,2,2,3,4,4,3]
     * 输出：
     *      result = true
     * 解释：
     *      1.递归
     *      2.迭代（Queue队列）
     */
    @Test
    public void suanfa21()
    {
        // 创建树
        TreeNode root = new TreeNode(1, new TreeNode(2, new TreeNode(3), new TreeNode(4)), new TreeNode(2, new TreeNode(4), new TreeNode(3)));// 调用方法：迭代
        boolean result2 = this.isSymmetricIteration(root);
        System.out.println("results2 = " + result2);
 
    }
 
    /**
     * 迭代方案
     *
     * @param root 二叉树
     * @return
     */
    public boolean isSymmetricIteration(TreeNode root)
    {
        // Queue队列 和 堆的处理方案一样，都是先进先出（FIFO）的数据结构
        Queue<TreeNode> treeNodes = new LinkedList<>();
 
        // 存入根节点的 左子树 和 右子树
        treeNodes.offer(root.left);
        treeNodes.offer(root.right);
 
        // 如果Queue队列不为空就循环比较
        while (!treeNodes.isEmpty())
        {
            // 获取存入的左子树 和 右子树 （因为先进先出，所以可以确认顺序）
            TreeNode rootLeft = treeNodes.poll();
            TreeNode rootRight = treeNodes.poll();
 
            // 两个都等于null， 所以没有子节点了，就继续判断队列中是否还有值，有则比较，无则结束，返回true
            if (rootLeft == null && rootRight == null)
            {
                continue;
            }
 
            // 左子树 或 右子树，如果有一个是null，就说明不相等,直接返回false，因为上面的判断，所以不可能两个都是null
            if (rootLeft == null || rootRight == null)
            {
                return false;
            }
 
            // 左子树 比较 右子树 的值不相等,直接返回false
            if (rootLeft.val != rootRight.val)
            {
                return false;
            }
 
            // 存入 左子树的左子树 和 右子树的右子树，这样当取出比较相等就说明是镜像
            treeNodes.offer(rootLeft.left);
            treeNodes.offer(rootRight.right);
 
            // 存入 左子树的右子树 和 右子树的左子树，这样当取出比较相等就说明是镜像
            treeNodes.offer(rootLeft.right);
            treeNodes.offer(rootRight.left);
        }
        // 当执行到这里说明树两边是镜像的
        return true;
    }

package com.yao;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class BlockingQueueTest {
 /**
 定义装苹果的篮子
  */
 public static class Basket{
  // 篮子，能够容纳3个苹果
  BlockingQueue<String> basket = new ArrayBlockingQueue<String>(3);
 
  // 生产苹果，放入篮子
  public void produce() throws InterruptedException{
   // put方法放入一个苹果，若basket满了，等到basket有位置
   basket.put("An apple");
  }
  // 消费苹果，从篮子中取走
  public String consume() throws InterruptedException{
   // get方法取出一个苹果，若basket为空，等到basket有苹果为止
   String apple = basket.take();
   return apple;
  }
 
  public int getAppleNumber(){
   return basket.size();
  }
 
 }
 //　测试方法
 public static void testBasket() {
  // 建立一个装苹果的篮子
  final Basket basket = new Basket();
  // 定义苹果生产者
  class Producer implements Runnable {
   public void run() {
    try {
     while (true) {
      // 生产苹果
      System.out.println("生产者准备生产苹果：" 
        + System.currentTimeMillis());
      basket.produce();
      System.out.println("生产者生产苹果完毕：" 
        + System.currentTimeMillis());
      System.out.println("生产完后有苹果："+basket.getAppleNumber()+"个");
      // 休眠300ms
      Thread.sleep(300);
     }
    } catch (InterruptedException ex) {
    }
   }
  }
  // 定义苹果消费者
  class Consumer implements Runnable {
   public void run() {
    try {
     while (true) {
      // 消费苹果
      System.out.println("消费者准备消费苹果：" 
        + System.currentTimeMillis());
      basket.consume();
      System.out.println("消费者消费苹果完毕：" 
        + System.currentTimeMillis());
      System.out.println("消费完后有苹果："+basket.getAppleNumber()+"个");
      // 休眠1000ms
      Thread.sleep(1000);
     }
    } catch (InterruptedException ex) {
    }
   }
  }
 
  ExecutorService service = Executors.newCachedThreadPool();
  Producer producer = new Producer();
  Consumer consumer = new Consumer();
  service.submit(producer);
  service.submit(consumer);
  // 程序运行10s后，所有任务停止
  try {
   Thread.sleep(10000);
  } catch (InterruptedException e) {
  }
  service.shutdownNow();
 }
 public static void main(String[] args) {
  BlockingQueueTest.testBasket();
 }
}

 public static void BufferedReaderEx(String str) {//指定文件目录
        File file = new File(str); //file实例
        FileReader reader = null;
        //读取数据并存储在list集合中
        try {
            reader = new FileReader(file);
 
        BufferedReader bufferedReader = new BufferedReader(reader);
        String tmp;
            ArrayList<String> list = new ArrayList<>();
            while ((tmp = bufferedReader.readLine()) != null) {
                String[] split = tmp.split(",");
                for (String s:split){
                list.add(s);
                }
            }
           HashMap<String,Integer> map = HashMapEx(list);
            PriorityQueue<Map.Entry<String, Integer>> queue = QueueEx(map,5);
            while (!queue.isEmpty()){
                Map.Entry<String, Integer> remove = queue.remove();
                System.out.println("数字：" + remove.getKey() + ",出现：" +remove.getValue() + "次");
 
            }
        }  catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static HashMap<String,Integer> HashMapEx(ArrayList<String> list){//将数据存储到HashMap中用来统计一个数组出现的次数 key为数据 value为出现次数
        HashMap<String, Integer> map = new HashMap<>();
    while (!list.isEmpty()){
        String index = list.remove(0);
        if (map.containsKey(index)) {
            map.put(index, map.get(index) + 1);
        } else {
            map.put(index, 1);
        }
    }
        return map;
    }
    public static PriorityQueue<Map.Entry<String, Integer>> QueueEx(HashMap<String,Integer> map,int num){//将Map中的Entry存储到PriorityQueue队列中并提供一个关于Entry.value的比较器并将队列的容量设置为K
        PriorityQueue<Map.Entry<String, Integer>> queue = new PriorityQueue<>(num, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                return (Integer) o1.getValue() - (Integer) o2.getValue();
            }
        });
        Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()){//遍历Map集合 如果队列容量小于K直接插入数据否则与queue顶部数据进行Value计较如果大于顶部数据插入到queue中
            Map.Entry<String, Integer> next = iterator.next();
            if(queue.size()<num){
                queue.add(next);
            }else {
                if(next.getValue()>queue.peek().getValue()){
                    queue.remove();
                    queue.add(next);
                }
            }
        }
        return queue;
    }

addFirst(E e)：在前端插入元素，异常处理和add一样；
addLast(E e)：在后端插入元素，和add一样的效果；
offerFirst(E e)：在前端插入元素，异常处理和offer一样；
offerLast(E e)：在后端插入元素，和offer一样的效果；
removeFirst()：移除前端的一个元素，异常处理和remove一样；
removeLast()：移除后端的一个元素，和remove一样的效果；
pollFirst()：移除前端的一个元素，和poll一样的效果；
pollLast()：移除后端的一个元素，异常处理和poll一样；
getFirst()：获取前端的一个元素，和element一样的效果；
getLast()：获取后端的一个元素，异常处理和element一样；
peekFirst()：获取前端的一个元素，和peek一样的效果；
peekLast()：获取后端的一个元素，异常处理和peek一样；
removeFirstOccurrence(Object o)：从前端开始移除第一个是o的元素；
removeLastOccurrence(Object o)：从后端开始移除第一个是o的元素；
push(E e)：和addFirst一样的效果；
pop()：和removeFirst一样的效果。

package cn.com.easyExcel.point;
 
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import lombok.Data;
import lombok.NoArgsConstructor;
 
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
 
 
@Data
@NoArgsConstructor
public class PointValue implements Serializable {
    private static final long serialVersionUID = -3925356810846060856L;
 
    // 值
    public BigDecimal value;
 
    // 某时刻
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @JsonSerialize(using = LocalDateTimeSerializer.class)
    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
    public LocalDateTime time;
 
    public static PointValue of(BigDecimal value, LocalDateTime time) {
        PointValue pointPower = new PointValue();
        pointPower.setValue(value);
        pointPower.setTime(time);
        return pointPower;
    }
}

package cn.com.easyExcel.point;
 
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import lombok.NoArgsConstructor;
 
import java.io.Serializable;
import java.util.Deque;
import java.util.LinkedList;
import java.util.concurrent.LinkedBlockingDeque;
 
/**
 * 双向队列
 *
 **/
@Data
@NoArgsConstructor
public class PointValueQueue implements Serializable {
    private static final long serialVersionUID = 5938295366928195243L;
 
    private Long pointId;
 
    private String pointName;
 
    private LinkedBlockingDeque<PointValue> queue = new LinkedBlockingDeque<PointValue>();
 
    public static PointValueQueue of(Long pointId, String pointName) {
        PointValueQueue pointValueQueue = new PointValueQueue();
        pointValueQueue.setPointId(pointId);
        pointValueQueue.setPointName(pointName);
        return pointValueQueue;
    }
 
    /**
     * 新增元素, 队尾
     *
     * @param pointValue
     */
    public void addLast(PointValue pointValue) {
        this.queue.addLast(pointValue);
    }
 
    /**
     * 获取队首元素值, 不移除, 队列为空时, 抛出异常
     *
     * @return
     */
    @JsonIgnore
    public PointValue getFirst() {
        return this.queue.getFirst();
    }
 
    /**
     * 获取队首元素值, 不移除, 队列为空时, 返回null
     *
     * @return
     */
    @JsonIgnore
    public PointValue peekFirst() {
        return this.queue.peekFirst();
    }
 
    /**
     * 获取队尾元素值, 不移除
     *
     * @return
     */
    @JsonIgnore
    public PointValue getLast() {
        return this.queue.getLast();
    }
 
    /**
     * 获取队首元素值, 移除
     *
     * @return
     */
    public PointValue poll() {
        return this.queue.poll();
    }
 
    /**
     * 获取队列当前大小
     *
     * @return
     */
    public int size() {
        return this.queue.size();
    }
 
    /**
     * 是否为空队列
     *
     * @return
     */
    @JsonIgnore
    public boolean isEmpty() {
        return this.queue.isEmpty();
    }
 
    /**
     * 清空
     */
    public void clear() {
        this.queue.clear();
    }
 
}

package cn.com.easyExcel;
 
import cn.com.easyExcel.point.PointValue;
import cn.com.easyExcel.point.PointValueQueue;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import org.junit.jupiter.api.Test;
 
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
 
/**
 * @description:测试写队列
 * LinkedBlockingQueue和LinkedBlockingDeque，两个都是队列，只不过前者只能一端出一端入，后者则可以两端同时出入，
 * 并且都是结构改变线程安全的队列。其实两个队列从实现思想上比较容易理解，
 * 有以下特点：
 * 链表结构（动态数组）
 * 通过ReentrantLock实现锁
 * 利用Condition实现队列的阻塞等待，唤醒
 *
 */
public class DequeDemoTest {
 
    @Test
    public void LinkedBlockingDeque() {
        //字符串池
        String key = StringPool.EMPTY;
        Map<Long, PointValueQueue> queueMap = getSet();
        for (int i = 0; i <20 ; i++) {
            // 队列
            PointValueQueue pointValueQueue = Optional.ofNullable(queueMap.get((long)i)).orElse(PointValueQueue.of((long)i, i+""));
 
            System.out.println((i)+"之前：："+pointValueQueue);
            // 队尾元素
            PointValue tail = pointValueQueue.getLast();
            // 队首元素
            PointValue head = pointValueQueue.getFirst();
            if(i%3==0){
                //pointValueQueue.clear();
                // 获取队首元素值, 移除
                pointValueQueue.poll();
                System.out.println((i)+"之后：：：：："+pointValueQueue);
            }
            if(i==10){
                pointValueQueue.clear();
                System.out.println((i)+"最后：：：：："+pointValueQueue);
            }
        }
    }
 
    //设置值
    private  Map<Long, PointValueQueue> getSet(){
        Map<Long, PointValueQueue> roomSuspectedQueue=new HashMap<Long, PointValueQueue>();
        for (int i = 0; i < 20; i++) {
            PointValueQueue pointValueQueue = PointValueQueue.of((long)i, i + "");
            for (int j = 0; j <10 ; j++) {
                LocalDateTime now = LocalDateTime.now();
                LocalDateTime time = now.plusHours(j);
                //功率
                BigDecimal p = new BigDecimal(""+j);
                // 队列新元素
                PointValue pointValue = PointValue.of(p, time);
                // 更新队列
                pointValueQueue.addLast(pointValue);
            }
            roomSuspectedQueue.put((long)i,pointValueQueue);
        }
     return roomSuspectedQueue;
    }
}