「java先进先出」java 先进后出
本篇文章给大家谈谈java先进先出，以及java 先进后出对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、Java使用LinkedList来模拟一个队列(先进先出的特性)
- 2、java中的queue类有哪些用法？
- 3、先进先出的模式,应该用Java的什么算法
- 4、如何用Java和Redis设计一个高效的先入先出的队列
- 5、java 用什么实现 FIFO队列？
Java使用LinkedList来模拟一个队列(先进先出的特性)
import java.util.LinkedList;
public class Demo01 {
private LinkedListObject linkedList;
public Demo01() {
linkedList = new LinkedListObject();
}
public void put(Object object) {
linkedList.add(object);
}
public Object get() {
Object object = null;
if (linkedList.size() != 0) {
object = linkedList.get(0);
linkedList.remove(0);
}
return object;
}
public boolean isEmpty() {
if (linkedList.size() != 0) {
return true;
} else {
return false;
}
}
public static void main(String[] args) {
Demo01 demo01 = new Demo01();
demo01.put("1");
demo01.put("2");
System.out.println(demo01.get());
System.out.println(demo01.get());
System.out.println(demo01.isEmpty());
}
}
结果：
1
2
false
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的什么算法
使用java队列算法，网站有第三方实现jar.
你也可以自己简单实现一个，可以同数组模拟，也可以用List模拟。
在java中有java.util.Queue接口，你可以详细查看一下java的API相关的说明后在使用。
如何用Java和Redis设计一个高效的先入先出的队列
分析：
redis的list底层是多个ziplist结构组成的“双向”链表。中间部分还压缩了一下。
最外层是由两个哈希表构成的dict。
哈希表的get(key)时间复杂度为O(1),而且这个O(1)理论上不会因为所占内存的大小和元素数目所改变。list的出队列和入队操作也都是O(1)。
Java的队列时间复杂度也应为O(1)。
可不可以直接用redis的list做先进先出？
情况1，数据数量不多，可以用
情况2，数据量多，但存的数据是激活码这样简单值一类，可以用。
情况3，list存的是要获取数据的索引，大量数据的值已经存在redis的KV结构中。
这时候，如果数据每次获取下一个数据都要执行redis的hash查找（O(1)）然后redis的list从头或者末尾出一个。经过网络IO返回，Java程序在用出来的key去请求redis去get(key) （O(1)）。这里是两次网络IO或者进程间的IO。
这时候，可以不用redis的list存索引而只是用redis大的KV哈希结构存键值。用①Java的队列先进先出获取下一个key或者②使用预先规定好的键生成的规则，让键是有规则有顺序的，比如自增ID，然后每次获取都是ID++，而直接从redis.get(ID.next());来获取值。
最后一种就是最高效的办法，为了特殊场景的高效出队列而设计。但是如果只是一般的数据量，使用redis的list也未尝不可。
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先进先出的信息别忘了在本站进行查找喔。