Java队列栈

参考低调人生的博客，网址：https://www.cnblogs.com/lemon-flm/p/7877898.html

一、栈为后进先出。

 

Stack<Integer> stack=new Stack<Integer>(); //java 栈  后进先出

例子：

package test;

import java.util.Stack;

public class JavaStack {
    
    /*
     Java Stack 类
            栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
            堆栈只定义了默认构造函数，用来创建一个空栈。 堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法。
     * */
    public static void stackTest(){
       
        Stack<Integer> stack=new Stack<Integer>(); //java 栈  后进先出
        Stack<Integer> stack2=new Stack<Integer>(); //java 栈  后进先出
        
        for(int i=0;i<5;i++){
            int y=stack.push(i);//把项压入堆栈顶部
            boolean y2=stack2.add(i);
            //System.out.println("y="+y+"  y2="+y2);
            System.out.println("添加值为"+y+",目前栈集合为："+stack+"  --栈顶为"+stack.peek());
        }
        
        int t=stack.peek();//查看堆栈顶部对象
        //int t2=stack2.peek();//查看堆栈顶部对象
        System.out.println("获取栈顶元素为="+t);  
    } 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        stackTest();//栈测试
       
    }

}

2、队列是先进先出

Queue：是FIFO（先入先出）的数据结构。其中，LinkedList实现了Deque接口。

1、没有实现的阻塞接口的LinkedList： 实现了java.util.Queue接口和java.util.AbstractQueue接口
　　内置的不阻塞队列： PriorityQueue 和 ConcurrentLinkedQueue
　　PriorityQueue 和 ConcurrentLinkedQueue 类在 Collection Framework 中加入两个具体集合实现。 
　　PriorityQueue 类实质上维护了一个有序列表。加入到 Queue 中的元素根据它们的天然排序（通过其 java.util.Comparable 实现）或者根据传递给构造函数的 java.util.Comparator 实现来定位。
　　ConcurrentLinkedQueue 是基于链接节点的、线程安全的队列。并发访问不需要同步。因为它在队列的尾部添加元素并从头部删除它们，所以只要不需要知道队列的大 小，　　　　    　　ConcurrentLinkedQueue 对公共集合的共享访问就可以工作得很好。收集关于队列大小的信息会很慢，需要遍历队列。

2)实现阻塞接口的：
　　java.util.concurrent 中加入了 BlockingQueue 接口和五个阻塞队列类。它实质上就是一种带有一点扭曲的 FIFO 数据结构。不是立即从队列中添加或者删除元素，线程执行操作阻塞，直到有空间或者元素可用。
五个队列所提供的各有不同：
　　* ArrayBlockingQueue ：一个由数组支持的有界队列。
　　* LinkedBlockingQueue ：一个由链接节点支持的可选有界队列。
　　* PriorityBlockingQueue ：一个由优先级堆支持的无界优先级队列。
　　* DelayQueue ：一个由优先级堆支持的、基于时间的调度队列。
　　* SynchronousQueue ：一个利用 BlockingQueue 接口的简单聚集（rendezvous）机制。

 

 

package queue;

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

 

 

生产者准备生产苹果：1552837572335
消费者准备消费苹果：1552837572335
生产者生产苹果完毕：1552837572336
消费者消费苹果完毕：1552837572336
生产完后有苹果：0个
消费完后有苹果：0个
生产者准备生产苹果：1552837572636
生产者生产苹果完毕：1552837572636
生产完后有苹果：1个
生产者准备生产苹果：1552837572936
生产者生产苹果完毕：1552837572936
生产完后有苹果：2个
生产者准备生产苹果：1552837573236
生产者生产苹果完毕：1552837573236
生产完后有苹果：3个
消费者准备消费苹果：1552837573336
消费者消费苹果完毕：1552837573336
消费完后有苹果：2个
生产者准备生产苹果：1552837573536
生产者生产苹果完毕：1552837573536
生产完后有苹果：3个
生产者准备生产苹果：1552837573836
消费者准备消费苹果：1552837574336
生产者生产苹果完毕：1552837574336
生产完后有苹果：3个
消费者消费苹果完毕：1552837574337
消费完后有苹果：3个
生产者准备生产苹果：1552837574638
消费者准备消费苹果：1552837575338
生产者生产苹果完毕：1552837575338
生产完后有苹果：3个
消费者消费苹果完毕：1552837575338
消费完后有苹果：3个
生产者准备生产苹果：1552837575638
消费者准备消费苹果：1552837576338
生产者生产苹果完毕：1552837576338
生产完后有苹果：3个
消费者消费苹果完毕：1552837576338
消费完后有苹果：3个
生产者准备生产苹果：1552837576638
消费者准备消费苹果：1552837577338
生产者生产苹果完毕：1552837577338
生产完后有苹果：3个
消费者消费苹果完毕：1552837577338
消费完后有苹果：3个
生产者准备生产苹果：1552837577638
消费者准备消费苹果：1552837578338
生产者生产苹果完毕：1552837578338
生产完后有苹果：3个
消费者消费苹果完毕：1552837578338
消费完后有苹果：3个
生产者准备生产苹果：1552837578638
消费者准备消费苹果：1552837579339
消费者消费苹果完毕：1552837579339
生产者生产苹果完毕：1552837579339
消费完后有苹果：3个
生产完后有苹果：3个
生产者准备生产苹果：1552837579639
消费者准备消费苹果：1552837580339
消费者消费苹果完毕：1552837580339
消费完后有苹果：2个
生产者生产苹果完毕：1552837580340
生产完后有苹果：3个
生产者准备生产苹果：1552837580640
消费者准备消费苹果：1552837581340
消费者消费苹果完毕：1552837581340
消费完后有苹果：2个
生产者生产苹果完毕：1552837581340
生产完后有苹果：3个
生产者准备生产苹果：1552837581641
消费者准备消费苹果：1552837582340
生产者生产苹果完毕：1552837582340
生产完后有苹果：3个
消费者消费苹果完毕：1552837582340
消费完后有苹果：3个