java队列实现类有哪些

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



size：4
出队列：1
出队列：2
出队列：3
出队列：4
删完重新添加==============
size：4
出队列：11
出队列：22
出队列：33
出队列：44

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

生活不只是敲代码，如果你或你身边的人喜欢摄影或者生活的点点滴滴，可以关注下面的公众号~

收起

展开全文

数据结构

JAVA实现队列类

千次阅读 2019-02-24 19:22:54

本文使用java中的数据和列表来实现队列类，从而更加详细和直观的理解队列的使用和性质。 1、使用数组实现队列 public class QueueWithArray { private int [] queueArray; private int front ...

和栈一样，队列也是线性的集合。对于队列来说，插入限制在一端，也就是队尾，删除限制在另一端，也就是对头。队列支持先进先出的协议。

本文使用java中的数据和列表来实现队列类，从而更加详细和直观的理解队列的使用和性质。

1、使用数组实现队列

public class QueueWithArray {
	private int [] queueArray;
	private int front = 0;
	private int rear = 0;
	
	public QueueWithArray() {
		this(5);
	}
	
	public QueueWithArray(int queueSize) {
		queueArray = new int [queueSize];
	} 
	
	public void push(int element) {
		if (rear >= front && rear < queueArray.length - 1) {
			queueArray [rear ++] = element;
		}
		else if(rear == queueArray.length - 1 && front == 0) {
			int [] tempArray = new int [queueArray.length * 2];
			System.arraycopy(queueArray, 0, tempArray, 0, queueArray.length);
			queueArray [rear ++] = element;
		}
		else if (front > 0 && rear == queueArray.length - 1) {
			queueArray [rear] = element;
			rear = 0;
		}
		else if (rear < front - 1) 
			queueArray [rear ++ ] = element;
		else if (rear < front && rear == front - 1) {
			loopArrayCopy();
			queueArray [rear ++] = element;
		}
	}
	
	public int pop() {
		if (front == queueArray.length - 1) {
			int reasult = queueArray [front];
			front = 0;
			return reasult;
		}
		else if (front == rear - 1) {
			int reasult = queueArray [front];
			front = 0;
			rear = 0;
			return reasult;
		}
		else
			return queueArray [front ++];
	}
	
	public int peek() {
		return queueArray [front];
	}
	
	public boolean isEmpty() {
		return front == 0 && rear == 0;
	}
	
	public int getSize() {
		if (front < rear)
			return rear - front;
		else if (front > rear) {
			int frontNumber = queueArray.length - front;
			int rearNumber = rear;
			return frontNumber + rearNumber;
		}
		else
			return 0;
	}
	
	private void loopArrayCopy() {
		int [] tempArray = new int [queueArray.length * 2];
		System.arraycopy(queueArray, front, tempArray, 0, queueArray.length - front);
		System.arraycopy(queueArray, 0, tempArray, queueArray.length - front, rear);
		front = 0;
		rear = queueArray.length - 1;
		queueArray = tempArray;
	}
	
	public void clear() {
		rear = 0;
		front = 0;
	}
	
	@Override
	public String toString() {
		String s = " ";
		if (front < rear) {
			for (int index = front; index < rear; index ++) 
				s += (Integer.toString(queueArray [index]) + " ");
			return s;
		}
		else if (front > rear) {
			for (int index = front; index < queueArray.length; index ++)
				s += (Integer.toString(queueArray [index]) + " ");
			for (int index = 0; index < rear; index ++) 
				s += (Integer.toString(queueArray [index]) + " ");
			return s;
		}
		else
			return "The queue is empty";
			
	}
}

为了验证类的正确性下面提供验证程序


public class TestQueueWithArray {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		QueueWithArray queue = new QueueWithArray(4);
		queue.push(1);
		queue.push(2);
		int a = queue.pop();
		System.out.println(a);
		System.out.println(queue.toString());
		queue.push(3);
		queue.push(4);
		queue.push(5);
		System.out.println(queue.getSize());
		queue.push(6);
		System.out.println(queue.getSize());
		System.out.println(queue.toString());
		queue.clear();
		System.out.println(queue.isEmpty());
	}

}


2、使用列表实现队列

import java.util.ArrayList;

public class QueueWithList {
	private ArrayList<Integer> queueList= new ArrayList<>();
	public QueueWithList() {
		
	}
	
