精华内容
下载资源
问答
  • Java队列

    2018-04-03 15:30:09
    参考资料:https://blog.csdn.net/litong09282039/article/details/46359745
    展开全文
  • JavaJava 队列的遍历

    2019-09-28 01:14:17
    Java队列到底有没有可以遍历的功能呢?暂且试一下吧 参考链接:stl容器遍历测试 1.LinkedList实现简单遍历 for(Iter =LocTimesSerials.size()-1; iSearch < SizePatternX && Iter>= 0; --It...

            Java队列到底有没有可以遍历的功能呢?暂且试一下吧

            参考链接:stl容器遍历测试

           

    1.LinkedList实现简单遍历

    for(Iter =LocTimesSerials.size()-1; iSearch < SizePatternX && Iter>= 0; --Iter){
    				DeatS += LocTimesSerials.get(Iter).x;
    				++iSearch;
    			}



    转载于:https://www.cnblogs.com/wishchin/p/9200040.html

    展开全文
  • Java队列实现

    2015-04-14 10:32:59
    Java队列实现 队列定义栈(queue)是一种先进先出(first in first out,缩写为FIFO)的线性表。它只允许在表的一端进行插入,而在另一端删除元素。在队列中,允许插入的一端叫队尾(rear),允许删除的一端称为队头...

    队列定义

    栈(queue)是一种先进先出(first in first out,缩写为FIFO)的线性表。

    它只允许在表的一端进行插入,而在另一端删除元素。

    在队列中,允许插入的一端叫队尾(rear),允许删除的一端称为队头(front)。

    队的属性与方法

    Java程序代码实现

    public interface IMyQueue<T> {
    
        /*
         * 入队
         */
        boolean add(T data);
    
        /*
         * 出队
         */
        T poll();
    
        /*
         * 查看队列的第一个元素,不出队
         */
        T peek();
    
        /*
         * 队列长
         */
        int length();
    
        /*
         * 队列是否为空
         */
        boolean isEmpty();
    
        /*
         * 清空队列
         */
        void clear();
    }

    队列的顺序表示

    定义

    队列的顺序表示是用一组地址连续的存储单元依次存放队列中的各个元素,并用指针front指向队头,指针rear指向队尾。

    代码

    Java程序代码实现

    import java.util.Arrays;
    
    public class MyArrayQueue<T> implements IMyQueue<T> {
    
        private Object[] objs = new Object[16];
    
        /*
         * 队列长度
         */
        private int size;
    
        @Override
        public boolean add(T data) {
            if(size >= objs.length){
                addLength();
            }
            objs[size++]=data;
            return true;
        }
    
        @SuppressWarnings("unchecked")
        @Override
        public T poll() {
            if(size==0){
                return null;
            }
            Object temp = objs[0];
            for(int i=0 ;i<size-1;i++){
                objs[i] = objs[i+1];
            }
            size--;
            return (T) temp;
        }
    
        @Override
        public int length() {
            return size;
        }
    
        @Override
        public boolean isEmpty() {
            return size == 0;
        }
    
        @Override
        public void clear() {
            for (int i = 0; i < size; i++) {
                objs[i] = null;
            }
            size=0;
        }
    
        /*
         * 增加数组长度
         */
        private void addLength() {
            objs = Arrays.copyOf(objs, size*3/2+1);
        }
    
        @Override
        public String toString() {
            StringBuffer sb = new StringBuffer();
            sb.append("MyArrayQueue:[");
            for (int i = 0; i < size; i++) {
                sb.append(objs[i]);
                if(i != size-1){
                    sb.append(",");
                }
            }
            sb.append("]");
            return sb.toString();
        }
    
        @Override
        public T peek() {
            if(size==0){
                return null;
            }
            return (T) objs[0];
        }
    
    }

    队列的链式表示

    定义

    用链表表示的队列简称链队列。
    一个链队列需要两个分别指示队头和队尾的指针(分别称为头指针和尾指针)才能唯一确定。
    空的链队列的判决条件为头指针和尾指针均指向头节点。

    代码

    java程序代码实现

    public class MyLinkedQueue<T> implements IMyQueue<T> {
    
        /*
         * 队首指针
         */
        Node<T> front;
    
        /*
         * 队尾指针
         */
        Node<T> rear;
    
        /*
         * 队列长度
         */
        private int size;
    
        /*
         * 重载函数
         */
        public MyLinkedQueue() {
            Node<T> node = new Node<T>(null);
            this.rear = node;
            this.front = this.rear;
            this.size = 0;
        }
    
        @Override
        public boolean add(T data) {
            Node<T> node = new Node<T>(data);
            rear.next = node;
            rear = node;
            size++;
            return true;
        }
    
        @Override
        public T poll() {
            if(size==0){
                return null;
            }
            Object temp = front.next.data;
            front = front.next;
            size--;
            return (T) temp;
        }
    
        @Override
        public int length() {
            return size;
        }
    
        @Override
        public boolean isEmpty() {
            return size == 0;
        }
    
        @Override
        public void clear() {
            rear = front=null;
            size=0;
        }
    
        @Override
        public T peek() {
            return front.next.data;
        }
    
    }

    循环队列

    定义

    和顺序栈相类似,在队列的顺序存储结构中,除了用一组地址连续的存储单元依次存放从队头到队尾的元素之外,需附设两个指针front和rear分别指示队列头元素及队列尾元素的位置。

    在非空队列中,头指针始终指向队列头元素,而尾指针始终指向队列尾元素的下一个位置。只凭Q.front \== Q.rear无法判别队列空间是“空”还是“满”。可有两种处理方法:其一是另设一个标志位以区别队列是“空”还是“满”;其二是少用一个元素空间,约定以“队列头指针在队列尾指针的下一位置(指环状的下一位置)上”作为队列呈“满”状态的标志。

    循环队列空或满的判断条件

    队空:Q.front \== Q.rear
    队满:Q.front \== (Q.rear+1)%MAXSIZE

    代码

    Java程序代码实现

    public class CirularQueue<T> implements IMyQueue<T> {
    
        /*
         * 队首下标
         */
        int front;
    
        /*
         * 队尾下标
         */
        int rear;
    
        private Object[] objs;
    
        public CirularQueue(){
            this(11); // 默认队列内有10个元素
        }
    
        public CirularQueue(int size) {
            // 队列最大长度为size个元素,保证rear转一圈之后不会和head相等
            // 也就是队列满的时候,rear+1=head,中间刚好空一个元素。当rear=head的时候,一定是队列空了
            objs = new Object[size+1]; 
            front = 0;
            rear = 0;
        }
    
        /*
         * 队列长度
         */
        private int size;
    
        @Override
        public boolean add(T data) {
            if(front == (rear+1)% (objs.length)){
                return false;
            }
            objs[rear] = data;
            rear = (rear+1)%(objs.length);
            size++;
            return true;
        }
    
        @Override
        public T poll() {
            if(front == rear){
                return null;
            }
            Object temp = objs[front];
            front = (front+1) % (objs.length);
            size--;
            return (T) temp;
        }
    
        @Override
        public T peek() {
            if(front == rear){
                return null;
            }
            return (T) objs[front];
        }
    
        @Override
        public int length() {
            return size;
        }
    
        @Override
        public boolean isEmpty() {
            return size == 0;
        }
    
        @Override
        public void clear() {
            for(int i = front; i < front+size; i++){
                objs[i%(objs.length)]=null;
            }
            front = rear = 0;
            size = 0;
        }
    
    }
    展开全文
  • java 队列、优先级队列、双向队列示例演示代码
    java 队列、优先级队列、双向队列示例演示代码
    package org.rui.collection2.queues;
    
    import java.util.LinkedList;
    import java.util.PriorityQueue;
    import java.util.Queue;
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.ConcurrentLinkedQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.PriorityBlockingQueue;
    
    import org.rui.generics.anonymity.Generator;
    /**
     * 下面涉及Queue实现的大部分操作的基本示例
     * 可以看到除了优先队列,Queue将精确地按照元素被置于Queue中的顺序产生它们
     * @author lenovo
     *
     */
    public class QueueBeHavior {
    	private static int count=10;
    	static<T> void test(Queue<T> queue,Generator<T> gen)
    	{
    		for(int i=0;i<count;i++)
    		{
    			//T temp=gen.next();
    			//System.out.println(temp);
    			queue.offer(gen.next());
    		}
    		
    		while(queue.peek()!=null)
    			System.out.print(queue.remove()+"  ");
    		    System.out.println();
    	}
    
    	static class Gen implements Generator<String>
    	{
    		String[] s=
    		("one tow three four five six seven eight nine ten".split(" "));
    		int i;
    
    		public String next() 
    		{
    			return s[i++];
    		}
    	}
    	
    	public static void main(String[] args) 
    	{
    		test(new LinkedList<String>(),new Gen());
    		test(new PriorityQueue<String>(),new Gen());
    		test(new ArrayBlockingQueue<String>(count),new Gen());
    		test(new ConcurrentLinkedQueue<String>(),new Gen());
    		test(new LinkedBlockingQueue<String>(),new Gen());
    		test(new PriorityBlockingQueue<String>(),new Gen());
    	}
    }
    /**output:
    one  tow  three  four  five  six  seven  eight  nine  ten  
    eight  five  four  nine  one  seven  six  ten  three  tow  
    one  tow  three  four  five  six  seven  eight  nine  ten  
    one  tow  three  four  five  six  seven  eight  nine  ten  
    one  tow  three  four  five  six  seven  eight  nine  ten  
    eight  five  four  nine  one  seven  six  ten  three  tow 
     */
    

    package org.rui.collection2.queues;
    
    import java.util.PriorityQueue;
    
    /**
     * 优先级队列
     * 主要和次要的优先级排序
     * 该列表的排序顺序也是通过实现Comparable而进行控制的
     * @author lenovo
     *
     */
    public class ToDoList  extends PriorityQueue<ToDoList.ToDoItem>
    {
    
    	static class ToDoItem implements Comparable<ToDoItem>
    	{
    		private char primary;//主要的
    		private int secondary;//二
    		private String item;
    		
    		public ToDoItem(String item,char primary, int secondary) 
    		{
    			this.primary = primary;
    			this.secondary = secondary;
    			this.item = item;
    		}
    		
    		public int compareTo(ToDoItem o) 
    		{
    			if(primary>o.primary)//先比较主要的
    				return +1;
    			if(primary==o.primary)
    				if(secondary>o.secondary) //再比较次要的
    					return +1;
    				else if(secondary==o.secondary)
    					return 0;
    			return -1;
    		}
    		
    		public String toString()
    		{
    			return Character.toString(primary)+secondary+": "+item;
    		}
    	}
    	
    	public void add(String td,char pri,int sec)
    	{
    		super.add(new ToDoItem(td, pri, sec));
    	}
    	
    	public static void main(String[] args) {
    		ToDoList to=new ToDoList();
    		to.add("Empty Trash",'C',4);
    		to.add("Feed dog",'A',2);
    		to.add("Feed bird",'B',7);
    		to.add("Mow lawn",'C',3);
    		to.add("Water lawn",'A',1);
    		to.add("Feed cat",'B',1);
    		
    		while(!to.isEmpty())
    		{
    			System.out.println(to.remove());
    		}
    	}
    }
    /**output:
    A1: Water lawn
    A2: Feed dog
    B1: Feed cat
    B7: Feed bird
    C3: Mow lawn
    C4: Empty Trash
     */
    

    package org.rui.collection2.queues;
    
    import java.util.LinkedList;
    
    /**
     * 双向队列就是一个队列,但是你可以在任何一端添加或移除元素,
     * LinkedList无法实现这样的接口,但可以使用组合来创建一个Deque类,
     * @author lenovo
     *
     * @param <T>
     */
    
    public class Deque<T>  {
    	private LinkedList<T> deque=new LinkedList<T>();
    	public void addFirst(T e){deque.addFirst(e);}
    	public void addLast(T e){deque.addLast(e);}
    	public T getFirst(T e){return deque.getFirst();}
    	public T getLast(T e){return deque.getLast();}
    	public T removeFirst(){return deque.removeFirst();}
    	public T removeLast(){return deque.removeLast();}
    	public int size(){return deque.size();}
    	public String toString(){return deque.toString();}
    	//and other methods as necessary............
    	
    	
    	public static void fillTest(Deque<Integer> de)
    	{
    		for(int i=10;i<17;i++)
    			de.addFirst(i);
    		for(int i=50;i<55;i++)
    			de.addLast(i);
    	}
    	public static void main(String[] args) {
    		Deque<Integer> deque=new Deque<Integer>();
    		fillTest(deque);
    		System.out.println(deque);
    		while(deque.size()!=0)
    			System.out.print(deque.removeFirst()+"  ");
    		System.out.println();
    		fillTest(deque);
    		while(deque.size()!=0)
    			System.out.print(deque.removeLast()+"  ");
    		System.out.println();
    		
    	}
    	
    }
    /** output:
    [16, 15, 14, 13, 12, 11, 10, 50, 51, 52, 53, 54]
    16  15  14  13  12  11  10  50  51  52  53  54  
    54  53  52  51  50  10  11  12  13  14  15  16 
    */

    展开全文
  • Java队列和C队列的区别 (1)C语言中的队列是通过采用指针(链式队列)或”虚拟指针”(对于数组队列而言,通过采用数组的索引的自增和自减来模拟指针的移动)的移动,来定位队列的头部和尾部,以便于实现队列的FIFO...
  • Java队列的部分调用方法

    千次阅读 2020-06-02 14:41:52
    Java队列的部分调用方法 方法 作用 说明 add() 增加一个元素 如果队列已满,则抛出一个IIIegaISlabEepeplian异常 remove() 移除并返回队列头部的元素 如果队列为空,则抛出一个NoSuchElementException异常...
  • JAVA队列系列教程<1>

    2016-10-19 17:43:38
    java队列 缓存队列 先进先出
  • Java队列Queue

    千次阅读 2020-01-29 20:10:45
    欲速则不达,欲达则欲速! 队列Queue是一个先进先出的数据结构;与list、set同一级别,...队列不满时可执行插入元素线程,直到队列满。 2、移除 队列不为空时都可移除,直到队列为空。 抛出异常:满的时候插...
  • Java队列详解之 LinkedList 类 1. 类简介 类释义 A collection designed for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, ...
  • 【Java】Java队列Queue使用详解

    万次阅读 多人点赞 2018-09-10 16:29:27
    Queue是java中实现队列的接口,它总共只有6个方法,我们一般只用其中3个就可以了。Queue的实现类有LinkedList和PriorityQueue。最常用的实现类是LinkedList。
  • java队列(Queue)用法总结

    万次阅读 多人点赞 2018-11-30 19:05:56
    1.队列的特点 队列是一种比较特殊的线性结构。它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作。进行插入操作的端称为队尾,进行删除操作的端称为队头。 队列中最先插入的元素也将最先...
  • Java队列介绍&用队列实现栈

    千次阅读 2020-06-04 16:40:58
    本文将介绍队列的概念以及Java中队列Queue的继承关系。第二部分将用队列实现栈。
  • java队列详解

    万次阅读 2018-05-14 08:14:44
    Queue: 是一个队列,即一个先入先出(FIFO)的数据结构... Queue的实现1、没有实现的阻塞接口的LinkedList: 实现了java.util.Queue接口和java.util.AbstractQueue接口 内置的不阻塞队列: PriorityQueue 和 C...
  • 简单java队列

    千次阅读 2018-01-05 22:03:27
    队列是一种特殊的线性表,它只允许在表的前端进行删除操作,而在表的后端进行插入操作。 LinkedList类实现了Queue接口,因此我们可以把LinkedList当成Queue来用。 以下实例演示了队列(Queue)的用法: /* ...
  • Java 队列Queue及循环队列

    千次阅读 2019-04-04 17:45:14
    队列是一种线性结构。 相比数组,队列对应的操作是数组的子集。 只能从一段(队尾)添加元素,只能从另一端(队首取出元素)。 队列的操作: 队列的实现: 添加元素(入队) : void enqueue(E) 删除...
  • JAVA队列之优先队列

    千次阅读 2016-05-24 09:01:55
    最近在项目开发中开发了全双工异步长连接的通讯组件,内部用到了延迟队列。而延迟队列的内部实现的存储是用到了优先队列,当时看C++的数据结构时,了解过优先队列,用的存储是二叉树的逻辑,应该叫完全二叉树,也...
  • JAVA 队列: SynchronousQueue

    千次阅读 2019-06-24 17:54:20
    SynchronousQueue 是一个不存储元素的阻塞队列。每一个 put 操作必须等待一个 take 操作,否则不能继续添加元素。 SynchronousQueue 可以看成是一个传球手,负责把生产者线程处理的数据直接传递给消费者线程。队列...
  • java队列的使用

    2021-03-02 22:53:24
    1、继承LinkedBlockingQueue ...LinkedBlockingQueue不指定队列容量时,默认为Integer.MAX_VALUE,即无界队列,为了避免队列过大造成机器负载或者内存爆满,建议手动传一个队列的大小。LinkedBlock
  • java队列学习

    2015-02-25 20:38:27
    java.util.Queue是Java 5中的一个最简单和基本的队列,要避免使用该接口的add和remove方法,因为使用中可能会抛出异常。 比较常用的两个方法是offer和poll方法 offer方法:向队列中加入元素 poll方法:获取队列中...
  • java队列的种类

    千次阅读 2018-04-26 09:57:23
    没有实现阻塞接口:实现java.util.Queue的LinkList,实现java.util.AbstractQueue接口内置的不阻塞队列: PriorityQueue 和 ConcurrentLinkedQueue实现阻塞接口的java.util.concurrent 中加入了 BlockingQueue ...
  • Java队列基础用法

    千次阅读 2019-03-23 15:17:30
    Java5中新增加了java.util.Queue接口,用以支持队列的常见操作。该接口扩展了java.util.Collection接口。 * * Queue使用时要尽量避免Collection的add()和remove()方法,而是要使用offer()来加入元素,使用...
  • Java 队列 ArrayList。简单自定义队列

    千次阅读 2018-08-26 17:28:38
    第一步:查看,剖析ArrayList源代码 第二步:简单自定义队列 队列动态添加元素的机制:新建一个数组对象,再把原数组中的元素和新元素放入其中,再把新数组的地址变成原数组的地址。...泛型:泛型是Java SE 1....
  • java 队列方法详解

    千次阅读 2019-03-09 20:55:59
    一、队列支持的方法(Queue) throw exception return special value insert add 1、增加元素不能为null 2、其他异常,比如有界队列 offer ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,167
精华内容 18,866
关键字:

java队列

java 订阅