精华内容
下载资源
问答
  • 队列的基本概念以及java实现队列

    千次阅读 2018-08-16 22:42:33
    获取队列长度 链式队列 构造函数 入队 出队 查询front 获取队列长度 循环列队 构造函数 入队 出队 查询front 获取循环队列的大小 判断队列是否为空 判断队列是否满 代码传送门,欢迎star:...

    队列

    代码传送门,欢迎star:https://github.com/mcrwayfun/java-data-structure

    1. 队列的基本概念

    队列是一种限定存取位置的线性表。它只允许在表的一端插入,在另一端删除。允许插入的一端叫做队尾,允许删除的一端叫做队头。

    每次在队尾加入元素,因此入队的顺序为a1,a2,a3,…,an,最先入队的元素最先出队,所以队列具有的这种特性成为先进先出FIFO(First In First Out

    2. 队列的抽象数据类型

    队列是一种特殊的线性表,其包含了一般线性表的操作,抽象数据类型ADT可以概括为两种:基于数组的存储表示和基于链表的存储表示。基于数组实现的是栈称为顺序队列,基于链表实现的栈称为链式队列。基本方法可以概括为

    public interface Queue<E> {
        // 判断队列是否为空
        boolean isEmpty();
        // 入队
        void push(E data);
        // 出队
        E pop();
        // 查询front
        E peek();
        // 清空队列
        void clear();
        // 返回当前队列中的元素个数
        int length();
    }

    3. 顺序队列

    顺序栈基于数组来存储表示,申明一个一维数组来存储数据

    private Object[] elementData;

    定义两个整型变量front和rear,分别表示为队头和队尾;队头front保存着即将出队的元素的索引,而队尾rear保存着下一个即将入队元素的索引。DEFAULT_SIZE为初始化数组的默认长度,capacity为数组中元素的个数

    // 队列默认长度
    private int DEFAULT_SIZE = 10;
    // 保存数组的长度。
    private int capacity;
    // 队列头元素位置
    private int front = 0;
    // 队列尾元素位置
    private int rear = 0;

    3.1 构造函数

    提供一个无参构造函数来初始化数组,数组长度为DEFAULT_SIZE

    /**
      * 初始化数组长度和数组
      */
    public SequenceQueue() {
      this.capacity = DEFAULT_SIZE;
      elementData = new Object[capacity];
    }

    提供value作为队列第一个元素,initSize作为数组的初始化长度

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

    3.2 入队

    检查队列是否已经满了,若不满则在队尾入队,且rear++

        /**
         * 入队
         *
         * @param data
         * @throws IndexOutOfBoundsException
         */
        @Override
        public void push(E data) {
    
            // 检查队列是否已经满了
            checkQueueIsFull();
    
            elementData[rear++] = data;
        }

    3.3 出队

    检查队列是否为空,若不为空则在队头出队,且front++

        /**
         * 出队,推出元素
         *
         * @return
         * @throws IndexOutOfBoundsException
         */
        @Override
        @SuppressWarnings("unchecked")
        public E pop() {
    
            // 检查队列是否为空
            checkQueueIsEmpty();
    
            E oldValue = (E) elementData[front];
            // 释放队列已经出栈的元素
            elementData[front++] = null;
            return oldValue;
        }

    3.4 查询front

        /**
         * 推出元素但不出队
         *
         * @return
         * @throws IndexOutOfBoundsException
         */
        @Override
        @SuppressWarnings("unchecked")
        public E peek() {
    
            // 检查队列是否为空
            checkQueueIsEmpty();
    
            return (E) elementData[front];
        }

    3.5 获取队列长度

        /**
         * 获取顺序队列的大小
         *
         * @return
         */
        @Override
        public int length() {
            return rear - front;
        }

    4. 链式队列

    链式队列使用结点的方式来存储表示数据,不用预先分配存储空间。使用front指针表示队头,rear指针表示队尾,size来统计当前队列中的结点数

        /**
         * 定义一个内部类Node,实现链表队列的结点
         *
         * @param <E>
         */
        private static class Node<E> {
    
            E item;
            Node<E> next;
    
            public Node() {
            }
    
            public Node(E item, Node<E> next) {
                this.item = item;
                this.next = next;
            }
        }
    
        /**
         * 队列头指针
         */
        private Node<E> front;
        /**
         * 队列尾指针
         */
        private Node<E> rear;
        /**
         * 队列包含的结点数
         */
        private int size;

    4.1 构造函数

    无参构造函数

        /**
         * 无参构造函数
         */
        public LinkQueue() {
            front = null;
            rear = null;
        }

    以特定的数据来构造链表队列的头结点

        /**
         * 以特定的数据来构造链表队列的头结点
         *
         * @param data
         */
        public LinkQueue(E data) {
    
            front = new Node<>(data, null);
            rear = front;
            size++;
        }

    4.2 入队

    分两种情况,队列为空和不为空。若队列为空,则队头指针和队尾指针均指向新结点;若不为空,则队尾指针rear.next = newNode,且newNode成为新的队尾

        /**
         * 入队
         *
         * @param data
         */
        @Override
        public void push(E data) {
            Node<E> newNode = new Node<>(data, null);
            // 当前队列为空
            if (isEmpty()) {
                front = newNode;
                rear = newNode;
            } else {
                // 队列存在元素
                // 尾结点的next指向新结点
                rear.next = newNode;
                // 新结点成为新的尾结点
                rear = newNode;
            }
            size++;
        }

    4.3 出队

    先检查队列是否为空,若不为空才能执行出队操作。出队元素为当前front指针指向的结点

        /**
         * 出队,并删除头元素
         *
         * @return
         * @throws IndexOutOfBoundsException
         */
        @Override
        public E pop() {
    
            // 检测队列是否空
            checkQueueIsEmpty();
            Node<E> oldFront = front;
            front = front.next;
            oldFront.next = null;
            size--;
            return oldFront.item;
        }

    4.4 查询front

    当前front指向的结点即为队头

        /**
         * 查找队列的front元素
         *
         * @return
         * @throws IndexOutOfBoundsException
         */
        @Override
        public E peek() {
    
            // 检测队列是否空
            checkQueueIsEmpty();
            return front.item;
        }

    4.5 获取队列长度

        /**
         * 返回队列长度
         *
         * @return
         */
        @Override
        public int length() {
            return size;
        }

    5. 循环列队

    这是一个顺序队列,由图中可以得知,当front == rear的时候,队列为空。当rear = maxSize(maxSize = 数组长度),队列满,如果再加入新的元素,则会产生溢出。但是,这种溢出是一种假溢出,因为数组的前端可能还存在空位置,为了能够充分利用数组中的元素,把数组的前端和后端连接起来,形成一个环形的表,这就是循环队列。

    循环队列首尾相接,当队头指针front和队尾rear进到maxSize-1时,在前进一个位置就自动到0,所以:
    **队头指针进1:front = (front + 1)% maxSize
    队尾指针进1:rear = (rear + 1) % maxSize**

    队列为空的判断条件为front == rear,为了区别,队满的判断条件为front == (rear + 1) % maxSize,即当rear指向front的前一位置时就认为队列已经满了。还有一种判断队列满的方法,定义一个flag,当出队时,让flag = 0;入队时,让flag = 1。当遇到front == rear,若flag = 0,则队列空;若flag = 1,则队列满

        // 队列默认长度
        private int DEFAULT_SIZE = 10;
    
        // 用来保存队列元素的数组
        private Object[] elementData;
        // 保存数组的长度。
        private int capacity;
        // 队列头元素位置
        private int front = 0;
        // 队列尾元素位置
        private int rear = 0;

    上述代码是操作循环队列申明的变量,用数组elementData来存储数据,capacity标识数组的长度。因为存在数组,我们可以利用elementData[rear]elementData[front]来替换flag。当遇到front == rear时,若elementData[rear] == null,则队列空;若elementData[front] != null,则队列满

    5.1 构造函数

    无参构造函数,使用默认长度DEFAULT_SIZE来初始化数组长度

        public LoopQueue() {
            this.capacity = DEFAULT_SIZE;
            elementData = new Object[capacity];
        }

    以初始元素和初始长度来构建循环队列

        /**
         * 以初始元素和初始长度来构建循环队列
         *
         * @param data
         * @param initSize
         */
        public LoopQueue(E data, int initSize) {
    
            this.capacity = initSize;
            elementData = new Object[capacity];
            elementData[0] = data;
            rear++;
        }

    5.2 入队

    入队前先判断队是否满了,若满了则不能入队。将data放入数组,且rear++。判断rear == capacity,若等于则从下标0开始

         /**
         * 入队
         *
         * @param data
         * @throws IndexOutOfBoundsException
         */
        @Override
        public void push(E data) {
    
            // 判断队列是否已经满了
            checkQueueIsFull();
            elementData[rear++] = data;
            // rear到头则rear转头
            rear = rear == capacity ? 0 : rear;
        }

    5.3 出队

    出队前先判断队列是否为空,若空了则不能出队。出队后front++,判断front == capacity,若等于则从下标0开始

        /**
         * 出队并删除头元素
         *
         * @return
         * @throws IndexOutOfBoundsException
         */
        @Override
        @SuppressWarnings("unchecked")
        public E pop() {
    
            // 判断队列是否为空
            checkQueueIsEmpty();
            E oldValue = (E) elementData[front];
            elementData[front++] = null;
            // front到头则front转头
            front = front == capacity ? 0 : front;
            return oldValue;
        }

    5.4 查询front

        /**
         * 查找队列的第一个元素
         *
         * @return
         * @throws IndexOutOfBoundsException
         */
        @Override
        @SuppressWarnings("unchecked")
        public E peek() {
    
            // 判断队列是否为空
            checkQueueIsEmpty();
            return (E) elementData[front];
        }

    5.5 获取循环队列的大小

    分两种情况,如果front < rear,有效元素就是front到rear之间的元素,直接用rear - front即可;如果front >= rear,有效元素为front->capacity之间,0->front之间的

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

    5.6 判断队列是否为空

        /**
         * 判断队列是否为空
         *
         * @return
         */
        @Override
        public boolean isEmpty() {
            return rear == front
                    && elementData[rear] == null;
        }

    5.7 判断队列是否满

        /**
         * 判断队列是否已经满了,若满了则抛出IndexOutOfBoundsException
         */
        private void checkQueueIsFull() {
    
            if (rear == front && elementData[front] != null) {
                // throw exception
            }
        }
    展开全文
  • 思路就是简单bfs,首先是值为0入队,然后每次取出队列第一个元素,更新四个方向,如果当前距离+1小于原距离,就将原距离更新即可。 注意Java中队列,offer()是添加元素,poll()取出...

    给定一个由 0 和 1 组成的矩阵,找出每个元素到最近的 0 的距离。

    两个相邻元素间的距离为 1 。

    示例 1:
    输入:

    0 0 0
    0 1 0
    0 0 0
    输出:

    0 0 0
    0 1 0
    0 0 0

    思路就是简单的bfs,首先是值为0的入队,然后每次取出队列第一个元素,更新四个方向,如果当前距离+1小于原距离,就将原距离更新即可。

    注意Java中队列,offer()是添加元素,poll()取出第一个元素并删除,size()判断队列内元素,peek()查看第一个元素。

    此外注意一下二维数组判断行列距离的方法。

    class Solution {
        int dirx[] = {0,0,1,-1};
        int diry[] = {1,-1,0,0};
        public int[][] updateMatrix(int[][] matrix) {
            Queue<Integer>q = new LinkedList<Integer>();
            //取行列大小的方法
            int rowlen = matrix.length;
            int collen = matrix[0].length;
            int ans[][] = new int [rowlen][collen];
            for(int i=0;i<rowlen;i++)
            {
                for(int j=0;j<collen;j++)
                {
                    if(matrix[i][j]==0)
                    {
                        ans[i][j] = 0;
                        q.offer(i*collen+j);
                    }
                    else
                    {
                        ans[i][j] = 0x3f3f3f3f;//初始化为无穷大
                    }
                }
            }
            while(q.size()>0)
            {
                int now = q.poll();
                int x = now/collen;
                int y = now%collen;
                for(int i=0;i<=3;i++)
                {
                    //遍历四个方向
                    int next_x = x+dirx[i];
                    int next_y = y+diry[i];
                    if(next_x<0||next_x>=rowlen||next_y<0||next_y>=collen)
                    {
                        continue;
                    }
                    if(ans[next_x][next_y]<0x3f3f3f3f)
                    {
                        continue;
                    }
                    if(ans[next_x][next_y] > ans[x][y]+1)
                    {
                        ans[next_x][next_y] = ans[x][y]+1;
                        q.offer(next_x*collen+next_y);
                    }
                }
            }
            return ans;
        }
    }
    
    展开全文
  • java数组队列

    2018-09-06 16:37:20
    下面是我对java数组队列的理解。 什么是数组队列? 数组队列就是利用数组存储数据的属性来改变它只有固定长度的局限性,增加了一些删除,添加数据等功能,增加了其灵活性; 数组队列的实现 数组队列实现分为两...

    学习不久,理解不深。有错误之处还请指正。下面是我对java数组队列的理解。

    什么是数组队列?

    数组队列就是利用数组存储数据的属性来改变它只有固定长度的局限性,增加了一些删除,添加数据等功能,增加了其灵活性;

    数组队列的实现

    数组队列实现分为两部分:

    1.数组队列接口

    在数组队列接口中需要定义一些抽象方法,例如删除数据,添加数据,获取数据等方法

    若你想存储多种类型的数据你可以使用泛型,泛型可以用来指任何类型的一种数据。下面的代码使用泛型编写的,以便于添加存储自己想要的类型数据。

    接下来创建一个接口List<E>类,用来删除数据,添加数据,获取数据等等,下面是代码。

    public interface List<E> {
    public void add(E e);//向队列末尾添加一个元素
    public boolean add(int index,E e);//向指定位置添加一个元素,添加成功返回true,添加失败返回false;
    public E getE(int index);//获取指定位置的元素
    public E remove(int index);//删除指位置的元素
    public boolean remove(E e);//删除元素
    public boolean update(int index,E e);//更新指定位置的元素
    public boolean update(E e,E newValue);//更新某一个元素
    public boolean removeall();//移除所有元素
    public int size();//获取数组队列中元素个数的总数
    }

     

    2.数组队列类

    在数组队列类中继承数组队列接口,然后要定义两个重要的属性,分别是数组长度length元素个数size;然后在重写接口中的所有方法就可以了,关键是写好添加,删除等方法;下面的代码使用泛型编写的,以便于添加存储自己想要的类型数据。

    下面是数组队列类myArraysList<E>的代码

    public class myArraysList<E> implements List<E>{
    	private static int size=0;//定义数组队列中元素个数的初始值,为了在数组队列类中测试下面的方法是否正确,所以设置成静态
    	private static int length=1;//记录数组初始长度,为了在数组队列类中测试下面的方法是否正确,所以设置成静态
    	Object [] Array;//声明一个数组变量
    	public myArraysList(int length){
    		this.length=length;
    		Array=new Object[length];//定义数组长度为length
    	}
    	@Override
    	public void add(E e) {//向队列末尾添加一个元素
    		// TODO Auto-generated method stub
    		if(size<length){//元素个数小于数组长度就添加
    			Array[size]=e;
    			
    		}
    		else{
    			Object[] Array1=new Object[length*2];//Array1指定义的一个新的数组
    			for(int i=0;i<length;i++){
    				Array1[i]=Array[i];
    			}
    			Array1[size]=e;
    			Array=Array1;
    			length=Array1.length;
    		}
    		size++;
    	}
    
    	@Override
    	public boolean add(int index, E e) {//向指定位置添加一个元素,添加成功返回true,添加失败返回false;
    		// TODO Auto-generated method stub
    		if(index<0||index>=size){
    			System.out.println("超过数组的size就不能添加");
    			return false;
    		}
    		else{
    			Object []Array1=new Object[size+1];//Array1指定义的一个新的数组
    			for(int i=0;i<index;i++){
    				Array1[i]=Array[i];
    			}
    			Array1[index]=e;//把要添加的元素加入指定位置
    			for(int i=index;i<size;i++){
    				Array1[i+1]=Array[i];
    			}
    			Array=Array1;
    			length=Array1.length;
    			size++;
    		return true;
    		}
    		
    	}
    
    	@SuppressWarnings("unchecked")
    	@Override
    	public E getE(int index) {//获取指定位置的元素
    		// TODO Auto-generated method stub
    		if(index<0||index>=size){
    			return null;
    		}
    		else{
    		return (E)Array[index];
    		}
    	}
    
    	@Override
    	public E remove(int index) {//删除指位置的元素
    		// TODO Auto-generated method stub
    		if(index<0||index>=size){
    			System.out.println("超过数组的size就不能删除");
    		}
    		else{
    			Array[index]=null;
    			for(int i=index;i<size-1;i++){
    				Array[i]=Array[i+1];
    			}
    			size--;
    		}
    		return null;
    	}
    
    	@Override
    	public boolean remove(E e) {//删除元素
    		// TODO Auto-generated method stub
    		for(int i=0;i<size;i++){
    			if(Array[i]==e){
    				Array[i]=null;
    				for(int j=i;j<size-1;j++){
    					Array[j]=Array[j+1];
    				}
    				size--;
    			}
    		}
    		return true;
    	}
    
    	@Override
    	public boolean update(int index, E e) {//更新指定位置的元素
    		// TODO Auto-generated method stub
    		if(index>=0&&index<size){
    			Array[index]=e;
    			}	
    		return true;
    	}
    
    	@Override
    	public boolean update(E e, E newValue) {//更新某一个元素
    		// TODO Auto-generated method stub
    		for(int i=0;i<size;i++){
    			if(Array[i]==e){
    				Array[i]=newValue;
    			}
    		}
    		return true;
    	}
    
    	@Override
    	public boolean removeall() {//移除所有元素
    		// TODO Auto-generated method stub
    		Object []Array1=new Object[0];
    		Array=Array1;
    		if(Array.length ==0)
    			return true;
    		else
    			return false;
    	}
    
    	@Override
    	public int size() {//获取数组队列中元素个数的总数
    		// TODO Auto-generated method stub
    		return size;
    	}
    	public static void main(String [] args){//这里主函数是为了测试上式方法的正确性
    		myArraysList<String> mylist=new myArraysList<String>(length);//创建数组队列对象myArraysList
    		mylist.add("wo");
    		mylist.add("xihuan");
    		mylist.add("ni");
    		mylist.add(2, "you");
    		
    		for(int i=0;i<size;i++){
    			Object e=mylist.getE(i);
    			System.out.println("得到的元素是:"+e);
    		}
    		mylist.remove("you");
    		mylist.update(2, "i");
    		//mylist.removeall();
    		for(int i=0;i<size;i++){
    			Object e=mylist.getE(i);
    			System.out.println("得到的元素是:"+e);
    		}
    	}
    }

    参考:https://blog.csdn.net/weixin_42621338/article/details/82080167

     

     

     

     

     

    展开全文
  • Java阻塞队列之BlockingQueue

    千次阅读 2020-08-14 10:25:30
    阻塞队列的概念 当阻塞队列是空时,从队列中获取元素的操作将会被阻塞 当阻塞队列是满时,往队列里添加元素的操作将会被阻塞 ArrayBlockingQueue ... // 定义阻塞队列的长度为3 BlockingQue..

    阻塞队列的概念

    •   当阻塞队列是空时,从队列中获取元素的操作将会被阻塞
    •   当阻塞队列是满时,往队列里添加元素的操作将会被阻塞

    ArrayBlockingQueue

    数组组成的有界阻塞队列

    代码示例:add、remove、element(一言不合就报错比较暴力)

        public static void main(String[] args) throws InterruptedException {
            // 定义阻塞队列的长度为3
            BlockingQueue blockingQueue = new ArrayBlockingQueue(3);
            // 使用add插入,如果队列已满则会直接报错
            blockingQueue.add(1);
            blockingQueue.add(2);
            blockingQueue.add(3);
            blockingQueue.add(4);
            // 使用element检查队列,如果队列是空则直接报错
            blockingQueue.element();
            // 使用remove删除元素,如果队列是空直接报错
            blockingQueue.remove();
            blockingQueue.remove();
            blockingQueue.remove();
            blockingQueue.remove();
        }

    代码示例:offer、poll、peek(比较温和,不会报错只会返回false和null)

        public static void main(String[] args) throws InterruptedException {
            // 定义阻塞队列的长度为3
            BlockingQueue blockingQueue = new ArrayBlockingQueue(3);
            // 使用offer插入,如果队列已满则会返回false
            System.out.println(blockingQueue.offer(1));
            System.out.println(blockingQueue.offer(2));
            System.out.println(blockingQueue.offer(3));
            System.out.println(blockingQueue.offer(4));
            // 使用peek检查队列,如果队列是空返回null
            System.out.println(blockingQueue.peek());
            // 使用poll删除元素,如果队列是空返回null
            System.out.println(blockingQueue.poll());
            System.out.println(blockingQueue.poll());
            System.out.println(blockingQueue.poll());
            System.out.println(blockingQueue.poll());
        }
    

    代码示例:put、take(在队列是满的情况下put操作会一直等待空出来位置,在是空的情况下take操作会等待队列有值)

        public static void main(String[] args) throws InterruptedException {
            // 定义阻塞队列的长度为3
            BlockingQueue blockingQueue = new ArrayBlockingQueue(3);
            // 使用put插入,如果队列已满则会一直等待队列空出来
            blockingQueue.put(1);
            blockingQueue.put(2);
            blockingQueue.put(3);
            blockingQueue.put(4);
            // 使用take删除元素,如果队列是空会一直等待队列有值
            System.out.println(blockingQueue.take());
            System.out.println(blockingQueue.take());
            System.out.println(blockingQueue.take());
            System.out.println(blockingQueue.take());
        }

    代码示例:offer、poll(限时等待,加入了限时秒数,等待x秒后不再阻塞)

        public static void main(String[] args) throws InterruptedException {
            // 定义阻塞队列的长度为3
            BlockingQueue blockingQueue = new ArrayBlockingQueue(3);
            // 使用限时offer插入,如果队列已满则会等待1s后退出
            blockingQueue.offer(1,1L,TimeUnit.SECONDS);
            blockingQueue.offer(2,1L,TimeUnit.SECONDS);
            blockingQueue.offer(3,1L,TimeUnit.SECONDS);
            blockingQueue.offer(4,1L,TimeUnit.SECONDS);
            // 使用限时poll删除元素,如果队列是空会等待1s后退出
            System.out.println(blockingQueue.poll(1L,TimeUnit.SECONDS));
            System.out.println(blockingQueue.poll(1L,TimeUnit.SECONDS));
            System.out.println(blockingQueue.poll(1L,TimeUnit.SECONDS));
            System.out.println(blockingQueue.poll(1L,TimeUnit.SECONDS));
        }
     

    SynchronousQueue

    不存储元素的阻塞队列,只有一个元素

    代码示例:

        public static void main(String[] args) throws InterruptedException {
            // 定义阻塞队列的长度为3
            BlockingQueue blockingQueue = new SynchronousQueue();
    
            new Thread(()->{
                try {
                    System.out.println(Thread.currentThread().getName()+"\t 写个 1");
                    blockingQueue.put("1");
                    System.out.println(Thread.currentThread().getName()+"\t 写个 2");
                    blockingQueue.put("2");
                    System.out.println(Thread.currentThread().getName()+"\t 写个 3");
                    blockingQueue.put("3");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
    
            new Thread(()->{
                try {
                    Thread.sleep(1000);
                    System.out.println(blockingQueue.take());
                    Thread.sleep(1000);
                    System.out.println(blockingQueue.take());
                    Thread.sleep(1000);
                    System.out.println(blockingQueue.take());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    展开全文
  • java常用阻塞队列

    2019-03-07 15:09:00
    BlockingQueue 获取元素的时候等待队列里有元素,否则阻塞 保存元素的时候等待队列里有空间,否则阻塞...在生产者消费者例子中,如果生产者生产实体放入队列超过了队列的长度,则在offer(或者put,add)的时候会被阻塞...
  • 7.8java集合之队列

    2020-07-07 10:55:06
    int size():获取队列长度; boolean add(E)/boolean offer(E):添加元素到队尾; E remove()/E poll():获取队首元素并从队列中删除; E element()/E peek():获取队首元素但并不从队列中删除。
  • java-阻塞队列BlockingQueue

    万次阅读 2019-04-18 14:11:30
    包含固定长度队列和不固定长度队列 什么是可阻塞队列队列满了添加线程会阻塞等待,队列空了获取线程也会阻塞等待。非阻塞队列则会直接报错。 BlockingQueue支持两个附加操作Queue:1)当Queue为空时,获取元素...
  • 队列的原理见博客:队列(queue)原理 使用数组来实现队列时,如果用一般的... 获取队列长度 辅助操作: 判断队列是否为空; 判断队列是否满; 清空队列。 下面是数组循环队列的实现代码(ArrayQueue) /** ...
  • Java数组实现队列

    2013-12-26 15:52:31
    用数组实现。队首出队,队尾进队。...获取队列的长度getSize(), 元素出队,在队首出队 元素入队,在对尾入队 public class Queue { private int front;//队首 private int back;//队尾 private in
  • Java中,作为所有数据结构中存储和获取速度最快的一种,数组凭借其这种简单易用的优势在各个方面都能大显神威。但是数组也有自身的局限性。数组的长度必须是固定的一旦定义之后就无法动态的更改,这就会造成这样的...
  • Java 线程池等待队列问题

    千次阅读 2019-09-20 15:38:48
    该线程池等待队列最大长度默认为int最大值,随口默写出来就是2147483647(2^31 -1,高中物理老师说过一句话,记住一些固定数字可以预判一些问题)。线程池在提交任务时,如果线程池未达到最大线程数,则起线程...
  • 队列遵循先进先出的原则。 1.实现队列的接口类 ... //获取队列长度 int getSize(); //判断队列是否为空 boolean isEmpty(); //向队列中添加元素 void enqueue(E e); //从队列中取出元素 E dequeue(); ...
  • 单向链表队列是属于非循环队列,同时队列的长度是不受限制的,也就是说添加数据的速度比拉取数据的速度快时,队列的长度是无限增长的。单链队列其本质就是一个链表,只不过是在获取或添加数据的时候跟普通的链表有所...
  • 该线程池等待队列最大长度默认为int最大值,随口默写出来就是2147483647(2^31 -1,高中物理老师说过一句话,记住一些固定数字可以预判一些问题)。线程池在提交任务时,如果线程池未达到最大线程数,则起线程...
  • //获取队列长度 int getSize(); //判断队列是否为空 boolean isEmpty(); //向队列中添加元素 void enqueue(E e); //从队列中取出元素 E dequeue(); //取出队列中首个元素...
  • 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里,一旦一个队列满了,我们就不能插入下一个元素,即使在队列前面仍有空间。但是使用循环队列,我们能使用这些空间去存储新的值。 你的...
  • java数组在声明的的时候都会要求输入数组...下面我将要说自定义队列,跟javaArrayList实现差不多,它能够优化数组定义时固定长度的不足。 自定义队列将要实现基本功能: 1.添加对象 2.获取指定位置...
  • 前言很久之前写过一篇有关HashMap文章:啃碎JDK源码(四):HashMap,反响不错。本来手后面是想写篇文章...与Java数组相比,它容量能动态增长。它继承于AbstractList,实现了List, RandomAccess, Cloneable, ...
  • 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里,一旦一个队列满了,我们就不能插入下一个元素,即使在队列前面仍有空间。但是使用循环队列,我们能使用这些空间去存储新的值。 你的...
  • ArrayBlockingQueue是阻塞队列的一种,基于数组实现,长度固定,队尾添加,队首获取, 构造函数: ArrayBlockingQueue(int capacity) ArrayBlockingQueue(int capacity, boolean fair) ...
  • MyCircularQueue(k): 构造器,设置队列长度为 k 。 Front: 从队首获取元素。如果队列为空,返回 -1 。 Rear: 获取队尾元素。如果队列为空,返回 -1 。 enQueue(value): 向循环队列插入一个元素。如果成功插入则返回...
  • java数据结构 1、数组 public class MyArray { private int[] Arr; //数组复制 ... //获取数组长度 public int size() { return Arr.length; } //往数组末尾加一个元素 public void...
  • 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里,一旦一个队列满了,我们就不能插入下一个元素,即使在队列前面仍有空间。但是使用循环队列,我们能使用这些空间去存储新的值。 你的...
  • 双向链表实现数据结构中的队列/** * 文章标题:双向链表实现数据结构中的队列 * 摘要: * (一)实现的是数据结构中的队列 ... * 3、获取队列的长度 * 4、判断队列是否为空 * 5、建一个队列 * (四
  • java

    2018-11-22 17:10:12
    单向链表队列是属于非循环队列,同时队列的长度是不受限制的,也就是说添加数据的速度比拉取数据的速度快时,队列的长度是无限增长的。单链队列其本质就是一个链表,只不过是在获取或添加数据的时候跟普通的链表有所...
  • int size():获取队列长度; boolean add(E)/boolean offer(E):添加元素到队尾; E remove()/E poll():获取队首元素并从队列中删除; E element()/E peek():获取队首元素但并不从队列中删除。 注意到添加、删除...
  • 队列小结

    2013-07-31 13:54:25
    队列总结 1.为什么要使用队列? 由于数组的长度是固定的,因此对于要再添加数据的情况下,数组就不能使用了,因此要用 ... //获取队列长度 public int size(); //向队列尾部添加元素 public ...
  • 文章目录ArrayList简介导入初始化增获取元素删查获取长度遍历排序随机获取元素截取部分元素 ArrayList 简介 ArrayList 是一个动态数组,继承了 AbstractList ,并实现了 List 接口 ArrayList 是一个数组队列,提供...

空空如也

空空如也

1 2 3 4 5 6
收藏数 105
精华内容 42
关键字:

java获取队列的长度

java 订阅