	public void add(int number) {
		queueList.add(number);
	}
	
	public int pop() {
		int number = queueList.remove(0);
		return number;
	}
	
	public int peek() {
		return queueList.get(0);
	}
	
	public boolean isEmpty() {
		return queueList.isEmpty();
	}
	
	public int len() {
		return queueList.size();
	}
	
	public void clear() {
		queueList.clear();
	}
	@Override
	public String toString() {
		String s = "";
		for (int index = 0; index < queueList.size(); index ++ ) {
			if (index < queueList.size() - 1) 
				s += (Integer.toString(queueList.get(index)) + " ");
			else
				s += Integer.toString(queueList.get(index));
		}
		return s;
	}
}


测试程序：


public class TestQueue {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		QueueWithList queue = new QueueWithList();
		queue.add(1);
		queue.add(2);
		System.out.println(queue.toString());
		int a = queue.peek();
		System.out.println(a);
		System.out.println(queue.toString());
		System.out.println(queue.len());
		queue.clear();
		System.out.println(queue.isEmpty());
	}
	
}

收起

展开全文

java 队列实现

万次阅读 2009-03-05 15:00:00

买饭时需要排队，好多事情都是需要排队，排在第一位的则先处理，结束后，后面的人都像前移动一位，在开发中也有好多这样的事情需要处理，如文件的下载，短信的发送功能，等这些都是需要队列方式实现。...

队列其实 所指生活中排队的现象，去商场购物，付款时需要排队， 买饭时需要排队， 好多事情都是需要排队， 排在第一位的则先处理，结束后， 后面的人都像前移动一位，在开发中也有好多这样的事情需要处理，如文件的下载，短信的发送功能， 等这些都是需要队列方式实现。好了， 废话不多说， 详情见下面代码！
 
package com.fanzhang;
 
class Queue   //队列类
    {
    private int maxSize; //队列长度，由构造函数初始化
    private long[] queArray; // 队列
    private int front; //队头
    private int rear; //队尾
    private int nItems;  //元素的个数
//--------------------------------------------------------------
    public Queue(int s)           // 构造函数
       {
       maxSize = s;
       queArray = new long[maxSize];
       front = 0;
       rear = -1;
       nItems = 0;
       }
//--------------------------------------------------------------
    public void insert(long j)    // 进队列
       {
       if(rear == maxSize-1)          // 处理循环
          rear = -1;
       queArray[++rear] = j;          // 队尾指针加1,把值j加入队尾
       nItems++;                    
       }
//--------------------------------------------------------------
    public long remove()          // 取得队列的队头元素。
       {
       long temp = queArray[front++]; // 取值和修改队头指针
       if(front == maxSize)            // 处理循环
          front = 0;
       nItems--;                      
       return temp;
       }
//--------------------------------------------------------------
    public long peekFront()       // 取得队列的队头元素。该运算与 remove()不同，后者要修改队头元素指针。
       {
       return queArray[front];
       }
//--------------------------------------------------------------
    public boolean isEmpty()     // 判队列是否为空。若为空返回一个真值，否则返回一个假值。
       {
       return (nItems==0);
       }
//--------------------------------------------------------------
    public boolean isFull()      // 判队列是否已满。若已满返回一个真值，否则返回一个假值。
       {
       return (nItems==maxSize);
       }
//--------------------------------------------------------------
    public int size()            // 返回队列的长度
       {
       return nItems;
       }
//--------------------------------------------------------------
    }  

public class IntegerQueue
{
public static void main(String[] args)
   {
 Queue theQueue = new Queue(5);   // 队列有5个元素
   theQueue.insert(10);             // 添加4个元素
   theQueue.insert(20);
   theQueue.insert(30);
   theQueue.insert(40);
   theQueue.remove();               // 移除3个元素
   theQueue.remove();               // (10, 20, 30)
   theQueue.remove();
   theQueue.insert(50);             // 添加4个元素
   theQueue.insert(60);           
   theQueue.insert(70);
   theQueue.insert(80);
   
   while( !theQueue.isEmpty() )     // 遍历队列并移除所有元素
      {                            
      long n = theQueue.remove();   // (40, 50, 60, 70, 80)
      System.out.print(n);
      System.out.print(" ");
      }
   System.out.println("");
   }  
}

