Java手写数组队列和链表队列并使用java里面现成的队列方法

于 2023-09-05 17:22:44 发布
阅读量250 收藏
点赞数
分类专栏： 数据结构 文章标签： java 数据结构 链表 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48040732/article/details/132693211
版权

Java队列实现与常用使用方法介绍

说明

这里记录下使用数组和链表手动实现队列功能，并使用java里面现成的队列方法。

使用数组手动实现队列功能

package com.example.deesign_patterns.test;

//java使用数组简单实现队列
public class ArrayQueue {
    private int[] queue;  // 内部数组
    private int front;    // 队列头部指针
    private int rear;     // 队列尾部指针
    private int size;     // 队列当前元素个数
    private int capacity; // 队列容量

    //构造方法,初始化的时候必须要传队列容量值
    public ArrayQueue(int capacity) {
        this.capacity = capacity;
        queue = new int[capacity];
        front = 0;
        rear = -1;
        size = 0;
    }

    //判断是否是空队列
    public boolean isEmpty() {
        return size == 0;
    }

    //判断队列是否已满
    public boolean isFull() {
        return size == capacity;
    }

    //队列元素个数
    public int size() {
        return size;
    }

    //元素入队列
    public void add(int value) {
        if (isFull()) {
            System.out.println("队列已经满了，无法添加队列。");
            return;
        }
        rear = (rear + 1) % capacity; // 循环队列，计算新的尾部位置
        queue[rear] = value;//在数组尾部添加元素
        size++;//如果添加成功，则队列元素数量加1
        System.out.println("入队列元素值: " + value);
    }

    //头部元素出队列,重新计算头部位置,数组索引往后移了一位,相当于删除头元素
    public int pull() {
        if (isEmpty()) {
            System.out.println("队列是空的，无法出队列。");
            return -1;
        }
        int value = queue[front];
        front = (front + 1) % capacity; // 循环队列，计算新的头部位置
        size--;//如果出队列成功，则队列元素数量减1
        System.out.println("出队列元素值: " + value);
        return value;
    }

    //获取队列里面的首元素,不会删除元素
    public int peek() {
        if (isEmpty()) {
            System.out.println("队列是空的!");
            return -1;
        }
        return queue[front];
    }

    //显示队列元素
    public void display() {
        if (isEmpty()) {
            System.out.println("队列是空的!");
            return;
        }
        System.out.print("队列当前元素值: ");
        int index = front;
        for (int i = 0; i < size; i++) {
            System.out.print(queue[index] + " ");
            index = (index + 1) % capacity; // 循环遍历队列
        }
        System.out.println();
    }

    //测试类
    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue(5);
        queue.add(10);
        queue.add(20);
        queue.add(30);
        queue.display(); // Queue: 10 20 30
        queue.pull();
        queue.display(); // Queue: 20 30
        queue.add(40);
        queue.add(50);
        queue.display(); // Queue: 20 30 40 50
        queue.pull();
        queue.pull();
        queue.display(); // Queue: 40 50
        System.out.println("当前队列首元素为："+queue.peek());//Queue: 40
    }
}

执行结果如下:
在这里插入图片描述

使用单向链表手动实现队列功能

单向链表类

package com.example.deesign_patterns.test;

//单向链表类
public class Node<T> {
    public T data;
    public Node next;

    //无参构造方法
    public Node() {}

