精华内容
下载资源
问答
  • 数组模拟队列java实现

    2020-03-30 16:57:14
    java数组模拟队列一、基本介绍二、数组模拟队列1、基本介绍2、代码实现3、存在的问题三、数组模拟环形队列1、优化思路分析2、代码实现 一、基本介绍 队列是一个有序列表,可以用数组或者链表实现。 遵循先入先出的...

    一、基本介绍

    • 队列是一个有序列表,可以用数组或者链表实现。
    • 遵循先入先出的原则。即:先存入队列的数据,要先取出,后存入的要后取出。
      数组模拟队列示意图

    二、数组模拟队列

    1、基本介绍

      队列本身是有序列表,若使用数组的形式来存储队列的数据,则队列数组需要声明如下几个变量:

    • int maxSize:数组最大容量
    • int front:队列头元素的上一个位置,初始值为-1
    • int rear:队列尾元素,初始值为-1
    • int[] arr:存放数据,模拟队列
      (此时的队满条件为rear = maxSize-1;此时的队空条件为rear = front)

    2、代码实现

    首先创建队列,声明数组模拟队列所需要的变量以及基本的队空队满判断、入队、出队、显示队头、显示队列方法

    //使用数组模拟队列
    class ArrayQueue {
        private int maxSize;//数组最大容量
        private int front;//队列头上一个位置
        private int rear;//队列尾
        private int[] arr;//存放数据,模拟队列
    
        //创建队列的构造器
        public ArrayQueue(int arrMaxSize) {
            maxSize = arrMaxSize;
            arr = new int[maxSize];
            front = -1;//指向队列的头的前一个位置
            rear = -1;//指向队列尾
        }
    
        //判断队列是否满
        public boolean isFull() {
            return rear == maxSize - 1;
        }
    
        //判断队列是否为控
        public boolean isEmpty() {
            return rear == front;
        }
    
        //添加数据到队列
        public void addQueue(int n) {
            //判断是否满
            if (isFull()) {
                System.out.println("队列满,不能加入数据");
                return;
            }
            rear++;
            arr[rear] = n;
        }
    
        //取出数据
        public int getQueue() {
            //判断是否空
            if (isEmpty()) {
                throw new RuntimeException("队列为空,不能取数据");
            }
            front++;
            return arr[front];
        }
    
        //显示队列的所有数据
        public void showQueue() {
            //遍历
            if (isEmpty()) {
                System.out.println("队列为空,没有数据");
                return;
            }
            for (int i = front+1; i <= rear; i++) {
                System.out.printf("arr[%d]=%d\n", i, arr[i]);
            }
        }
    
        //显示队列的头数据
        public int headQueue() {
            if (isEmpty()) {
                throw new RuntimeException("队列为空,没有数据");
            }
            return arr[front + 1];
        }
    }
    

    然后就可以使用队列进行一些基本操作了,这里用一个简单的Demo来进行测试

    import java.util.Scanner;
    
    /**
     * @author dankejun
     * @create 2020-03-20 16:31
     */
    public class ArrayQueueDemo {
    
        public static void main(String[] args) {
            ArrayQueue arrayQueue = new ArrayQueue(3);
            char key = ' ';
            Scanner s = new Scanner(System.in);
            boolean loop = true;
            while (loop) {
                System.out.println("s(show):显示队列");
                System.out.println("e(exit):退出程序");
                System.out.println("a(add):添加数据到队列");
                System.out.println("g(get):从对立获取数据");
                System.out.println("h(head):查看队列头数据");
                key = s.next().charAt(0);
                switch (key) {
                    case 's':
                        arrayQueue.showQueue();
                        break;
                    case 'a':
                        System.out.println("输入要添加的数:");
                        int i = s.nextInt();
                        arrayQueue.addQueue(i);
                        break;
                    case 'g':
                        try {
                            int res = arrayQueue.getQueue();
                            System.out.println("取出的数据是" + res + "\t");
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'h':
                        try {
                            int res = arrayQueue.headQueue();
                            System.out.println("队列头的数据是:" + res);
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'e':
                        s.close();
                        loop = false;
                    default:
                        break;
                }
            }
            System.out.println("程序退出");
        }
    }
    

    3、存在的问题

      由以上队列的操作发现,虽然将数据出队后,只要队列不满,还可以继续进行添加,但实际上发现这样用数组模拟队列只能使用一次,不可复用。也就是说,当尾指针rear到达数组的最后一个索引位置时,再将某数据出队,这样一来队头指针front前面虽然存在无用的位置,但由于尾指针无法到达,就导致其无法被利用,固当队尾指针rear到达数组最后一个单元时,即使将某些数据出队,也无法再添加新数据到队列,如下图。

    数组模拟队列
    要解决以上问题,就需要将此队列模拟为环形队列,即尾指针可重新回到数组的首个单元,实现队列的复用

    三、数组模拟环形队列

      环形队列时对前面数组模拟队列的一个优化,通过取模的方式,可以达到充分利用数组,实现队列复用的目的。

    1、优化思路分析

    1. 此时我们将头指针front和尾指针rear的指向做一个调整:
       - int front:队列的头元素,初始值为0
        - int rear:队列尾元素的后一个元素,初始值为0(此时数组需要空出来一个元素作为约定,所以maxSize的值比实际容量小1)
    2. 此时队空条件为:rear = front(保持不变)
    3. 此时队满条件为:(rear+1)%maxSize =front(利用取模,让尾指针重新回到数组头元素)
    4. 队列中有效数据的个数:(rear+maxSize-front)%maxSize
    5. 每入队一个元素,先将arr[rear]赋值,再执行rear = (rear + 1) % maxSize(利用取模,让尾指针重新回到数组头元素)
    6. 每出队一个元素,先取出arr[front]的值,再执行front = (front + 1) % maxSize;(利用取模,让头指针重新回到数组头元素)

    2、代码实现

    同样的,首先创建队列,声明数组模拟队列所需要的变量以及基本的队空队满判断、入队、出队、显示队头、显示队列方法

    class CircleArray {
        private int maxSize;//数组最大容量
        private int front;//队列头
        private int rear;//队列尾
        private int[] arr;//存放数据,模拟队列
    
        public CircleArray(int maxSize) {
            this.maxSize = maxSize;
            arr = new int[this.maxSize];
            front = 0;//指向队列的头的前一个位置
            rear = 0;//指向队列尾
        }
    
        //判断队列是否满
        public boolean isFull() {
            return (rear + 1) % maxSize == front;
        }
    
        //判断队列是否为控
        public boolean isEmpty() {
            return rear == front;
        }
    
        //添加数据到队列
        public void addQueue(int n) {
            //判断是否满
            if (isFull()) {
                System.out.println("队列满,不能加入数据");
                return;
            }
            arr[rear] = n;
            rear = (rear + 1) % maxSize;
        }
    
        //取出数据
        public int getQueue() {
            //判断是否空
            if (isEmpty()) {
                throw new RuntimeException("队列为空,不能取数据");
            }
            int temp = arr[front];
            front = (front + 1) % maxSize;
            return temp;
        }
    
        //显示队列的所有数据
        public void showQueue() {
            //遍历
            if (isEmpty()) {
                System.out.println("队列为空,没有数据");
                return;
            }
            for (int i = front; i < front + size(); i++) {
                System.out.printf("arr[%d]=%d\n", i % maxSize, arr[ i % maxSize]);
            }
        }
    
        //求出当前队列有效数据的个数
        public int size() {
            return (rear + maxSize - front) % maxSize;
        }
    
        //显示队列的头数据
        public int headQueue() {
            if (isEmpty()) {
                throw new RuntimeException("队列为空,没有数据");
            }
            return arr[front];
        }
    }
    

    然后就可以使用队列进行一些基本操作了,这里用一个简单的Demo来进行测试

    
    import java.util.Scanner;
    
    /**
     * @author dankejun
     * @create 2020-03-20 17:14
     */
    public class CircleArrayQueue {
    
        public static void main(String[] args) {
            CircleArray arrayQueue = new CircleArray(4);
            char key = ' ';
            Scanner s = new Scanner(System.in);
            boolean loop = true;
            while (loop) {
                System.out.println("s(show):显示队列");
                System.out.println("e(exit):退出程序");
                System.out.println("a(add):添加数据到队列");
                System.out.println("g(get):从对立获取数据");
                System.out.println("h(head):查看队列头数据");
                key = s.next().charAt(0);
                switch (key) {
                    case 's':
                        arrayQueue.showQueue();
                        break;
                    case 'a':
                        System.out.println("输入要添加的数:");
                        int i = s.nextInt();
                        arrayQueue.addQueue(i);
                        break;
                    case 'g':
                        try {
                            int res = arrayQueue.getQueue();
                            System.out.println("取出的数据是" + res + "\t");
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'h':
                        try {
                            int res = arrayQueue.headQueue();
                            System.out.println("队列头的数据是:" + res);
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'e':
                        s.close();
                        loop = false;
                    default:
                        break;
                }
            }
            System.out.println("程序退出");
        }
    
    }
    

    此时用数组模拟的队列就可以复用了
    数组模拟环形队列

    展开全文
  • 简单循环数组实现队列的局限性 用于实现队列的数组的最大空间必须预先声明并且不可改变,试图对于一个满队列执行入队操作和队一个空队列做出队列操作都会队列的相关异常 基于动态数组实现队列 /** * 基于动态数组...

    简单循环数组实现队列的局限性

    用于实现队列的数组的最大空间必须预先声明并且不可改变,试图对于一个满队列执行入队操作和队一个空队列做出队列操作都会队列的相关异常

    基于动态数组实现队列

    /**
     * 基于动态数组实现队列
     */
    public class DynArrayQueue {
        /**
         * 队列头指针
         */
        private int front;
        /**
         * 队列尾指针
         */
        private int rear;
        /**
         * 队列容量
         */
        private int capacity;
        /**
         * 容器
         */
        private int[] array;
    
        /**
         * 私有化构造器,初始容量为1
         */
        private DynArrayQueue() {
            capacity = 1;
            front = -1;
            rear = -1;
            array = new int[1];
        }
    
        public static DynArrayQueue createDynArrayQueue() {
            return new DynArrayQueue();
        }
    
        /**
         * 判空操作
         *
         * @return
         */
        public boolean isEmpty() {
            return front == -1;
        }
    
        /**
         * 满队列操作
         *
         * @return
         */
        public boolean isFull() {
            return (rear + 1) % capacity == front;
        }
    
        /**
         * 获取队列容量
         *
         * @return
         */
        public int getQueueSize() {
            if (front == -1) {
                return 0;
            }
            int size = (capacity - front + rear + 1) % capacity;
            if (size == 0) {
                return capacity;
            } else {
                return size;
            }
        }
    
        /**
         * 容器数组扩容
         */
        private void resizeQueue() {
            int initCapacity = this.capacity;
            capacity *= 2;
            int[] oldArray = this.array;
            array = new int[capacity];
            System.arraycopy(oldArray, 0, array, 0, oldArray.length);
            if (rear < front) {
                if (front >= 0) System.arraycopy(this.array, 0, array, 0 + initCapacity, front);
                rear = rear + initCapacity;
            }
        }
    
        /**
         * 入队操作
         *
         * @param data
         */
        public void enQueue(int data) {
            if (isFull()) {
                resizeQueue();
            }
            rear = (rear + 1) % capacity;
            array[rear] = data;
            if (front == -1) {
                front = rear;
            }
        }
    
        /**
         * 出栈操作
         *
         * @return
         */
        public int deQueue() {
            Integer data = null;
            if (isEmpty()) {
                throw new RuntimeException("Queue is Empty!");
            } else {
                data = array[front];
                if (front == rear) {
                    front = rear = -1;
                }
            }
            return data;
        }
    }
    
    展开全文
  • java数组实现队列 什么是队列? (What is a Queue?) Queue is a special type of data structure, which is designed to hold elements before processing and process elements in a FIFO (first-in-first-out) ...

    java数组实现队列

    什么是队列? (What is a Queue?)

    Queue is a special type of data structure, which is designed to hold elements before processing and process elements in a FIFO (first-in-first-out) manner. It’s part of java collections framework. In this tutorial, we will learn Queue implementation in Java using an array.

    队列是一种特殊类型的数据结构,旨在在处理和处理元素之前以FIFO(先进先出)的方式保存元素。 它是java collections框架的一部分。 在本教程中,我们将学习如何使用数组在Java中实现Queue。

    基本队列功能 (Basic Queue Functions)

    A Queue must have the following functions:

    队列必须具有以下功能:

    • enqueue(obj) – insert element to the queue.

      enqueue(obj) –将元素插入队列。
    • dequeue() – remove and return the least recent item from the queue.

      dequeue() –从队列中删除并返回最近的项目。
    • isEmpty() – returns true if the queue is empty, else false.

      isEmpty() –如果队列为空,则返回true,否则返回false。

    Java中的队列实现 (Queue Implementation in Java)

    We can implement basic Queue functions using an array.

    我们可以使用数组实现基本的Queue函数。

    Here is the complete code to implement a Queue in Java.

    这是在Java中实现队列的完整代码。

    package com.journaldev.java;
    
    public class MyQueue {
    
    	public static final int DEFAULT_SIZE = 5;
    
    	private Object data[];
    
    	private int index;
    
    	public MyQueue() {
    		data = new Object[DEFAULT_SIZE];
    	}
    
    	public MyQueue(int size) {
    		data = new Object[size];
    	}
    
    	public boolean isEmpty() {
    		return index == 0;
    	}
    
    	public void enqueue(Object obj) throws Exception {
    		if (index == data.length - 1) {
    			throw new Exception("Queue is full. Dequeue some objects");
    		}
    		this.data[index] = obj;
    		this.index++;
    	}
    
    	public Object dequeue() throws Exception {
    		if (isEmpty())
    			throw new Exception("Queue is empty");
    		Object obj = this.data[0];
    		for (int i = 0; i < this.index - 1; i++) {
    			data[i] = data[i + 1];
    		}
    		this.index--;
    		return obj;
    
    	}
    }

    Important Points

    重要事项

    • There are two constructors – one to create a Queue with default size, the other one is used to specify the queue size.

      有两个构造函数–一个用于创建默认大小的Queue,另一个用于指定队列的大小。
    • We are using a private integer variable “index” to manage the queue elements.

      我们正在使用私有整数变量“ index”来管理队列元素。
    • We are using an Object array so that we can hold any type of object in the Queue. We can use generics here too but I am avoiding that to keep the program simple.

      我们正在使用对象数组,以便可以在队列中保存任何类型的对象。 我们也可以在此处使用泛型,但为了避免使程序保持简单,我避免这样做。
    • If the queue is full, the enqueue() will throw an exception with proper message.

      如果队列已满,则enqueue()会引发带有适当消息的异常。
    • If the queue is empty and we call the dequeue() function, an exception is raised.

      如果队列为空,并且我们调用dequeue()函数,则会引发异常。

    Implementation Limitations
    The Queue methods are not synchronized and it’s not thread-safe. There is a chance of data inconsistency if you use this implementation in a multi-threaded environment.

    实施局限性
    Queue方法未同步,并且不是线程安全的。 如果在多线程环境中使用此实现,则可能会导致数据不一致。

    测试程序以检查队列实施 (Test Program to Check Queue Implementation)

    Let’s test our queue implementation with some calls to enqueue() and dequeue() functions.

    让我们通过对enqueue()和dequeue()函数的一些调用来测试我们的队列实现。

    MyQueue queue = new MyQueue();
    queue.enqueue("1");
    System.out.println(queue.dequeue());
    
    queue.enqueue("2");
    queue.enqueue("3");
    queue.enqueue("4");
    System.out.println(queue.dequeue());
    
    queue.enqueue("5");
    queue.enqueue("6");
    // queue.enqueue("7");
    // queue.enqueue("8");

    Output:

    输出:

    1
    2

    If you uncomment the last two lines, the queue will get full and an exception will be raised.

    如果取消注释最后两行,则队列将已满,并且将引发异常。

    Exception in thread "main" java.lang.Exception: Queue is full. Dequeue some objects
    	at com.journaldev.java.MyQueue.enqueue(MyQueue.java:25)
    	at com.journaldev.java.MyQueue.main(MyQueue.java:56)

    结论 (Conclusion)

    A Queue is one of the simplest data structures. We can implement it using an array or a list.

    队列是最简单的数据结构之一。 我们可以使用数组或列表来实现它。

    翻译自: https://www.journaldev.com/104/queue-implementation-java-array

    java数组实现队列

    展开全文
  • 数组实现队列(java)

    2019-10-13 20:00:33
    一维数组实现队列的基本操作 在之前更新==稀疏数组,单双链表,循环链表(约瑟夫环)==后,这次代码实现用简单的一维数组完成队列的基本操作,希望对大家有所帮助。在之后持续更新java数据结构,喜欢博主留个关注吧...

    一维数组实现队列的基本操作

    在之前更新==稀疏数组,单双链表,循环链表(约瑟夫环)==后,这次代码实现用简单的一维数组完成队列的基本操作,希望对大家有所帮助。在之后持续更新java数据结构,喜欢博主留个关注吧,记得双鸡么么哒!!!

    队列

    先进先出

    代码功能

    1.增加数据
    2.取出数据
    3.取出头数据
    4.展示列表

    注意

    此时单链表实现此功能,在添加数据到数组最大程度后,即使取出,再次添加也会提示队列满,所以我们更加倾向利用循环队列,循环队列下次更新!!!!

    代码

    手敲全注释代码来啦!!!感兴趣可以看一下我之前的文章关于链表,稀疏数组

    package queue;
    
    import java.util.Scanner;
    
    public class ArrayQueueDemo {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		ArrayQueue queue = new ArrayQueue(3);
    		char key = ' ';//接受用户输入
    		Scanner scanner = new Scanner (System.in);
    		boolean loop = true;
    		while(loop) {
    			System.out.println("s(show):显示队列");
    			System.out.println("e(exit):退出程序");
    			System.out.println("a(add):增加数据到队列");
    			System.out.println("g(get):取队列数据");
    			System.out.println("h(head):取队列首数据");
    			key = scanner.next().charAt(0);
    			switch(key) {
    			case 's':
    				queue.showQueue();
    				break;
    			case 'a':
    				System.out.println("亲输入添加的数:");
    				int value = scanner.nextInt();
    				queue.addQueue(value);
    				break;
    			case 'g':
    				try {
    					int res= queue.getQueue();
    					System.out.println("取出的数据是:"+res);
    					}catch(Exception e){
    						System.out.println(e.getMessage());
    					}
    				break;
    			case 'h':
    				try {
    					int res= queue.getQueue();
    					System.out.println("取出的头数据是:"+res);
    					}catch(Exception e){
    						System.out.println(e.getMessage());
    					}
    				break;
    			case 'e':
    				scanner.close();
    				loop = false;
    				break;
    			default:
    				break;
    			}
    		}
    		System.out.println("程序退出");
    	}
    
    }
    //使用数组模拟队列 
    class ArrayQueue{
    	private int maxSize;//表示数组最大容量
    	private int front;//队列头
    	private int rear;//队尾
    	private int[] arr;//数组模拟队列
    	
    	//创建队列的构造器
    	public ArrayQueue(int arrMaxSize) {
    		maxSize = arrMaxSize;
    		arr = new int[maxSize];
    		front = -1;
    		rear = -1;
    	}
    	//判断队列是否满
    	public boolean isFull(){
    		return rear ==maxSize - 1;
    	}
    	//判断队列空
    	public boolean isEmpty() {
    		return rear == front;
    	}
    	
    	//添加元素
    	public void addQueue(int n ) {
    		if(isFull()){
    			System.out.println("队满,不能添加元素。");
    			return;
    		}
    		rear++;
    		arr[rear] = n;
    	}
    	
    	//出队
    	public int getQueue() {
    		if(isEmpty()) {
    			//System.out.println("队空,不能取出元素。");
    			throw new RuntimeException("队空,不能取出元素。");
    		}
    		front++;
    		return arr[front];
    	}
    	
    	//显示队列的说有数据
    	public void showQueue() {
    		if(isEmpty()) {
    			System.out.println("队空,没有元素。");
    			return;
    		}
    		for(int i = 0;i<arr.length;i++) {
    			System.out.printf("arr[%d]= %d\n",i,arr[i]);
    		}
    	}
    	//显示队列的头数剧
    	public int headQueue() {
    		if(isEmpty()) {
    			throw new RuntimeException("队空,没有元素。");
    		}
    		return arr[front+1];
    	}
    	
    }
    
    展开全文
  • 主要介绍了java数组实现队列及环形队列实现过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 使用数组实现队列,未实现环形队列使得数组可以重复利用!环形队列实现见另一个博客。 package com.algorithm.queue; public class QueueDemo01 { public static void main(String[] args) { // rear == maxSize...
  • 【编程题】用数组实现队列Java实现) 题目要求 通过一个数组实现队列的功能,具有出队列、压队列、以及当前队列顶的元素等方法。 思路 在数组中用一个start指向当前队列头的位置,出队列就往上添加;用一个...
  • Java数组实现队列

    2018-03-02 11:55:25
    队列实现方式一:Java数组实现队列package queue; /** * * &lt;p&gt; * 功能描述:使用数组实现队列 * &lt;/p&gt; * @author 钟良健 * @company * @version V1.0 */ public class ...
  • 数组实现队列——java

    2020-03-12 23:08:26
    采用静态数组的方式实现队列,并且测试使用,所以只支持int类型,感兴趣的朋友可以自己制作泛型队列。其中设计指向头的元素:front,指向最后一个元素的下一个:rear,队列的空间:maxSize,队列的数据:data[]。 ...
  • 基于简单循环数组实现队列 队列抽象数据类型的这种简单实现使用数组,在数组中,采用循环的方式则增加元素,并使用两个变量分别记录队首和队尾元素。通常,使用front变量和rear变量分别表示队列中的队首元素和队尾...
  • title: 基于数组实现队列(基于Java) tags: 数组 队列 基于数组实现队列的原理: 基于数组实现的队列,使用两个指针,一个是head指针 ,指向的是队头;一个是tail指针,指向队尾。可以通过下面这张图片来进行理解...
  • java数组实现队列java数组实现队列,基本的操作有入队(add),出队(poll)和判断队列是否为空(isEmpty)。 入队时在数组的末尾增加元素,出队时将数组的头部元素取出来,判断队列是否为空就判断队列长度是否为...
  • 队列的循环数组实现java)。
  • // 使用数组模拟队列,编写circleQueue类 class circleQueue{ private int maxSize; //数组最大容量 private int front; //队列头,对应队列开头位置,初始值为0 private int rear; //队列尾,对应...
  • 不想讲解,直接上代码.需要学习的直接看注释. ... * @desc 动态循环数组实现队列 * @date 2019-12-10 16:53 */ public class DynamicArrayQueue<E> { private static final int DEFAULT_SIZE = 16; /** ...
  • 简单数组实现容量固定的栈 队列类代码实现 仅enQueue方法与数组是否倍增有关,其他方法都与简单数组中的队列实现相同。 本人对数组倍增用的不是很熟,所以犯了一些容易犯的错误,解析见注释。 this.show()用于调试...
  • 数组实现队列有两个缺点 1、会出现”假溢出” 2、低位空间无法重复利用(出队之后的空间) 队列队尾进 队首出 FIFO(First In First Out)数组队列类:public class QueueArrays { /** * 队尾插入 * 队首...
  • public class ArrayQueue{ //队列,由队尾插入元素,由队首删除元素 private int[] A; //内置数组 private int front; //头指针 private int rear; //尾指针 public ArrayQueue(int size) { this.A=new int...
  • java数组实现队列

    2019-01-23 10:46:00
    数组实现队列,也叫循环队列。就是定义一个数组,用两个下标head,tail表示队头和队尾。当队头和队尾相等时,队列为空。当队尾+1等于队头时,队列为满。 注意tail的值,当插入一个元素时tail=1 szie=1,两个时...
  • Java数组实现队列

    2020-08-11 12:05:12
    使用数组实现顺序队列、环形队列,包括队列的介绍、思路分析、示意图和代码实现。
  • Java数组实现队列

    2019-03-12 15:15:55
    数组实现队列,实际是通过维护队首和队尾变量来实现一个循环数组,从而实现复杂度为1的FIFO队列。 interface Queue&lt;T&gt; { boolean add(T t) throws Exception; T take(); } public class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,006
精华内容 1,602
关键字:

数组实现队列java

java 订阅