收起

展开全文

insert string class

java队列实现（顺序队列、链式队列、循环队列）

万次阅读 多人点赞 2014-01-21 15:45:31

1.顺序队列的实现 package lang; import java.io.Serializable; import java.util.Arrays; /** * @ClassName: ArrayQueue * @Description: 顺序队列 * @date 2014年1月20日下午3:46:19 * @param */ public ...

双向顺序队列ArrayDeque和双向链式队列LinkedList，JDK已经包含，在此略。ArrayDeque包括顺序栈和顺序队列，LinkedList包含链式栈和链式队列。ArrayDeque和LinkedList都是线程不安全的。PriorityQueue优先队列也在JDK。
1.顺序队列的实现
package lang;

import java.io.Serializable;
import java.util.Arrays;

/**
 * @ClassName: ArrayQueue
 * @Description: 顺序队列
 * @date 2014年1月20日 下午3:46:19
 * @param <T>
 */
public class ArrayQueue<T> implements Serializable{
  /**
   * @Fields serialVersionUID : TODO
   */
  private static final long serialVersionUID = 7333344126529379197L;

  private int DEFAULT_SIZE = 10;

  private int capacity;//保存数组的长度

  private Object[] elementData;//定义一个数组用于保存顺序队列的元素

  private int front = 0;//队头

  private int rear = 0;//队尾

  //以默认数组长度创建空顺序队列
  public ArrayQueue() {
    capacity = DEFAULT_SIZE;
    elementData = new Object[capacity];
  }

  //以一个初始化元素来创建顺序队列
  public ArrayQueue(T element) {
    this();
    elementData[0] = element;
    rear++;
  }
  
  public ArrayQueue(int initSize) {
    elementData = new Object[initSize];
  }

  /**
   * 以指定长度的数组来创建顺序队列
   * @param element 指定顺序队列中第一个元素
   * @param initSize 指定顺序队列底层数组的长度
   */
  public ArrayQueue(T element, int initSize) {
    this.capacity = initSize;
    elementData = new Object[capacity];
    elementData[0] = element;
    rear++;
  }

  /**
   * @Title: size     
   * @Description: 获取顺序队列的大小    
   * @return
   */
  public int size() {
    return rear - front;
  }

  /**
   * @Title: offer     
   * @Description: 入队    
   * @param element
   */
  public void offer(T element) {
    ensureCapacity(rear + 1);
    elementData[rear++] = element;
  }
  
  private void ensureCapacity(int minCapacity) {
    //如果数组的原有长度小于目前所需的长度
    int oldCapacity = elementData.length;
    if (minCapacity > oldCapacity) {
      int newCapacity = (oldCapacity * 3) / 2 + 1;
      if (newCapacity < minCapacity)
        newCapacity = minCapacity;
      // minCapacity is usually close to size, so this is a win:
      elementData = Arrays.copyOf(elementData, newCapacity);
    }

  }

  /**
   * @Title: poll     
   * @Description: 出队    
   * @return
   */
  public T poll() {
    if (isEmpty()) {
      throw new IndexOutOfBoundsException("空队列异常");
    }
    //保留队列的front端的元素的值
    T oldValue = (T) elementData[front];
    //释放队列的front端的元素
    elementData[front++] = null;
    return oldValue;
  }

  /**
   * @Title: peek     
   * @Description: 返回队列顶元素，但不删除队列顶元素    
   * @return
   */
  public T peek() {
    if (isEmpty()) {
      throw new IndexOutOfBoundsException("空队列异常");
    }
    return (T) elementData[front];
  }

  /**
   * @Title: isEmpty     
   * @Description: 判断顺序队列是否为空队列    
   * @return
   */
  public boolean isEmpty() {
    return rear == front;
  }

  /**
   * @Title: clear     
   * @Description: 清空顺序队列
   */
  public void clear() {
    //将底层数组所有元素赋为null
    Arrays.fill(elementData, null);
    front = 0;
    rear = 0;
  }

  public String toString() {
    if (isEmpty()) {
      return "[]";
    } else {
      StringBuilder sb = new StringBuilder("[");
      for (int i = front; i < rear; i++) {
        sb.append(elementData[i].toString() + ", ");
      }
      int len = sb.length();
      return sb.delete(len - 2, len).append("]").toString();
    }
  }
}
 
