「java队列」java队列的入队和出队

admin 2023-03-21 23:55:09 884

本篇文章给大家谈谈java队列，以及java队列的入队和出队对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、java中queue的使用方法?
2、java多线程共同操作同一个队列,怎么实现?
3、java中的队列都有哪些
4、JAVA中队列和栈的区别
5、java调优设置阻塞队列大小
6、java 用什么实现 FIFO队列？

java中queue的使用方法?

java中的queue类是队列数据结构管理类。在它里边的元素可以按照添加它们的相同顺序被移除。

队列通常（但并非一定）以 FIFO（先进先出）的方式排序各个元素。不过优先级队列和 LIFO 队列（或堆栈）例外，前者根据提供的比较器或元素的自然顺序对元素进行排序，后者按 LIFO（后进先出）的方式对元素进行排序。无论使用哪种排序方式，队列的头都是调用remove()或poll()所移除的元素。在 FIFO 队列中，所有的新元素都插入队列的末尾。其他种类的队列可能使用不同的元素放置规则。每个Queue实现必须指定其顺序属性。

offer 添加一个元素并返回true 如果队列已满，则返回false

poll 移除并返问队列头部的元素如果队列为空，则返回null

peek 返回队列头部的元素如果队列为空，则返回null

put 添加一个元素如果队列满，则阻塞

take 移除并返回队列头部的元素如果队列为空，则阻塞

element 返回队列头部的元素如果队列为空，则抛出一个NoSuchElementException异常

add 增加一个元索如果队列已满，则抛出一个IIIegaISlabEepeplian异常

remove 移除并返回队列头部的元素如果队列为空，则抛出一个

NoSuchElementException异常

注意：poll和peek方法出错进返回null。因此，向队列中插入null值是不合法的。

还有带超时的offer和poll方法重载，例如，下面的调用：

boolean success = q.offer(x,100,TimeUnit.MILLISECONDS);

尝试在100毫秒内向队列尾部插入一个元素。如果成功，立即返回true；否则，当到达超时进，返回false。同样地，调用：

Object head = q.poll(100, TimeUnit.MILLISECONDS);

如果在100毫秒内成功地移除了队列头元素，则立即返回头元素；否则在到达超时时，返回null。

阻塞操作有put和take。put方法在队列满时阻塞，take方法在队列空时阻塞。

Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。

java多线程共同操作同一个队列,怎么实现?

具体代码如下：

以下是两个线程：

import java.util.*;

