Java实现队列的三种方法集合

数组实现队列

//数组实现队列
class queue{
 int[] a = new int[5];
 int i = 0;
 //入队操作
 public void in(int m) {
 a[i++] = m;
 }
// 出队列操作  取出最前面的值 通过循环遍历把所有的数据向前一位
 public int out() {
 int index = 0;
 int temp = a[0];
 for(int j = 0;j < i;j++) {
  a[j] = a[j + 1];
 }
 return temp;
 }
}

ArrayList实现队列

//集合实现队列
class queue{
 List<Integer> list = new ArrayList<Integer>();
 int index = 0;

 public void in(int n) {
 list.add(n);
 index++;
 }
 //出队列操作
 //出队
  public int out(){
    if(!list.isEmpty()){
      index--;
      return list.remove(0);
    }
    return -1;
  }
}

两个堆栈实现队列

//两个堆栈实现一个队列
class queue3 {

 Stack<Integer> stackA = new Stack<Integer>();
 Stack<Integer> stackB = new Stack<Integer>();

 //入队
 public void in(int n) {
   stackA.push(n);
 }

 //出队 我们把A里面的元素遍历拿出放入B中 再拿出B中的第一个元素
 public int out() {
  //判断b栈有没有元素 有返回false 无返回真
   if(stackB.isEmpty()) {
    while(!stackA.isEmpty()) {
    stackB.push(stackA.pop());
    }
   }
   return stackB.pop();
 }
}

补充知识：java使用链表实现队列

队列使用Java进行链表实现，在网上找到了一张图，很好，借鉴一下

设置两个结点node，front指向队首元素，rear指向队尾；

上代码：

 public class LinkedQueue {

  Node front;//队头指针，指向队头节点
  Node rail;//队尾指针，指向队尾节点
  int size = 0;//记录队列长度 

  //构造函数
  public LinkedQueue() {
    front = rail = null;
  }

  public boolean isEmpty() {
    return size == 0 ? true : false;
  }

  //添加元素
  public boolean addQueue(Object ele) {
    if (size == 0) {
      front = new Node(null, ele);
      rail = front;
      size++;
      return true;
    }
    Node s = new Node(null, ele);
    //这块有个主意的地方，一旦rail设置了next属性，因为front节点与rail节点指向了同一个node节点，持有同一个结点的一个引用，因此front节点next属性也被填充
    rail.setNext(s);
    rail = s;
    size++;
    return true;
  } 

  /**
   * 删除元素,出队列
   * @return
   */
  public boolean deleteQueue() {
    if (isEmpty()) {
      System.out.println("当前队列为空");
      return false;
    }
    front = front.next;
    size--;
    return true;
  } 

  public static void main(String[] args) {
    LinkedQueue queue = new LinkedQueue();

    queue.addQueue(1);
    queue.addQueue(2);
    queue.addQueue(3);
    queue.deleteQueue();

  }
}

/**
 * 首先链表底层是一个个结点
 */
class Node {

  Node next;
  Object element;

  public Node(Node next, Object element) {
    this.next = next;
    this.element = element;
  }

  public Node getNext() {
    return next;
  }

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

  public Object getElement() {
    return element;
  }

  public void setElement(Object element) {
    this.element = element;
  }

}

以上这篇Java实现队列的三种方法集合就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持我们。

赞 (0)