2. 链式队列的实现
package lang;

import java.io.Serializable;

/**
 * @ClassName: LinkQueue
 * @Description:  链式队列
 * @date 2014年1月21日 下午3:24:38
 * @param <T>
 */
public class LinkQueue<T> implements Serializable{
  /**
   * @Fields serialVersionUID : TODO
   */
  private static final long serialVersionUID = -6726728595616312615L;

  //定义一个内部类Node，Node实例代表链队列的节点。
  private class Node {
    
    private T data;//保存节点的数据
   
    private Node next;//指向下个节点的引用

    //无参数的构造器
    public Node() {
    }

    //初始化全部属性的构造器
    public Node(T data, Node next) {
      this.data = data;
      this.next = next;
    }
  }
  
  private Node front;//保存该链队列的头节点
  
  private Node rear;//保存该链队列的尾节点

  private int size;//保存该链队列中已包含的节点数

  /**
   * <p>Title: LinkQueue </p>     
   * <p>Description: 创建空链队列 </p> 
   */
  public LinkQueue() {
    //空链队列，front和rear都是null
    front = null;
    rear = null;
  }

  /**
   * <p>Title: LinkQueue </p>    
   * <p>Description: 以指定数据元素来创建链队列，该链队列只有一个元素</p> 
   */
  public LinkQueue(T element) {
    front = new Node(element, null);
    //只有一个节点，front、rear都指向该节点
    rear = front;
    size++;
  }

  /**
   * @Title: size     
   * @Description: 获取顺序队列的大小    
   * @return
   */
  public int size() {
    return size;
  }

  /**
   * @Title: offer     
   * @Description: 入队    
   * @param element
   */
  public void offer(T element) {
    //如果该链队列还是空链队列
    if (front == null) {
      front = new Node(element, null);     
      rear = front;//只有一个节点，front、rear都指向该节点
    } else {     
      Node newNode = new Node(element, null);//创建新节点     
      rear.next = newNode;//让尾节点的next指向新增的节点     
      rear = newNode;//以新节点作为新的尾节点
    }
    size++;
  }

  /**
   * @Title: poll     
   * @Description: 出队    
   * @return
   */
  public T poll() {
    Node oldFront = front;
    front = front.next;
    oldFront.next = null;
    size--;
    return oldFront.data;
  }

  /**
   * @Title: peek     
   * @Description: 返回队列顶元素，但不删除队列顶元素    
   * @return
   */
  public T peek() {
    return rear.data;
  }

  /**
   * @Title: isEmpty     
   * @Description: 判断顺序队列是否为空队列    
   * @return
   */
  public boolean isEmpty() {
    return size == 0;
  }

  /**
   * @Title: clear     
   * @Description: 清空顺序队列
   */
  public void clear() {
    //将front、rear两个节点赋为null
    front = null;
    rear = null;
    size = 0;
  }

  public String toString() {
    //链队列为空链队列时
    if (isEmpty()) {
      return "[]";
    } else {
      StringBuilder sb = new StringBuilder("[");
      for (Node current = front; current != null; current = current.next) {
        sb.append(current.data.toString() + ", ");
      }
      int len = sb.length();
      return sb.delete(len - 2, len).append("]").toString();
    }
  }

  public static void main(String[] args) {
    LinkQueue<String> queue = new LinkQueue<String>("aaaa");
    //添加两个元素
    queue.offer("bbbb");
    queue.offer("cccc");
    System.out.println(queue);
    //删除一个元素后
    queue.poll();
    System.out.println("删除一个元素后的队列：" + queue);
    //再次添加一个元素
    queue.offer("dddd");
    System.out.println("再次添加元素后的队列：" + queue);
    //删除一个元素后，队列可以再多加一个元素
    queue.poll();
    //再次加入一个元素
    queue.offer("eeee");
    System.out.println(queue);
  }
}

 
3. 循环队列的实现
package lang;

import java.io.Serializable;
import java.util.Arrays;

/**
 * @ClassName: LoopQueue
 * @Description: 循环队列
 * @date 2014年1月20日 下午3:47:14
 */
public class LoopQueue<T> implements Serializable{
  /**
   * @Fields serialVersionUID : TODO
   */
  private static final long serialVersionUID = -3670496550272478781L;