    //有参构造方法
    public Node(T data, Node next) {
        this.data = data;
        this.next = next;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

队列需要实现的功能接口(也可以在链表队列类里面直接写方法)：

package com.example.deesign_patterns.test;

/**
 * 队列功能接口
 * 队列是一种先进先出的线性表
 * 只能在表的一端进行插入，另一段进行删除
 * 允许插入的一端叫队尾，允许删除的一端叫队头（）
 */
public interface IQueue<T> {
    /**
     * 初始化队列 构造一个空队列
     */
    IQueue InitQueue();

    /**
     * 销毁队列
     */
    IQueue DestroyQueue();

    /**
     * 清空队列
     */
    IQueue ClearQueue();

    /**
     * 队列判空
     */
    Boolean isEmpty();

    /**
     * 返回队列长度
     */
    Integer QueueLength();

    /**
     * 返回队列头元素
     */
    T GetHead();

    /**
     * 插入队尾元素
     */
    Boolean EnQueue(T e);

    /**
     * 删除队头元素  即出队
     */
    T DeQueue();

    /**
     * 打印队列元素
     */
    void printQueue();
}

链表队列类:

package com.example.deesign_patterns.test;

//java使用链表简单实现队列
public class LinkedQueue<T> implements IQueue<T> {
    private  Node<T> front;//队头指针
    private  Node<T> rear;//队尾指针
    private int size;//队列长度

    //无参构造方法
    public LinkedQueue() {
        front = null;
        rear = null;
        size = 0;
    }

    //初始化队列方法
    @Override
    public IQueue InitQueue() {
        front = null;
        rear = null;
        size = 0;
        return this;
    }

    //销毁队列方法
    @Override
    public IQueue DestroyQueue() {
        //销毁
        front = null;
        rear = null;
        size = 0;
        return this;
    }

    //清空队列方法
    @Override
    public IQueue ClearQueue() {
        front = null;
        rear = null;
        size = 0;
        return this;
    }

    //判断队列是否为空
    @Override
    public Boolean isEmpty() {
        return size == 0;
    }

    //判断队列长度
    @Override
    public Integer QueueLength() {
        return size;
    }

    //获取队列里面的首元素
    @Override
    public T GetHead() {
        if (isEmpty()) {
            return null;
        }
        return front.getData();
    }

    //将元素入队
    @Override
    public Boolean EnQueue(T e) {
        Node<T> newNode = new Node<>(e, null);
        if (isEmpty()) {
            front = newNode;
        } else {
            rear.setNext(newNode);
        }
        rear = newNode;
        size++;
        return true;
    }

    //将元素出队
    @Override
    public T DeQueue() {
        if (isEmpty()) {
            return null;
        }
        T data = front.getData();
        front = front.getNext();
        size--;
        if (isEmpty()) {
            rear = null;
        }
        return data;
    }

    @Override
    public void printQueue() {
        for (Node current = front;current != null;current = current.next){
            System.out.print(current.data+" ");
        }
        System.out.println();
    }
	
	//测试类
    public static void main(String[] args) {
        IQueue<Integer> queue = new LinkedQueue<>();
        queue.InitQueue();
        queue.EnQueue(1);
        queue.EnQueue(2);
        queue.EnQueue(3);
        System.out.println("队列长度: " + queue.QueueLength());
        queue.printQueue();//打印队列值
        System.out.println("队头元素: " + queue.GetHead());
        System.out.println("出队元素: " + queue.DeQueue());
        System.out.println("出队元素: " + queue.DeQueue());
        System.out.println("出队元素: " + queue.DeQueue());
        queue.printQueue();//打印队列值
        System.out.println("队列长度: " + queue.QueueLength());
        System.out.println("队列是否为空: " + queue.isEmpty());
    }
}

在这里插入图片描述

Java中ArrayBlockingQueue和ArrayQueue和LinkedBlockingQueue使用

在Java中，ArrayBlockingQueue和ArrayQueue是两种不同的队列实现。它们之间有以下区别：

  1. 数据结构不同：ArrayBlockingQueue是基于数组的有界阻塞队列，它的容量是固定的。而ArrayQueue是基于数组的无界队列，它的容量可以动态增长。
  2. 插入和删除操作的不同：ArrayBlockingQueue的插入和删除操作是线程安全的，并且支持阻塞操作。当队列已满时，插入操作将会被阻塞，直到有空间可用；当队列为空时，删除操作将会被阻塞，直到有元素可用。而ArrayQueue的插入和删除操作不是线程安全的，需要自行处理同步。
  3. 性能方面的不同：由于ArrayBlockingQueue支持阻塞操作，它在多线程环境下具有更好的线程安全性。然而，由于需要处理同步和阻塞，它的性能相对较低。相比之下，ArrayQueue在单线程环境下的性能更好，不需要处理同步和阻塞。

ArrayQueue使用方法如下:

package com.example.deesign_patterns.test;

import com.sun.jmx.remote.internal.ArrayQueue;

public class Test3Main {

    public static void main(String[] args) {
        //数组队列使用,给数组一个大小，当数组里面的元素数量超过5，就会报错，可以通过resize()方法扩容
        ArrayQueue arrayQueue=new ArrayQueue<Integer>(5);
        arrayQueue.add(1);//入队列
        arrayQueue.add(2);
        arrayQueue.add(3);
        arrayQueue.add(4);
        arrayQueue.add(5);
        System.out.println("当前队列元素:"+arrayQueue);
        System.out.println("当前队列大小:"+arrayQueue.size());
        System.out.println("获取当前队列索引为1的元素:"+arrayQueue.get(1));
        //重新设置队列大小,相当于扩容,扩容后大小由原来的5变为6,值必须比原来大
        arrayQueue.resize(6);
        arrayQueue.add(6);
        System.out.println("当前队列元素:"+arrayQueue);
        System.out.println("当前队列大小:"+arrayQueue.size());
        //只能删除队列头元素,必须是索引0,不为0报错,相当于出队列
        arrayQueue.remove(0);
        System.out.println("当前队列元素:"+arrayQueue);
    }
}

在这里插入图片描述

ArrayBlockingQueue常用使用方法如下:

在Java中，ArrayBlockingQueue是一个具有固定容量的阻塞队列。它的实现是基于数组的，它实现了BlockingQueue接口，提供了一组方法用于操作队列中的元素。

  1. add(element)：向队列尾部添加一个元素，如果队列已满，则IllegalStateExceptio异常。
  2. offer(element)：向队列尾部添加一个元素，如果队列已满，则返回false。
  3. put(element)：向队列尾部添加一个元素，如果队列已满，则会一直阻塞直到队列有空闲位置。
  4. poll()：从队列头部移除并返回一个元素，如果队列为空，则返回null。
  5. take()：从队列头部移除并返回一个元素，如果队列为空，则会一直阻塞直到队列有元素可取。
  6. peek()：获取队列头部的元素，但不会移除该元素。
  7. size()：返回队列中当前元素的数量。
  8. remainingCapacity()：返回队列中剩余的可用容量。
  9. isEmpty(): 判断队列是否为空，如果队列为空则返回true，否则返回false。
package com.example.deesign_patterns.test;

import java.util.concurrent.ArrayBlockingQueue;

public class Test3Main {

    public static void main(String[] args) {
        //数组队列使用,必须给数组一个大小，当数组里面的元素数量超过5，就会报错，不能扩容
        ArrayBlockingQueue queue=new ArrayBlockingQueue(5);
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        queue.add(5);
        System.out.println("当前队列元素:"+queue);
        System.out.println("当前队列大小:"+queue.size());
        System.out.println("队列已满返回boolean值为:"+queue.offer(6));
        System.out.println("获取队列头部元素:"+queue.peek());
        //出队列
        queue.poll();
        System.out.println("当前队列元素:"+queue);
        System.out.println("当前队列可用容量:"+ queue.remainingCapacity());
    }
}

在这里插入图片描述

LinkedBlockingQueue常用使用方法如下:

LinkedBlockingQueue是一个线程安全的队列，它的实现是基于链表的。LinkedBlockingQueue的容量可以是无限的。

常用使用方法和ArrayBlockingQueue队列方法一样

package com.example.deesign_patterns.test;

import java.util.concurrent.LinkedBlockingQueue;

public class Test3Main {

    public static void main(String[] args) {
        //链表队列使用
        //如果没有给链表一个大小，默认值是Integer.MAX_VALUE
        //LinkedBlockingQueue queue=new LinkedBlockingQueue();
        //如果给链表一个大小，当链表里面的元素数量超过5，就会报错，不能扩容
        LinkedBlockingQueue queue=new LinkedBlockingQueue(5);
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        queue.add(5);
        System.out.println("当前队列元素:"+queue);
        System.out.println("当前队列大小:"+queue.size());
        System.out.println("队列已满返回boolean值为:"+queue.offer(6));
        System.out.println("获取队列头部元素:"+queue.peek());
        //出队列
        queue.poll();
        System.out.println("当前队列元素:"+queue);
        System.out.println("当前队列可用容量:"+ queue.remainingCapacity());
    }
}

在这里插入图片描述

ArrayBlockingQueue和LinkedBlockingQueue区别

Java中的ArrayBlockingQueue和LinkedBlockingQueue都是实现了BlockingQueue接口，用于实现多线程环境下的阻塞队列。它们之间的区别主要有以下几个方面：

  1. 数据结构：ArrayBlockingQueue使用数组作为底层数据结构，而LinkedBlockingQueue使用链表作为底层数据结构。这导致了它们在插入和删除操作上的性能特点不同。
  2. 队列大小：ArrayBlockingQueue有一个固定的容量，需要在创建时指定大小，而LinkedBlockingQueue的容量是可选的，默认为Integer.MAX_VALUE。
  3. 线程阻塞：ArrayBlockingQueue在插入和删除元素时，如果队列已满或为空，操作线程会被阻塞，直到有可用的空间或元素可供操作。而LinkedBlockingQueue在插入和删除元素时，如果队列已满或为空，操作线程可以选择被阻塞或立即返回。
  4. 迭代性能：由于LinkedBlockingQueue使用链表作为底层数据结构，迭代操作的性能通常比ArrayBlockingQueue更好。
  5. 吞吐量：在高并发场景下，LinkedBlockingQueue通常比ArrayBlockingQueue具有更好的吞吐量，因为它能够更好地支持并发的插入和删除操作。

综上所述，ArrayBlockingQueue适用于有固定容量要求的场景，操作线程需要在队列满或空时被阻塞；而LinkedBlockingQueue适用于没有固定容量要求的场景，可以更好地支持高并发的插入和删除操作。

谁不想飞舞青春
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础篇--如何手写一个消息队列和延迟消息队列？
爱分享的淘金达人
06-21 667
第一次听到“消息队列”这个词时，不知你是不是和我反应一样，感觉很高阶很厉害的样子，其实当我们了解了消息队列之后，发现它与普通的技术类似，当我们熟悉之后，也能很快地上手并使用。 我们本课时的面试题是，消息队列的使用场景有哪些？如何手动实现一个消息队列和延迟消息队列？ 典型回答 消息队列的使用场景有很多，最常见的使用场景有以下几个。 1.商品秒杀 比如，我们在做秒杀活动时，会发生短时间内出现爆发式的用户请求，如果不采取相关的措施，会导致服务器忙不过来，响应超时的问题，轻则会导致服务假死，重则会让服务器
用Java实现一个队列
01-10
用Java实现一个队列
黑马笔记---常见数据结构
weixin_65440201的博客
06-29 518
目录1.常见数据结构1.1数据结构概述、栈、队列数据结构概述常见的数据结构1.2数组1.3链表链表的特点链表的种类 1.4二叉树、 二叉查找树二叉树概述二叉树的特点 二叉查找树的特点1.5平衡二叉树1.6红黑树红黑树概述红黑规则添加节点红黑树小结：各种数据结构的特点和作用是什么样的1.数据结构是计算机底层存储、组织数据的方式。是指数据相互之间是以什么方式排列在一起的。2.通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。1.栈2.队列3.数组4.链表5.二叉树6.二叉查找树7.平衡二叉树8.红
【源码系列】Java中的数据结构——栈，队列，链表与LinkedList
发光如星
05-29 1612
自从上次字节面试凉了之后，我就一直有这个想法，想写个源码系列的博客。无奈最近事情太多，无法真正静下心来写。原本是想暑假来好好写这个系列，但因为下周要由我来负责协会授课，所以只能在这周写完。也好，毕竟只有ddl才有效率嘛（笑哭）。
Java数据结构——堆栈、队列、数组、链表、数组、红黑树、哈希表
榴莲男孩的博客
08-04 568
数据存储的常用结构有：栈、队列、数组、链表和红黑树。 栈 栈：stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。 简单的说：采用该结构的集合，对元素的存取有如下的特点 先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。 栈的入口、出口的都是栈的顶端位置。 这里两个名
Java数据结构--队列(基于链表+数组)
m0_74808313的博客
04-19 689
我们在实现队列的代码之前，先来了解一下Java API中Queue类的方法摘要，要知道它是如何创建使用的。
【Java】初学者成神路之手写单链表
qq_53964276的博客
03-04 310
小白学习Java的第7天，手写单链表单链表中的节点：节点是单向链表中基本的单元 每一个节点Node都有两个属性： 一个属性：是存储的数据 另一个属性：是下一个节点的内存地址
Java手写队列，细到极致
gubeichengxuyuan的博客
01-20 941
Java手写队列，最近在学习Aqs，发现里面涉及到很多队列的写法，非常难以理解，于是，专门去学习了队列的Java写法。但是，网上的文章很多只列出一段段代码，其他的需要你自己去理解。    考虑到一些小伙伴们，可能无法理解其中的意思。所以，我写了一篇细到头发丝的队列文章，每一行都有解释，如果我这样教，你还看不懂，我真的没有办法了。     队列，先进先出。能理解吗，你就想象一个管道，你从管道进去，后面的人在你后面，前面的人在你前面，废话，我当然知道。队列也是如此，你出来时，前面的人已经出来了，后面的人准备出来
自己实现队列的基本操作方法（Java实现）
AwwzJ_0821的博客
12-12 759
自己通过链表实现队列的基本操作，同时定义一个内部类 Node 记录每个结点内存储的元素（value）以及下一个元素的结点（next）。并且定义一个头结点（head）和尾结点（last）方便后续的操作。观察三种情况，当队列中有元素时，都要进行头结点的更新。区别是尾结点的处理，元素个数为 1 个时，尾结点置空；元素个数大于1时，尾结点不变。因为队列先进先出，所以可以通过尾插操作来实现。因为队列先进先出，所以可以通过头删操作实现出队列操作。根据队列元素个数 size 判断即可。直接返回队列属性 size 值即可。
Java手写链表
qq_45464560的博客
09-28 2032
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V73ZFeSh-1632464808641)(https://img-mid.csdnimg.cn/release/static/image/mid/ask/081087464236187.jpg “=600 #left”)]
Java实现手写一个链表的数据结构
qq_44375666的博客
07-20 354
java 实现手写链表结构，简单实现
java使用数组和链表实现队列示例
09-04
队列是一种特殊的线性表，它只允许在表的前端(front)进行删除操作，只允许在表的后端（rear）进行插入操作,下面介绍一下java使用数组和链表实现队列的示例
使用python实现数组、链表、队列、栈的方法
09-18
数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。这篇文章主要介绍了使用python实现数组、链表、队列、栈的相关知识,需要的朋友可以参考下
Python实现队列的方法示例小结【数组，链表】
12-20
本文实例讲述了Python实现队列的方法。分享给大家供大家参考，具体如下： Python实现队列 队列(FIFO)，添加元素在队列尾，删除元素在队列头操作 列表实现队列：利用python列表方法 代码如下： # 列表实现队列 ...
关于数据结构中数组、链表、队列、散列表、集合的理解
01-08
经过一上午的学习，对数据结构有了新的认识和理解 数组 数组是由有限个相同类型的变量所组成的有序集合，...栈是一种线性逻辑结构，可以使用数组实现，也可以使用链表实现。包含入栈还有出栈操作，遵循先入后出的原则(F
Java 源码 - 惊叹面试官：由浅入深手写队列
热门推荐
简单记录一下。
09-29 20万+
不啰嗦，我们直接开始！ 引导语 现在不少大厂面试的时候会要求手写代码，我曾经看过一个大厂面试时，要求在线写代码，题目就是：在不使用 Java 现有队列 API 的情况下，手写出一个队列的实现出来，队列的数据结构，入队和出队方式都自己定义。 这题其实考察的有几个点： 考察你对队列的内部结构熟不熟悉； 考察你定义 API 的功底； 考察写代码的基本功，代码风格。 本章就和大家一起，结合以上几点，手写一个队列出来，一起来熟悉一下思路和过程，完整队列代码见：demo.four.DIYQueue 和 de
手写链表（jvav）
Infinite_Power_的博客
12-09 384
闲来无事用Java手写的一个链表系统
HashMap源码手写简易篇（数组+链表）
qq_43649937的博客
03-02 542
java
Java学习笔记（四）- 手写循环队列，实现多生产者单消费者
weixin_51393513的博客
12-11 510
学习的最好方式就是写出来 今天我们就手撸一个循环队列吧，多生产者，单消费者模式，模拟队列满了之后的场景 这里先说明下循环队列的实现原理 队列长度固定，队列有头部指针（front）、尾部指针(rear)两个指针 每插入一个元素，尾部指针前移一位 每取出一个元素，头部指针前移一位 队列满了之后，取出一个元素，再加入一个元素，尾部指针归零 取元素的个数达到队列最大长度之后，头部指针归零 ​ 1、下面上代码实操，先来个接口类 package co.
Java实现栈，队列，数组，链表数据结构
最新发布
05-17
Java实现队列的代码： ```java public class Queue { private int maxSize; private int[] queueArray; private int front; private int rear; private int nItems; public Queue(int size) { maxSize = ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值