精华内容
下载资源
问答
  • 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队列的简单实现就介绍到这里。


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

    展开全文
  • 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("");
       } 
    }

     

     

     

     

     

     

    展开全文
  • 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
  • 数据结构_队列_Java中的实现类

    千次阅读 2020-06-21 15:42:41
    我们对基础的数据结构队列都非常的熟悉,这里回顾下 ...Java 中的队列可以利用实现 Deque 接口的类作为实现类, Deque 的实现类主要分为两种场景: 一般场景 LinkedList 大小可变的链表双端队列,允许元素为 nu...
  • 文章目录JAVA集合 Deque实现类 ArrayDeque(双端队列) 源码浅析一、简述:二、ArrayDeque 类结构与属性三、ArrayDeque 构造方法四、Queue 与 Deque 的方法1. 添加元素 add(E e) JAVA集合 Deque实现类 ArrayDeque(双端...
  • Java双缓冲队列实现

    千次阅读 2017-04-18 09:30:15
    Java实现了一个双缓冲队列,并给出了实例代码
  • 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。
  • 使用Java集合类实现队列

    千次阅读 2012-09-17 14:50:32
    1、要求实现一个FIFO队列;能够查看最大值、最小值、中位数;队列中的每个对象能够比较大小。 接口1: package jp.co.worksap.recruiting; public interface ExamPeekableQueue> { public void enqueue(E e); ...
  • JAVA循环队列

    千次阅读 2017-09-15 15:25:44
    一、JAVA 中已经自带了 Queue、DQueue、ArrayList、LinkedList 等常用的数据结构,为什么还要单独实现循环队列? 之所以使用自定义循环队列,出发点还是基于我们在实际应用中对于数据处理各种各样的需求。使用...
  • 用堆实现优先级队列 Java实现

    千次阅读 2016-03-19 00:14:47
    优先级队列分为最大优先级队列和最小优先级队列。本文介绍基于大根堆实现最大优先级队列。关于堆的介绍见另一篇博文: 堆这种数据结构 Java实现 最小优先级队列实现可以在本文最后给出的github地址里找到。
  • JavaJava双端队列Deque使用详解

    万次阅读 多人点赞 2018-09-15 18:14:05
    Deque是一个双端队列接口,继承自Queue接口,它们共同的实现类是LinkedList。 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 整体架构如下所示 自定义协议 首先从上一篇中介绍了协议的...
  • Queue: 基本上,一个队列就是一个先入先出(FIFO)的数据... Queue的实现1、没有实现的阻塞接口的LinkedList: 实现java.util.Queue接口和java.util.AbstractQueue接口 内置的不阻塞队列: PriorityQueue ...
  • Java中通过集合实现Queue(队列): package QueueLearn; import java.util.ArrayList; import java.util.List; //2.使用集合实现队列功能,使用int数组保存数据特点:先进先出,后进后出 public class QueueText02...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 300,216
精华内容 120,086
关键字:

java队列实现类有哪些

java 订阅