  private int DEFAULT_SIZE = 10;

  private int capacity;//保存数组的长度

  private Object[] elementData;//定义一个数组用于保存循环队列的元素

  private int front = 0;//队头

  private int rear = 0;//队尾

  //以默认数组长度创建空循环队列
  public LoopQueue() {
    capacity = DEFAULT_SIZE;
    elementData = new Object[capacity];
  }

  //以一个初始化元素来创建循环队列
  public LoopQueue(T element) {
    this();
    elementData[0] = element;
    rear++;
  }

  /**
   * 以指定长度的数组来创建循环队列
   * @param element 指定循环队列中第一个元素
   * @param initSize 指定循环队列底层数组的长度
   */
  public LoopQueue(T element, int initSize) {
    this.capacity = initSize;
    elementData = new Object[capacity];
    elementData[0] = element;
    rear++;
  }

  //获取循环队列的大小
  public int size() {
    if (isEmpty()) {
      return 0;
    }
    return rear > front ? rear - front : capacity - (front - rear);
  }

  //插入队列
  public void add(T element) {
    if (rear == front && elementData[front] != null) {
      throw new IndexOutOfBoundsException("队列已满的异常");
    }
    elementData[rear++] = element;
    //如果rear已经到头，那就转头
    rear = rear == capacity ? 0 : rear;
  }

  //移除队列
  public T remove() {
    if (isEmpty()) {
      throw new IndexOutOfBoundsException("空队列异常");
    }
    //保留队列的rear端的元素的值
    T oldValue = (T) elementData[front];
    //释放队列的rear端的元素
    elementData[front++] = null;
    //如果front已经到头，那就转头
    front = front == capacity ? 0 : front;
    return oldValue;
  }

  //返回队列顶元素，但不删除队列顶元素
  public T element() {
    if (isEmpty()) {
      throw new IndexOutOfBoundsException("空队列异常");
    }
    return (T) elementData[front];
  }

  //判断循环队列是否为空队列
  public boolean isEmpty() {
    //rear==front且rear处的元素为null
    return rear == front && elementData[rear] == null;
  }

  //清空循环队列
  public void clear() {
    //将底层数组所有元素赋为null
    Arrays.fill(elementData, null);
    front = 0;
    rear = 0;
  }

  public String toString() {
    if (isEmpty()) {
      return "[]";
    } else {
      //如果front < rear，有效元素就是front到rear之间的元素
      if (front < rear) {
        StringBuilder sb = new StringBuilder("[");
        for (int i = front; i < rear; i++) {
          sb.append(elementData[i].toString() + ", ");
        }
        int len = sb.length();
        return sb.delete(len - 2, len).append("]").toString();
      }
      //如果front >= rear，有效元素为front->capacity之间、0->front之间的
      else {
        StringBuilder sb = new StringBuilder("[");
        for (int i = front; i < capacity; i++) {
          sb.append(elementData[i].toString() + ", ");
        }
        for (int i = 0; i < rear; i++) {
          sb.append(elementData[i].toString() + ", ");
        }
        int len = sb.length();
        return sb.delete(len - 2, len).append("]").toString();
      }
    }
  }

  public static void main(String[] args) {
    LoopQueue<String> queue = new LoopQueue<String>("aaaa", 3);
    //添加两个元素
    queue.add("bbbb");
    queue.add("cccc");
    //此时队列已满
    System.out.println(queue);
    //删除一个元素后，队列可以再多加一个元素
    queue.remove();
    System.out.println("删除一个元素后的队列：" + queue);
    //再次添加一个元素，此时队列又满
    queue.add("dddd");
    System.out.println(queue);
    System.out.println("队列满时的长度：" + queue.size());
    //删除一个元素后，队列可以再多加一个元素
    queue.remove();
    //再次加入一个元素，此时队列又满
    queue.add("eeee");
    System.out.println(queue);
  }
}

收起

展开全文

