精华内容
下载资源
问答
  • java队列实现类有哪些
    千次阅读
    2021-02-12 11:07:48

    掌握基础知识,面试事半功倍。即将踏上Java开发岗位的同学们,一起来复习一下面试必备的基础知识吧。本文沈阳达内IT培训为大家介绍Java中的队列都有哪些,有什么区别?

    1.BlockingQueue有四个具体的实现类,根据不同需求,选择不同的实现类:

    2.ArrayBlockingQueue:基于数组结构的有界阻塞队列,规定大小的BlockingQueue,其构造函数必须带一个int参数来指明其大小。

    其所含的对象是以FIFO(先入先出)顺序排序的

    3.LinkedBlockingQueue:基于链表结构的阻塞队列,大小不定的BlockingQueue,若其构造函数带一个规定大小的参数,生成的BlockingQueue有大小限制,若不带大小参数,所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定。其所含的对象是以FIFO顺序排序的,吞吐量通常要高于ArrayBlockingQueue

    4.PriorityBlockingQueue:具有优先级的无限阻塞队列,类似于LinkedBlockingQueue,但其所含对象的排序不是FIFO,而是依据对象的自然排序顺序或者是构造函数所带的Comparator决定的顺序

    5.SynchronousQueue:不存储元素的阻塞队列,对其的操作必须是放和取交替完成的,每个插入操作必须等到另一个线程调用移除操作,否则插入操作一直处于阻塞状态,吞吐量通常要高于LinkedBlockingQueue

    6.LinkedBlockingQueue和ArrayBlockingQueue比较起来,它们背后所用的数据结构不一样,导致LinkedBlockingQueue的数据吞吐量要大于ArrayBlockingQueue,但在线程数量很大时其性能的可预见性低于ArrayBlockingQueue

    更多相关内容
  • Java队列实现

    万次阅读 多人点赞 2017-09-19 11:42:26
    一、队列简单介绍队列是一种常用的数据结构之一,与...二、队列实现队列很多种,这里只是介绍最基本的实现,采用链式存储,也就是链式队列,与之前的链表存储形式一样,通过结点对象描述一个数据,结点对象包含具体数

    一、队列简单介绍

    队列是一种常用的数据结构之一,与之前的栈类似,不过队列是“先进先出”。队列有队头(front)和队尾(rear),数据从队尾进入队列,从队头出队列,队头(front)指向队列的第一个数据,队尾(rear)指向队列中的最后一个数据。
    这里写图片描述

    二、队列实现

    队列有很多种,这里只是介绍最基本的实现,采用链式存储,也就是链式队列,与之前的链表存储形式一样,通过结点对象描述一个数据,结点对象包含具体数据和下一个结点的引用。

    1、创建节点类

    结点类就跟创建链表的结点类一样。

    public class Node<T> {
        // 存储的数据
        private T data;
        // 下一个节点的引用
        private Node<T> next;
    
        public Node(T data) {
            this.data = data;
        }
    
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    
        public Node<T> getNext() {
            return next;
        }
    
        public void setNext(Node<T> next) {
            this.next = next;
        }
    
    }

    2、创建队列类LinkQueue

    在LinkQueue类中成员变量及方法如下:
    成员变量:front、rear、size
    对应的行为方法有:入队、出队、获取队列元素个数、判断队列是否为空。

    public class LinkQueue<T> {
    
        // 队头
        private Node<T> front;
        // 队尾
        private Node<T> rear;
        // 元素个数
        private int size;
    
        /**
         * 创建队列
         */
        public LinkQueue() {
            rear = front = null;
        }
    
        /**
         * 入队列
         * 
         * @param data
         */
        public void enQueue(T data) {
            Node<T> node = new Node<T>(data);
            if (isEmputy()) {
                front = rear = node;
            } else {
                rear.setNext(node);
                rear = node;
            }
    
            size++;
        }
    
        /**
         * 出队列
         * 
         * @return 返回数据
         */
        public T deQueue() {
            if (isEmputy()) {
                throw new RuntimeException("队列为空");
            }
    
            Node<T> delete = front;
            front = delete.getNext();
            delete.setNext(null);; // help GC
            size--;
    
            if (size == 0) {
                // 删除掉最后一个元素时,front值已经为null,但rear还是指向该节点,需要将rear置为null
                // 最后一个结点front和rear两个引用都没指向它,帮助GC处理该节点对象
                rear = front;
            }
    
            return (T) delete.getData();
        }
    
        /**
         * 判断队列是否为空
         * @return 
         */
        public boolean isEmputy() {
            return (front == null && rear == null) ? true : false;
        }
    
        /**
         * 获取队列的元素个数
         * @return
         */
        public int size() {
            return this.size;
        }
    
    }

    当创建队列时队列中没有数据,front和rear的值都为null。当插入第一个数据时,将front和rear都指向第一个结点对象
    这里写图片描述

    后续在插入数据时就利用rear进行数据的插入。
    这里写图片描述

    3、测试

    测试代码及结果如下:

    public static void main(String[] args) {
            LinkQueue<Integer> queue = new LinkQueue<Integer>();
    
            queue.enQueue(1);
            queue.enQueue(2);
            queue.enQueue(3);
            queue.enQueue(4);
    
            System.out.println("size:" + queue.size());
    
            System.out.println("出队列:" + queue.deQueue());
            System.out.println("出队列:" + queue.deQueue());
            System.out.println("出队列:" + queue.deQueue());
            System.out.println("出队列:" + queue.deQueue());
    
            System.out.println("删完重新添加==============");
            queue.enQueue(11);
            queue.enQueue(22);
            queue.enQueue(33);
            queue.enQueue(44);
    
            System.out.println("size:" + queue.size());
    
            System.out.println("出队列:" + queue.deQueue());
            System.out.println("出队列:" + queue.deQueue());
            System.out.println("出队列:" + queue.deQueue());
            System.out.println("出队列:" + queue.deQueue());
        }
    size4
    出队列:1
    出队列:2
    出队列:3
    出队列:4
    删完重新添加==============
    size4
    出队列:11
    出队列:22
    出队列:33
    出队列:44

    好了,java队列的简单实现就介绍到这里。


    生活不只是敲代码,如果你或你身边的人喜欢摄影或者生活的点点滴滴,可以关注下面的公众号~
    这里写图片描述

    展开全文
  • BlockingQueue接口 – 阻塞队列2.1 ArrayBlockingQueue界阻塞队列)2.2 LinkedBlockingQueue(无界阻塞队列)3. 源码:BlockingQueue实现生产者消费者模式→ 输出结果截图 1. Queue接口 – 队列 public ...
  • 数据结构_队列_Java中的实现类

    千次阅读 2020-06-21 15:42:41
    我们对基础的数据结构队列都非常的熟悉,这里回顾下 ...Java 中的队列可以利用实现 Deque 接口的类作为实现类, Deque 的实现类主要分为两种场景: 一般场景 LinkedList 大小可变的链表双端队列,允许元素为 nu...

     我们对基础的数据结构队列都非常的熟悉,这里回顾下

     

     

    队列是一种先进先出(First in First Out)的线性表,简称FIFO。允许插入的一端称为队尾,允许删除的一端称为队头

     

    它有两个基本操作:

     

    • offer

    在队列尾部加人一个元素

     

    • poll

    从队列头部移除一个元素

     

     

    Java 中的队列可以利用实现 Deque 接口的类作为实现类,

    Deque 的实现类主要分为两种场景:

    • 一般场景
      • LinkedList 大小可变的链表双端队列,允许元素为 null
      • ArrayDeque 大下可变的数组双端队列,不允许 null
    • 并发场景
      • LinkedBlockingDeque 如果队列为空时,获取操作将会阻塞,知道有元素添加

     

     

     

    LinkedList 主要是实现了  java.util.Deque  接口

    Deque  实现了 java.util.Queue  接口

    Deque 实现了 java.util.Collection 接口

    就LinkedList 作为队列使用,做个示例

    package leetcode;
    
    import java.util.Deque;
    import java.util.LinkedList;
    
    /**
     * Created by szh on 2020/6/21.
     * @author szh
     */
    public class QueueTest {
    
        public static void main(String[] args){
    
            Deque<Integer> stack = new LinkedList<>();
            //This method is equivalent to {@link #addFirst}.
            stack.offer(2);
            stack.offer(3);
            stack.offer(4);
            stack.offer(5);
            stack.offer(6);
    
            //view the stack first value
            System.out.println("view the first value : " + stack.peekFirst());
            System.out.println(stack.poll());
            System.out.println(stack.poll());
            System.out.println(stack.poll());
            System.out.println(stack.poll());
            System.out.println(stack.poll());
    
        }
    
    
    }
    

     

     

     

     

     

     

     

    展开全文
  • Java中的常用队列

    万次阅读 多人点赞 2022-01-15 16:50:54
    简述了队列的概念以及java中常见的队列,并阐述了各队列的区别与联系。

    一、队列的理解

    队列是一种由数组和链表作为底层构造的只暴露头和尾操作API的数据结构,因此,队列是被认为是一种受限的数据结构。
    队列的特性是:先进先出,类似于排队,原理如下图所示
    在这里插入图片描述

    二、Java中队列简述

    队列Queue与Set和List同级,都继承了Collection,其次,双端队列接口Deque、阻塞队列BlockingQueue和非阻塞队列AvstractQueue实现了Queue接口,以下简述这三个类型的队列。
    在这里插入图片描述

    2.1 Queue队列

    Queue是java中实现队列的接口,它总共只有6个方法,如下:
    Queue的6个方法分类:

    压入元素(添加):add()、offer()
    相同:未超出容量,从队尾压入元素,返回压入的那个元素。
    区别:在超出容量时,add()方法会对抛出异常,offer()返回false

    弹出元素(删除):remove()、poll()
    相同:容量大于0的时候,删除并返回队头被删除的那个元素。
    区别:在容量为0的时候,remove()会抛出异常,poll()返回false

    获取队头元素(不删除):element()、peek()
    相同:容量大于0的时候,都返回队头元素。但是不删除。
    区别:容量为0的时候,element()会抛出异常,peek()返回null。
    在这里插入图片描述
    引用资料:
    https://blog.csdn.net/devnn/article/details/82591349

    2.2 双端队列

    deque 是“double ended queue(双端队列)”的缩写,通常读为“deck”。双端队列顾名思义就是队列的两个端口都能进出。

    Deque的实现类是LinkedList,ArrayDeque,LinkedBlockingDeque,其中LinkedList是最常用的。值得注意的是,LinkedList也实现了List接口。

    大多数Deque既可以是有容量限制也可以是无固定容量限制。

    双端队列的插入、删除和检查方法各有两种形式,如下:
    在这里插入图片描述
    值得注意的是,插入操作要使用插入操作的特殊值形式,因为插入操作一般不允许失败。

    由于双端队列的既能实现先进先出,也能实现先进后出,因此,双端队列一般有三种用途

     - 作为普通队列(先进先出)
     Queue queue = new LinkedList()Deque deque = new LinkedList()
     - 作为堆栈(先进后出)
     Deque deque = new LinkedList()
    - 作为双端队列(两端可进出)
    Deque deque = new LinkedList()
    

    值得注意的是,Java堆栈Stack类已经过时,Java官方推荐使用Deque替代Stack使用。Deque堆栈操作方法:push()、pop()、peek()。

    以下是双端队列从Queue接口继承方法的等效对比:
    在这里插入图片描述
    以下是双端队列与堆栈方法的等效方法对比:
    在这里插入图片描述
    文章中引用资料的链接:
    https://blog.csdn.net/devnn/article/details/82716447

    2.3 阻塞队列

    1、理解
    阻塞队列是一个支持两个附加操作的队列,即在队列为满时,存储元素的线程会等待队列可用,当队列为空时,获取元素的线程会等待队列为非空。
    2、Java中的阻塞队列
    阻塞队列接口有BlockingQueueBlockingDeque两个,其中后者是双向队列。
    其中BlockingQueue接口提供的方法如下:
    在这里插入图片描述
    BlockingDeque接口提供的方法如下:
    头部元素:
    尾部元素:
    在这里插入图片描述
    常见的阻塞队列有:
    ArrayBlockingQueue : 一个由数组结构组成的有界阻塞队列。
    LinkedBlockingQueue : 一个由链表结构组成的有界阻塞队列。
    PriorityBlockingQueue : 一个支持优先级排序的无界阻塞队列。
    DelayQueue: 一个使用优先级队列实现的无界阻塞队列。
    SynchronousQueue: 一个不存储元素的阻塞队列。
    LinkedTransferQueue: 一个由链表结构组成的无界阻塞队列。
    LinkedBlockingDeque: 一个由链表结构组成的双向阻塞队列

    具体的实现方法没有深究,有兴趣的可以看引用资料:
    阻塞队列详解

    2.4 非阻塞队列

    1、理解
    非阻塞队列不能阻塞,个人理解为普通队列,在多线程中,当队列满或空时,只能使用wait()和notify()进行队列消息传送。
    2、Java中的非阻塞队列
    AbstractQueue是非阻塞队列的接口,常见的非阻塞实现类有:

    • LinkedList
    • PriorityQueue
    • ConcurrentLinkedQueue

    (1)LinkedList
    既实现了AbstractQueue接口也实现了Deque接口,也可作为双端队列使用。
    (2)PriorityQueue
    该类维护了一个有序队列,默认队头是规则排序中最小的元素,若多个最小值,则随机挑选。
    排序的规则是通过构造函数comparator来实现,因此,该队列不允许插入null值或不可比较的对象。
    (3)ConcurrentLinkedQueue
    该类是基于链接点的线程安全队列,并发访问不需要同步。因为它在队列的尾部添加元素并从头部删除它们,所以只要不需要知道队列的大小,ConcurrentLinkedQueue 对公共集合的共享访问就可以工作得很好。收集关于队列大小的信息会很慢,需要遍历队列。此队列不允许使用null元素,

    3、操作方法
    add(E e):将元素 e 插入到队列末尾,如果插入成功,则返回 true;如果插入失败(即队列已满),则会抛出异常;

    remove():移除队首元素,若移除成功,则返回 true;如果移除失败(队列为空),则会抛出异常;

    remove(Object o):移除指定的元素,若移除成功,则返回 true;如果移除失败(队列为空),则会抛出异常

    offer(E e):将元素 e 插入到队列末尾,如果插入成功,则返回 true;如果插入失败(即队列已满),则返回 false;

    poll():移除并获取队首元素,若成功,则返回队首元素;否则返回 null;

    peek():获取队首元素,若成功,则返回队首元素;否则返回 null

    isEmpty():队列是否为空

    size():队列长度

    值得注意的是,一般情况下建议使用 offer、poll 和 peek 三个方法,不建议使用 add 和 remove 方法。因为使用 offer、poll 和 peek 三个方法可以通过返回值判断操作成功与否,而使用 add 和 remove 方法却不能达到这样的效果。
    尤其对于插入操作,往往使用返回特殊值的方法。

    引用资料:
    https://blog.csdn.net/zyx1260168395/article/details/103656994

    三、各队列的区别与联系

    以下为个人理解,不正确请指正。
    1、从数据的输入和输出角度来看,队列可以看成是普通和双端两种,普通队列是先进先出,而双端则可以两端进出。
    2、从并发角度来看,队列可以看成阻塞和非阻塞两种,阻塞队列能实现阻塞,而非阻塞不能阻塞,阻塞和非阻塞队列都有普通队列和双端队列特性的实现类。

    展开全文
  • JAVA实现队列类

    千次阅读 2019-02-24 19:22:54
    本文使用java中的数据和列表来实现队列类,从而更加详细和直观的理解队列的使用和性质。 1、使用数组实现队列 public class QueueWithArray { private int [] queueArray; private int front ...
  • Java循环队列实现方法

    千次阅读 2021-03-08 06:51:39
    Java循环队列实现方法时间:2017-09-13来源:华清远见JAVA学院生活中很多队列的影子,比如打饭排队,买火车票排队问题等,可以说与时间相关的问题,一般都会涉及到队列问题。那么Java如何实现循环队列呢?今天...
  • Java redis实现消息队列

    千次阅读 2021-07-01 11:16:00
    文章目录一、单元测试Java多线程二、redis实现消息队列三、java多线程模拟生产者消费者 一、单元测试Java多线程 使用junit测试多线程代码,但是等到程序结束,输出结果不完整,或者是完全没结果,因此,可能是其他...
  • java实现延时队列

    千次阅读 2021-05-14 09:14:25
    延时队列主要应用场景是用户登录后延时推送消息,通知等,一般用mq中间件来弄,下面我来用java实现 一、消息实体类实现Delayed接口 import lombok.Data; import java.util.concurrent.Delayed; import java.util...
  • java实现队列类

    2006-02-23 09:05:59
    java2里面没有提供标准队列的支持,我就编写了一个用java实现队列类。可以供参考。
  • java队列实现入队push和出队pop

    千次阅读 2021-12-08 17:36:42
    那我们所说的数组来实现就是队列是由数组定义的,让它来实现先入先出,后入后出: 入队方法就是给数组增加元素,我们需要定义一个指针end,把指针指向队尾,每次添加一个元素就让end指针向后移,假如我们添加3个...
  • java实现队列(queue)数据结构

    千次阅读 2022-02-01 21:57:08
    队列是一种非原始(特殊)的线性表,是一种先进先出(FIFO)的数据结构。它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作。 FIFO:first input first output,即先添加的元素,先移除...
  • 1.java实现延迟消息(队列DelayQueue) DelayQueue是一个支持延时获取元素的无界阻塞队列队列使用PriorityQueue来实现队列中的元素必须实现Delayed接口,在创建元素时可以指定多久才能从队列中获取当前元素。...
  • 消息队列 | java简单实现

    千次阅读 2021-06-20 17:36:29
    1. 消息队列介绍: 消息队列是MQ是一种系统间相互写作的通信机制 Broker:消息处理中心,负责消息的接收、存储、转发等;...这里采用java中队列(Queue)的一个子类ArrayBockingQueue来实现。 如下是消
  • Java 阻塞队列实现串口数据读取监听

    千次阅读 2021-09-07 16:04:34
    这里使用BlockingQueue阻塞队列的方式实现串口数据的读取监听 提示:Java 环境需使用1.6版本及一下的,否则会出现内存 gc,等等异常问题。 RXTXcomm.jar 等ddl 文件下载【附带 配置教程】 :...
  • java实现RabbitMQ消息队列

    千次阅读 2022-04-19 10:43:27
    MQ(Message Queue)消息队列,是基础数据结构中“先进先出”的一种数据结构。一般用来解决应用解耦,异步消息,流量削峰等问题,实现高性能,高可用,可伸缩和最终一致性架构。
  • java并发之非阻塞队列

    千次阅读 2021-02-12 10:37:28
    非阻塞队列有:ArrayDeque、PriorityQueue、ConcurrentLinkedQueue之前都说过阻塞队列了,其实差别都不大,阻塞和非阻塞的区别在于阻塞队列有put和take方法进行阻塞,而非阻塞队列则没有这两个方法,同时poll和offer...
  • java 任务队列

    千次阅读 2021-02-12 10:06:47
    Java任务队列在不断的学习中需要我们掌握很多相关的技术信息。首先,下面我们就看看如何应用TaskQueue的具体问题。Java任务队列需要我们详细的学习,当然我们在不断的使用中还需要注意相关信息的学习。下面我们就先...
  • 1.2 LinkedBlockingQueue 基于链表实现的阻塞队列,该队列不设置大小时就是Integer.MAX_VALUE 其实也是队列,但是不设置大小时就时Integer.MAX_VALUE,内部是基于链表实现的 ArrayBlockingQueue 与 ...
  • Java 优先级队列

    千次阅读 2022-02-25 20:54:37
    Java 优先级队列
  • Java双端队列 典型的双端队列收集如下所示: 双端队列(Deque:double ended queue)就是一个两端都是结尾的队列队列的每一端都可以插入数据项和移除数据项。相对于普通队列,双端队列的入队和出队操作在两端都可...
  • java-简单消息队列实现

    千次阅读 2020-09-05 08:31:02
    简单消息队列实现 wj振藩 分类专栏:消息中间件 分布式消息中间件实践 在消息队列的完整使用场景中至少包含三个角色: 消息处理中心:负责消息的接收、存储、转发等 生产者: 负责产生和发送消息到消息处理...
  • 用栈实现队列Java实现

    万次阅读 2020-07-08 08:27:10
    用栈实现队列(力扣:232)
  • java容器4:Queue深入解读

    千次阅读 2021-02-25 19:42:17
    Collection的其它两大分支:List和Set在...前三篇关于Java容器的文章:Queuepublic interface Queue extends Collection {boolean add(E var1);boolean offer(E var1);E remove();E poll();E element();E peek();...
  • Java 延迟队列 DelayQueue 的原理

    千次阅读 2022-04-08 15:18:16
    一、什么是延迟队列(DelayQueue)? DelayQueue 是 Java 并发包 java.util.concurrent 下的一个 Class,其官方定义如下所示。 /** * An unbounded {@linkplain BlockingQueue blocking queue} of * {@code ...
  • 阻塞队列队列,无界队列

    千次阅读 2021-03-12 16:01:58
    如果要实现一个线程安全的队列有两种方式:一种是使用阻塞算法,另一种是使用非阻塞算法。 使用阻塞算法的队列可以用一个锁(入队和出队用同一把锁)或两个锁(入队和出队用不同的锁)等方式来实现。非阻塞的实现...
  • Java队列、线程池及ThreadPoolExecutor自定义线程池实现
  • Java优先级队列PriorityQueue

    千次阅读 2021-10-29 18:05:16
    目录普通队列对比优先级队列:逆序优先级队列自定义优先级队列的优先级 相较于普通先进先出队列来说,优先级队列会根据优先级进行由高到低排序,出队时优先级高的先出队。 普通队列对比优先级队列: 1.普通队列: ...
  • Java Queue

    千次阅读 2020-08-27 17:39:11
    Queue 队列简介Queue方法Queue子接口BlockingQueueDequeQueue实现类LinkedList 简介 Queue接口与List、Set同一级别,都是继承了Collection接口。 -------| Collection 单例集合的根接口。 ------------| List 如果...
  • java实现的利用Vector(继承)编写一个先进先出的队列类Queue,它两个方法:入队inqueue和出队outqueue。(在主方法中使用该队列: “111”、“222”入队,出队一元素,“333”入队,最后出队所有元素。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 359,998
精华内容 143,999
关键字:

java队列实现类有哪些