相关推荐

  • 详解java中的阻塞队列

    阻塞队列简介 阻塞队列(BlockingQueue)首先是一个支持先进先出的队列,与普通的队列完全相同: 其次是一个支持阻塞操作的队列,即: 当队列满时,会阻塞执行插入操作的线程,直到队列不满. 当队列为空时,会阻塞执行获取操作的线程,直到队列不为空. 阻塞队列用在多线程的场景下,因此阻塞队列使用了锁机制来保证同步,这里使用的可重入锁: 而对于阻塞与唤醒机制则有与锁绑定的Condition实现 应用场景:生产者消费者模式 java中的阻塞队列 java中的阻塞队列根据容量可以分为有界队列和无界队

  • java队列之queue用法实例分析

    Queue: 基本上,一个队列就是一个先入先出(FIFO)的数据结构 Queue接口与List.Set同一级别,都是继承了Collection接口.LinkedList实现了Deque接 口. Queue的实现 1.没有实现的阻塞接口的LinkedList: 实现了java.util.Queue接口和java.util.AbstractQueue接口 内置的不阻塞队列: PriorityQueue 和 ConcurrentLinkedQueue PriorityQueue 和 Concurren

  • 一口气说出Java 6种延时队列的实现方法(面试官也得服)

    五一期间原计划是写两篇文章,看一本技术类书籍,结果这五天由于自律性过于差,禁不住各种诱惑,我连电脑都没打开过,计划完美宣告失败.所以在这能看出和大佬之间的差距,人家没白没夜的更文,比你优秀的人比你更努力,难以望其项背,真是让我自愧不如. 知耻而后勇,这不逼着自己又学起来了,个人比较喜欢一些实践类的东西,既学习到知识又能让技术落地,能搞出个demo最好,本来不知道该分享什么主题,好在最近项目紧急招人中,而我有幸做了回面试官,就给大家整理分享一道面试题:"如何实现延时队列?". 下边会介绍

  • SpringBoot集成JmsTemplate(队列模式和主题模式)及xml和JavaConfig配置详解

    1.导入jar包: <!--jmsTemplate--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-activemq</artifactId> </dependency> <dependency> <groupId>org.apache.activemq</g

  • JAVA 实现延迟队列的方法

    延迟队列的需求各位应该在日常开发的场景中经常碰到.比如: 用户登录之后5分钟给用户做分类推送: 用户多少天未登录给用户做召回推送: 定期检查用户当前退款账单是否被商家处理等等场景. 一般这种场景和定时任务还是有很大的区别,定时任务是你知道任务多久该跑一次或者什么时候只跑一次,这个时间是确定的.延迟队列是当某个事件发生的时候需要延迟多久触发配套事件,引子事件发生的时间不是固定的. 业界目前也有很多实现方案,单机版的方案就不说了,现在也没有哪个公司还是单机版的服务,今天我们一一探讨各种方案的大致实现

  • Java实现队列的三种方法集合

    数组实现队列 //数组实现队列 class queue{ int[] a = new int[5]; int i = 0; //入队操作 public void in(int m) { a[i++] = m; } // 出队列操作 取出最前面的值 通过循环遍历把所有的数据向前一位 public int out() { int index = 0; int temp = a[0]; for(int j = 0;j < i;j++) { a[j] = a[j + 1]; } return temp;

  • java 字符串分割的三种方法(总结)

    最近在项目中遇到一个小问题,一个字符串分割成一个数组,类似String str="aaa,bbb,ccc"; 然后以","为分割符,将其分割成一个数组,用什么方法去实现呢? 第一种方法: 可能一下子就会想到使用split()方法,用split()方法实现是最方便的,但是它的效率比较低 第二种方法: 使用效率较高的StringTokenizer类分割字符串,StringTokenizer类是JDK中提供的专门用来处理字符串分割子串的工具类.它的构造函数如下: publ

  • java 字符串截取的三种方法(推荐)

    众所周知,java提供了很多字符串截取的方式.下面就来看看大致有几种. 1.split()+正则表达式来进行截取. 将正则传入split().返回的是一个字符串数组类型.不过通过这种方式截取会有很大的性能损耗,因为分析正则非常耗时. String str = "abc,12,3yy98,0"; String[] strs=str.split(","); for(int i=0,len=strs.length;i<len;i++){ System.out.pri

  • JAVA字符串反转的三种方法

    方法一:使用StringBuilder import java.util.Scanner; public class StrReversal { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String str = scanner.nextLine(); System.out.println(new StringBuilder(str).reverse()); } } 方法二

  • Java 实现定时任务的三种方法

    Java 实现定时任务的三种方法

    是的,不用任何框架,用我们朴素的 Java 编程语言就能实现定时任务. 今天,栈长就介绍 3 种实现方法,教你如何使用 JDK 实现定时任务! 1. sleep 这也是我们最常用的 sleep 休眠大法,不只是当作休眠用,我们还可以利用它很轻松的能实现一个简单的定时任务. 实现逻辑: 新开一个线程,添加一个 for/ while 死循环,然后在死循环里面添加一个 sleep 休眠逻辑,让程序每隔 N 秒休眠再执行一次,这样就达到了一个简单定时任务的效果. 实现代码如下: private stat

  • Java结束线程的三种方法及该如何选择

    java常用的结束一个运行中的线程的方法有3中:使用退出标志,使用interrupt方法,使用stop方法. 1.使用退出标志 即在线程内部定义一个bool变量来判断是否结束当前的线程: public class ThreadSafe extends Thread { public volatile boolean exit = false; public void run() { while (!exit){ //do work } } public static void main(Stri

  • Java打印数组的三种方法整理

    目录 ①.使用 for 循环打印 ②.使用 Arrays.toString() 或 Arrays.deepToString() ③.使用 Arrays.asList() 补充:java byte数组打印 十六位数组打印输出 普通数组打印输出 总结 在Java开发中有时候需要打印数组信息,下面是整理归纳的几种打印数组方法:(如下) ①.使用 for 循环打印 最简单的方法,逐个遍历打印 注:如果是多维数组的话,使用多层 for 循环嵌套就可以打印了. 一维数组: public static voi

  • java定位死锁的三种方法（jstack、Arthas和Jvisualvm）

    java定位死锁的三种方法（jstack、Arthas和Jvisualvm）

    目录 死锁 死锁发生的原因 死锁发生的条件 1:通过jstack定位死锁信息 1.2:查看死锁线程的pid 2:通过Arthas工具定位死锁 3. 通过 Jvisualvm 定位死锁 死锁的预防 总结 死锁 死锁:是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去. 死锁发生的原因 死锁的发生是由于资源竞争导致的,导致死锁的原因如下: 系统资源不足,如果系统资源充足,死锁出现的可能性就很低. 进程(线程)运行推进的顺序不合适. 资源分配

  • JAVA实现线程的三种方法

    (1)继承Thread类,重写run函数创建:class xx extends Thread{  public void run(){Thread.sleep(1000) //线程休眠1000毫秒,sleep使线程进入Block状态,并释放资源}}开启线程:对象.start() //启动线程,run函数运行(2)实现Runnable接口,重写run函数开启线程:Thread t = new Thread(对象) //创建线程对象t.start()(3)实现Callable接口,重写call函数C

  • java字符转码的三种方法总结及实例

    java字符转码:三种方法 转码成功的前提:解码后无乱码 转码流程:文件(gbk)-->解码-->编码--->文件(utf-8) 注:如有问题请留言 下面具体的实例  方法一:Java.lang.String //用于解码的构造器: String(byte[] bytes, int offset, int length, String charsetName) String(byte[] bytes, String charsetName) 用于编码的方法: byte[] getByte

随机推荐