java LinkedList类实现队列
千次阅读 2011-08-08 18:58:25
LinkedList 类实现队列 队列是FIFO 先进先出 FIRST IN FIRST OUT 一边进去另一边出来 LinkedList 底层是采用链表完成 ArrayList底层采用数组完成对数据的查找操作用数组更快 */ i
收起
object string
数据结构_队列_Java中的实现类
千次阅读 2020-06-21 15:42:41
我们对基础的数据结构队列都非常的熟悉，这里回顾下 ...Java 中的队列可以利用实现 Deque 接口的类作为实现类， Deque 的实现类主要分为两种场景：一般场景 LinkedList 大小可变的链表双端队列，允许元素为 nu...
收起
JAVA集合 Deque 与 Queue 实现类 ArrayDeque(队列、双端队列) 源码浅析
千次阅读 2018-12-23 18:39:37
文章目录JAVA集合 Deque实现类 ArrayDeque(双端队列) 源码浅析一、简述:二、ArrayDeque 类结构与属性三、ArrayDeque 构造方法四、Queue 与 Deque 的方法1. 添加元素 add(E e) JAVA集合 Deque实现类 ArrayDeque(双端...
收起
ArrayDeque 数据结构
Java双缓冲队列实现
千次阅读 2017-04-18 09:30:15
用Java实现了一个双缓冲队列，并给出了实例代码
收起
双缓冲
Java Design Demo--java实现队列的类ExecutorService
千次阅读 2013-03-11 09:48:13
JAVA API 有时服务器请求过多，需要使用队列来处理队列就好比去窗口（线程池）排队买票，窗口也是一种资源，过多的...java1.5加入了队列处理见 Executors 和ExecutorService类以下示例 public class TheadPo
收起
Java实现 栈和队列
千次阅读 2016-09-20 19:23:47
JAVA面试题编程题：请用JAVA实现两个类，分别实现堆栈（Stack)和队列（Queue）操作package com.lcx.interview; import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * 29. 请用...
收起
【Java】Java队列Queue使用详解
万次阅读 多人点赞 2018-09-10 16:29:27
Queue是java中实现队列的接口，它总共只有6个方法，我们一般只用其中3个就可以了。Queue的实现类有LinkedList和PriorityQueue。最常用的实现类是LinkedList。
收起
jdk1.7
使用Java集合类实现队列
千次阅读 2012-09-17 14:50:32
1、要求实现一个FIFO队列；能够查看最大值、最小值、中位数；队列中的每个对象能够比较大小。接口1： package jp.co.worksap.recruiting; public interface ExamPeekableQueue> { public void enqueue(E e); ...
收起
integer iterator immutable interface
JAVA循环队列
千次阅读 2017-09-15 15:25:44
一、JAVA 中已经自带了 Queue、DQueue、ArrayList、LinkedList 等常用的数据结构，为什么还要单独实现循环队列？之所以使用自定义循环队列，出发点还是基于我们在实际应用中对于数据处理各种各样的需求。使用...
收起
用堆实现优先级队列 Java实现
千次阅读 2016-03-19 00:14:47
优先级队列分为最大优先级队列和最小优先级队列。本文介绍基于大根堆实现最大优先级队列。关于堆的介绍见另一篇博文：堆这种数据结构 Java实现 最小优先级队列的实现可以在本文最后给出的github地址里找到。
收起
数据结构
【Java】Java双端队列Deque使用详解
万次阅读 多人点赞 2018-09-15 18:14:05
Deque是一个双端队列接口，继承自Queue接口，它们共同的实现类是LinkedList。 Deque的功能很强大：代替普通队列Queue：先进先出、队尾进队头出可以作为双端队列：队尾和队头都可以进出还可以作为堆栈...
收起
deque queue 堆栈
Java实现环形队列
千次阅读 2017-03-19 23:57:34
这里我定义的环形队列为：列表中最后一个元素是指向列表中的第一个元素，而且里面提供一个next方法，可以不断获取下一个元素，在环形队列中也就是不断的转圈，实现方式如下：队列中提供的方法：public boolean add...
收起
数据结构
栈和队列在java中的实现
千次阅读 2013-10-29 08:26:27
栈和队列在java中的实现
收起
java使用链表实现队列
千次阅读 2017-09-30 12:27:19
队列使用Java进行链表实现，在网上找到了一张图，很好，借鉴一下设置两个结点node，front指向队首元素，rear指向队尾；上代码： public class LinkedQueue { Node front;//队头指针，指向队头节点 ...
收起
队列的创建Java实现
千次阅读 2019-01-18 22:51:38
关键词：结点类、队列类、队头队尾指针 1.结点类的设计 class QueueNode { int data; QueueNode next; QueueNode(){ data = 0; next = null; } QueueNode(int d, QueueNode n){ data = 0; next = ...
收起
Java如何实现栈和队列
千次阅读 2019-07-03 15:38:52
Java如何实现栈和队列栈栈（stack）是一种后进先出（LIFO）的集合类型，即后来添加的数据会先被删除。可以将其类比于下面文件的取放操作：新到的文件会被先取走，这使得每次取走的文件都是最新的。栈可以用...
收起
java中Map有哪些实现类和使用场景
万次阅读 多人点赞 2018-05-25 21:02:38
Java中的map是一个很重要的集合，他是一个接口，下面继承它实现了多个实现类，这些类各有千秋，各自有个各自的优点和缺点，先上图。 map的主要特点是键值对的形式，一一对应，且一个key只对应1个value。其常用的map...
收起
Java实现消息队列服务
千次阅读 2019-08-30 16:34:15
使用 JAVA 语言自己动手来写一个MQ (类似ActiveMQ,RabbitMQ) 主要角色首先我们必须需要搞明白 MQ (消息队列) 中的三个基本角色 ProducerBrokerConsumer 整体架构如下所示自定义协议首先从上一篇中介绍了协议的...
收起
Java基础面试题5-Java中的队列都有哪些，有什么区别
万次阅读 2018-03-18 14:53:21
Queue：基本上，一个队列就是一个先入先出（FIFO）的数据... Queue的实现1、没有实现的阻塞接口的LinkedList：实现了java.util.Queue接口和java.util.AbstractQueue接口　内置的不阻塞队列： PriorityQueue ...
收起
1、利用Java的集合类实现队列（Queue）的一种方式
千次阅读 2019-04-27 09:10:01
在Java中通过集合实现Queue(队列): package QueueLearn; import java.util.ArrayList; import java.util.List; //2.使用集合实现队列功能，使用int数组保存数据特点：先进先出，后进后出 public class QueueText02...
收起
Queue 集合数据结构

Java队列实现

一、队列简单介绍

二、队列实现

1、创建节点类

2、创建队列类LinkQueue

3、测试

JAVA实现队列类

java 队列实现

java队列实现（顺序队列、链式队列、循环队列）

java LinkedList类实现队列

数据结构_队列_Java中的实现类

JAVA集合 Deque 与 Queue 实现类 ArrayDeque(队列、双端队列) 源码浅析

Java双缓冲队列实现

Java Design Demo--java实现队列的类ExecutorService

Java实现栈和队列

【Java】Java队列Queue使用详解

使用Java集合类实现队列

JAVA循环队列

用堆实现优先级队列 Java实现

【Java】Java双端队列Deque使用详解

Java实现环形队列

栈和队列在java中的实现

java使用链表实现队列

队列的创建Java实现

Java如何实现栈和队列

java中Map有哪些实现类和使用场景

Java实现消息队列服务

Java基础面试题5-Java中的队列都有哪些，有什么区别

1、利用Java的集合类实现队列（Queue）的一种方式

java队列实现类有哪些

Java队列实现

一、队列简单介绍

二、队列实现

1、创建节点类

2、创建队列类LinkQueue

3、测试

JAVA实现队列类

java 队列实现

java队列实现（顺序队列、链式队列、循环队列）

java LinkedList类实现 队列

数据结构_队列_Java中的实现类

JAVA集合 Deque 与 Queue 实现类 ArrayDeque(队列、双端队列) 源码浅析

Java双缓冲队列实现

Java Design Demo--java实现队列的类ExecutorService

Java实现 栈 和 队列

【Java】Java队列Queue使用详解

使用Java集合类实现队列

JAVA循环队列

用堆实现优先级队列 Java实现

【Java】Java双端队列Deque使用详解

Java实现环形队列

栈和队列在java中的实现

java使用链表实现队列

队列的创建Java实现

Java如何实现栈和队列

java中Map有哪些实现类和使用场景

Java实现消息队列服务

Java基础面试题5-Java中的队列都有哪些，有什么区别

1、利用Java的集合类实现队列（Queue）的一种方式

java队列实现类有哪些

java LinkedList类实现队列

Java实现栈和队列