「java队列创建」java实现一个队列
本篇文章给大家谈谈java队列创建，以及java实现一个队列对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、java版数据结构如何创建一个循环队列
- 2、怎么编写一个简单的java队列?
- 3、java中创建队列Queue的问题
- 4、到底什么是消息队列？Java中如何实现消息队列
- 5、用java编一个队列
- 6、用java语言设计顺序循环队列类
java版数据结构如何创建一个循环队列
public class CircleQueueT {
private int maxSize;
private int head;//头部出 始终指向即将被取出的下标
private int tail;//尾部进 始终指向即将赋值的下标
private int size;
//tail和head在队列为空或为满的时候重合,用size是否为0来区分
private Object[] array;
public CircleQueue(int maxSize){
this.maxSize=maxSize;
array=new Object[this.maxSize];
}
public synchronized boolean put(T t){
if(sizemaxSize){
array[tail]=t;
tail=(tail+1)%maxSize;
size++;
return true;
}else{
return false;
}
}
public synchronized T take(){
if(size0){
T t=(T) array[head];
head=(head+1)%maxSize;
size--;
return t;
}else{
return null;
}
}
public int size(){
return size;
}
}
怎么编写一个简单的java队列?
import java.util.*;
public class MyQueueT {
private LinkedListT list = new LinkedListT();
public void addLast(T v) {
list.addLast(v); //队尾插入
}
public T getFirst() {
return list.getFirst(); //取得队受元素
}
public void remove() {
list.removeFirst(); //移除队首元素
}
//类似功能自己扩展下
public static void main(String[] args) {
MyQueueString mq = new MyQueueString();
mq.addLast("hello world");
mq.addLast("hello world2");
System.out.println(mq.getFirst());
mq.remove();
System.out.println(mq.getFirst());
}
}
java中创建队列Queue的问题
因为queue是接口，不能new 接口，应该new接口实现类，你看jdk文档，搜索queue，如图：
看见下面有一大堆实现queue的类，选一个就行，针对队列的，你可以选LinkedBlockingQueue,AbstrctQueue,ArrayDeque
到底什么是消息队列？Java中如何实现消息队列
所谓队列，就是按照队首先出的规则建立的数据结构，消息队列就是根据消息到来后按照一定的规则进行排序，但一定是队首的消息先得到应答的队列。
比如：
public static String do_post(String url, ListNameValuePair name_value_pair) throws IOException {
String body = "{}";
DefaultHttpClient httpclient = new DefaultHttpClient();
try {
HttpPost httpost = new HttpPost(url);
httpost.setEntity(new UrlEncodedFormEntity(name_value_pair, StandardCharsets.UTF_8));
HttpResponse response = httpclient.execute(httpost);
HttpEntity entity = response.getEntity();
body = EntityUtils.toString(entity);
} finally {
httpclient.getConnectionManager().shutdown();
}
return body;
}
public static String do_get(String url) throws ClientProtocolException, IOException {
String body = "{}";
DefaultHttpClient httpclient = new DefaultHttpClient();
try {
HttpGet httpget = new HttpGet(url);
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
body = EntityUtils.toString(entity);
} finally {
httpclient.getConnectionManager().shutdown();
}
return body;
}
用java编一个队列
自己写了个简单的实现
class QueueE{
private Object[] integerQueue;//用来当队列
public int tail;//队尾
public int size;//队的长度，也可以设置一个默认值，溢出时从新申请
public Queue(int size){
integerQueue=new Object[size];
this.size=size;
tail=-1;
}
/**
* 将元素插入队列
* @return 如果该元素已添加到此队列，则返回 true；否则返回 false
*/
public boolean offer(E e){
if(tail size-1){
tail++;
this.integerQueue[tail]=e;
return true;
}else{
return false;
}
}
/**
* 获取并移除此队列的头，如果此队列为空，则返回 null。
*/
public E poll(){
Object tmp;
if(tail=0){
tmp=this.integerQueue[tail];
tail--;
return (E)tmp;
}else{
return null;
}
}
}
用java语言设计顺序循环队列类
代码如下：
import java.io.Serializable;
import java.util.Arrays;
public class LoopQueueT implements Serializable {
/**
* @Fields serialVersionUID : TODO
*/
private static final long serialVersionUID = -3670496550272478781L;
private int DEFAULT_SIZE = 10;
private int capacity;// 保存数组的长度
private Object[] elementData;// 定义一个数组用于保存循环队列的元素
private int front = 0;// 队头
private int rear = 0;// 队尾
// 以默认数组长度创建空循环队列
public LoopQueue() {
capacity = DEFAULT_SIZE;
elementData = new Object[capacity];
}
// 以一个初始化元素来创建循环队列
public LoopQueue(T element) {
this();
elementData[0] = element;
rear++;
}
/**
* 以指定长度的数组来创建循环队列
*
* @param element
* 指定循环队列中第一个元素
* @param initSize
* 指定循环队列底层数组的长度
*/
public LoopQueue(T element, int initSize) {
this.capacity = initSize;
elementData = new Object[capacity];
elementData[0] = element;
rear++;
}
// 获取循环队列的大小
public int size() {
if (isEmpty()) {
return 0;
}
return rear front ? rear - front : capacity - (front - rear);
}
// 插入队列
public void add(T element) {
if (rear == front elementData[front] != null) {
throw new IndexOutOfBoundsException("队列已满的异常");
}
elementData[rear++] = element;
// 如果rear已经到头，那就转头
rear = rear == capacity ? 0 : rear;
}
// 移除队列
public T remove() {
if (isEmpty()) {
throw new IndexOutOfBoundsException("空队列异常");
}
// 保留队列的rear端的元素的值
T oldValue = (T) elementData[front];
// 释放队列的rear端的元素
elementData[front++] = null;
// 如果front已经到头，那就转头
front = front == capacity ? 0 : front;
return oldValue;
}
// 返回队列顶元素，但不删除队列顶元素
public T element() {
if (isEmpty()) {
throw new IndexOutOfBoundsException("空队列异常");
}
return (T) elementData[front];
}
// 判断循环队列是否为空队列
public boolean isEmpty() {
// rear==front且rear处的元素为null
return rear == front elementData[rear] == null;
}
// 清空循环队列
public void clear() {
// 将底层数组所有元素赋为null
Arrays.fill(elementData, null);
front = 0;
rear = 0;
}
public String toString() {
if (isEmpty()) {
return "[]";
} else {
// 如果front rear，有效元素就是front到rear之间的元素
if (front rear) {
StringBuilder sb = new StringBuilder("[");
for (int i = front; i rear; i++) {
sb.append(elementData[i].toString() + ", ");
}
int len = sb.length();
return sb.delete(len - 2, len).append("]").toString();
}
// 如果front = rear，有效元素为front-capacity之间、0-front之间的
else {
StringBuilder sb = new StringBuilder("[");
for (int i = front; i capacity; i++) {
sb.append(elementData[i].toString() + ", ");
}
for (int i = 0; i rear; i++) {
sb.append(elementData[i].toString() + ", ");
}
int len = sb.length();
return sb.delete(len - 2, len).append("]").toString();
}
}
}
public static void main(String[] args) {
LoopQueueString queue = new LoopQueueString("aaaa", 3);
// 添加两个元素
queue.add("bbbb");
queue.add("cccc");
// 此时队列已满
System.out.println(queue);
// 删除一个元素后，队列可以再多加一个元素
queue.remove();
System.out.println("删除一个元素后的队列：" + queue);
// 再次添加一个元素，此时队列又满
queue.add("dddd");
System.out.println(queue);
System.out.println("队列满时的长度：" + queue.size());
// 删除一个元素后，队列可以再多加一个元素
queue.remove();
// 再次加入一个元素，此时队列又满
queue.add("eeee");
System.out.println(queue);
}
}
java队列创建的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java实现一个队列、java队列创建的信息别忘了在本站进行查找喔。
发布于：2022-12-20，除非注明，否则均为原创文章，转载请注明出处。