public class Thread_List_Operation {

//假设有这么一个队列

static List list = new LinkedList();

public static void main(String[] args) {

Thread t;

t = new Thread(new T1());

t.start();

t = new Thread(new T2());

t.start();

}

//线程T1,用来给list添加新元素

class T1 implements Runnable{

void getElemt(Object o){

Thread_List_Operation.list.add(o);

System.out.println(Thread.currentThread().getName() + "为队列添加了一个元素");

}

@Override

public void run() {

for (int i = 0; i 10; i++) {

getElemt(new Integer(1));

}

//线程T2,用来给list添加新元素

class T2 implements Runnable{

void getElemt(Object o){

Thread_List_Operation.list.add(o);

System.out.println(Thread.currentThread().getName() + "为队列添加了一个元素");

}

@Override

public void run() {

for (int i = 0; i 10; i++) {

getElemt(new Integer(1));

}

//结果（乱序）

Thread-0为队列添加了一个元素

Thread-1为队列添加了一个元素

Thread-0为队列添加了一个元素

Thread-1为队列添加了一个元素

Thread-0为队列添加了一个元素

java中的队列都有哪些

常见的有：

有界队列：

ArrayBlockingQueue

LinkedBlockingQuene

priorityBlockingQuene（具有优先级的队列）

无界队列：

SynchronousQuene

JAVA中队列和栈的区别

队列(Queue)：是限定只能在表的一端进行插入和在另一端进行删除操作的线性表;

栈(Stack)：是限定只能在表的一端进行插入和删除操作的线性表。

区别如下：

一、规则不同

1. 队列：先进先出(First In First Out)FIFO

2. 栈：先进后出(First In Last Out )FILO

二、对插入和删除操作的限定不同

1. 队列：只能在表的一端进行插入，并在表的另一端进行删除;

2. 栈：只能在表的一端插入和删除。

三、遍历数据速度不同

队列：基于地址指针进行遍历，而且可以从头部或者尾部进行遍历，但不能同时遍历，无需开辟空间，因为在遍历的过程中不影响数据结构，所以遍历速度要快;

栈：只能从顶部取数据，也就是说最先进入栈底的，需要遍历整个栈才能取出来，而且在遍历数据的同时需要为数据开辟临时空间，保持数据在遍历前的一致性。

java调优设置阻塞队列大小

阻塞队列大小的调整是Java调优的一个重要环节，它可以帮助减少内存的使用，提升程序的运行效率。Java调优时，首先要考虑的是阻塞队列大小的设置。根据不同的应用场景，可以选择不同大小的队列，有效地调整系统性能。例如，如果应用程序的任务量较大，就要选择增大阻塞队列的大小，以减少任务的等待和拥塞情况；如果应用程序的任务量少，则可以选择减小队列的大小，以节省内存的使用。

java 用什么实现 FIFO队列？

java使用数据结构来实现FIFO先进先出的队列，实例如下：

* To change this template, choose Tools | Templates

* and open the template in the editor.

package linkedlisttest;

import java.util.ArrayList;

import java.util.Deque;

import java.util.LinkedList;

import java.util.List;

/**

* @author Vicky.H

* @email eclipser@163.com

public class FIFOTest {

/**

* @param args the command line arguments

public static void main(String[] args) {

FIFOA fifo = new FIFOImplA(5);

for (int i = 0; i 20; i++) {

A a = new A("A:" + i);

A head = fifo.addLastSafe(a);

System.out.println(i + "\thead:" + head + "\tsize:" + fifo.size());

}

System.out.println("---------------");

System.out.println("弹出数据");

ListA polls = fifo.setMaxSize(3);

for (A a : polls) {

System.out.println("\thead:" + a);

}

System.out.println("剩余数据");

for (A a : fifo) {

System.out.println("\thead:" + a);

}

System.out.println(fifo.size());

}

interface FIFOT extends ListT, DequeT, Cloneable, java.io.Serializable {

/**

* 向最后添加一个新的，如果长度超过允许的最大值，则弹出一个 *

T addLastSafe(T addLast);

/**

* 弹出head，如果Size = 0返回null。而不同于pop抛出异常

* @return

T pollSafe();

/**

* 获得最大保存

* @return

int getMaxSize();

/**

* 设置最大存储范围

* @return 返回的是，因为改变了队列大小，导致弹出的head

ListT setMaxSize(int maxSize);

}

class FIFOImplT extends LinkedListT implements FIFOT {

private int maxSize = Integer.MAX_VALUE;

private final Object synObj = new Object();

public FIFOImpl() {

super();

}

public FIFOImpl(int maxSize) {

super();

this.maxSize = maxSize;

}

@Override

public T addLastSafe(T addLast) {

synchronized (synObj) {

T head = null;

while (size() = maxSize) {

head = poll();

}

addLast(addLast);

return head;

}

@Override

public T pollSafe() {

synchronized (synObj) {

return poll();

}

@Override

public ListT setMaxSize(int maxSize) {

ListT list = null;

if (maxSize this.maxSize) {

list = new ArrayListT();

synchronized (synObj) {

while (size() maxSize) {

list.add(poll());

}

this.maxSize = maxSize;

return list;

}

@Override

public int getMaxSize() {

return this.maxSize;

}

class A {

private String name;

public A() {

}

public A(String name) {

this.name = name;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public String toString() {

return "A{" + "name=" + name + '}';

}

关于java队列和java队列的入队和出队的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

标签：java队列