java数组实现队列

㈠ java 队列

java类库有Queue类，但是如果楼主想自己定义队列的话，可以模仿C++指针定义队列的方式。java和C#虽然没有指针，但是它们的对象默认都是传引用的，也就像指针传递地址一样，呵呵。

㈡ 跪求用JAVA语言实现一个栈和一个队列，数据元素为double型。。。具体在问题补充里

publicinterfaceMyStack<T>{
	/**
	*判断栈是否为空
	*/
	booleanisEmpty();
	/**
	*清空栈
	*/
	voidclear();
	/**
	*栈的长度
	*/
	intlength();
	/**
	*数据入栈
	*/
	booleanpush(Tdata);
	/**
	*数据出栈
	*/
	Tpop();
}
publicclassMyArrayStack<T>implementsMyStack<T>{
	privateObject[]objs=newObject[16];
	privateintsize=0;

	@Override
	publicbooleanisEmpty(){
		returnsize==0;
	}

	@Override
	publicvoidclear(){
		//将数组中的数据置为null,方便GC进行回收
		for(inti=0;i<size;i++){
			objs[size]=null;
		}
		size=0;
	}

	@Override
	publicintlength(){
		returnsize;
	}

	@Override
	publicbooleanpush(Tdata){
		//判断是否需要进行数组扩容
		if(size>=objs.length){
			resize();
		}
		objs[size++]=data;
		returntrue;
	}

	/**
	*数组扩容
	*/
	privatevoidresize(){
		Object[]temp=newObject[objs.length*3/2+1];
		for(inti=0;i<size;i++){
			temp[i]=objs[i];
			objs[i]=null;
		}
		objs=temp;
	}

	@SuppressWarnings("unchecked")
	@Override
	publicTpop(){
		if(size==0){
			returnnull;
		}
		return(T)objs[--size];
	}

	@Override
	publicStringtoString(){
		StringBuildersb=newStringBuilder();
		sb.append("MyArrayStack:[");
		for(inti=0;i<size;i++){
			sb.append(objs[i].toString());
			if(i!=size-1){
				sb.append(",");
			}
		}
		sb.append("]");
		returnsb.toString();
	}
}
//栈的链表实现
publicclassMyLinkedStack<T>implementsMyStack<T>{
	/**
	*栈顶指针
	*/
	privateNodetop;
	/**
	*栈的长度
	*/
	privateintsize;
	
	publicMyLinkedStack(){
		top=null;
		size=0;
	}
	
	@Override
	publicbooleanisEmpty(){
		returnsize==0;
	}
	
	@Override
	publicvoidclear(){
		top=null;
		size=0;
	}
	
	@Override
	publicintlength(){
		returnsize;
	}
	
	@Override
	publicbooleanpush(Tdata){
		Nodenode=newNode();
		node.data=data;
		node.pre=top;
		//改变栈顶指针
		top=node;
		size++;
		returntrue;
	}
	
	@Override
	publicTpop(){
		if(top!=null){
			Nodenode=top;
			//改变栈顶指针
			top=top.pre;
			size--;
			returnnode.data;
		}
		returnnull;
	}
	
	/**
	*将数据封装成结点
	*/
	privatefinalclassNode{
		privateNodepre;
		privateTdata;
	}
}

㈢ 用java语言设计顺序循环队列类

代码如下：

importjava.io.Serializable;
importjava.util.Arrays;

publicclassLoopQueue<T>implementsSerializable{
	/**
	*@FieldsserialVersionUID:TODO
	*/
	=-3670496550272478781L;

	privateintDEFAULT_SIZE=10;

	privateintcapacity;//保存数组的长度

	privateObject[]elementData;//定义一个数组用于保存循环队列的元素

	privateintfront=0;//队头

	privateintrear=0;//队尾

	//以默认数组长度创建空循环队列
	publicLoopQueue(){
		capacity=DEFAULT_SIZE;
		elementData=newObject[capacity];
	}

	//以一个初始化元素来创建循环队列
	publicLoopQueue(Telement){
		this();
		elementData[0]=element;
		rear++;
	}

	/**
	*以指定长度的数组来创建循环队列
	*
	*@paramelement
	*指定循环队列中第一个元素
	*@paraminitSize
	*指定循环队列底层数组的长度
	*/
	publicLoopQueue(Telement,intinitSize){
		this.capacity=initSize;
		elementData=newObject[capacity];
		elementData[0]=element;
		rear++;
	}

	//获取循环队列的大小
	publicintsize(){
		if(isEmpty()){
			return0;
		}
		returnrear>front?rear-front:capacity-(front-rear);
	}

	//插入队列
	publicvoidadd(Telement){
		if(rear==front&&elementData[front]!=null){
			("队列已满的异常");
		}
		elementData[rear++]=element;
		//如果rear已经到头，那就转头
		rear=rear==capacity?0:rear;
	}

	//移除队列
	publicTremove(){
		if(isEmpty()){
			("空队列异常");
		}
		//保留队列的rear端的元素的值
		ToldValue=(T)elementData[front];
		//释放队列的rear端的元素
		elementData[front++]=null;
		//如果front已经到头，那就转头
		front=front==capacity?0:front;
		returnoldValue;
	}

	//返回队列顶元素，但不删除队列顶元素
	publicTelement(){
		if(isEmpty()){
			("空队列异常");
		}
		return(T)elementData[front];
	}

	//判断循环队列是否为空队列
	publicbooleanisEmpty(){
		//rear==front且rear处的元素为null
		returnrear==front&&elementData[rear]==null;
	}

	//清空循环队列
	publicvoidclear(){
		//将底层数组所有元素赋为null
		Arrays.fill(elementData,null);
		front=0;
		rear=0;
	}

	publicStringtoString(){
		if(isEmpty()){
			return"[]";
		}else{
			//如果front<rear，有效元素就是front到rear之间的元素
			if(front<rear){
				StringBuildersb=newStringBuilder("[");
				for(inti=front;i<rear;i++){
					sb.append(elementData[i].toString()+",");
				}
				intlen=sb.length();
				returnsb.delete(len-2,len).append("]").toString();
			}
			//如果front>=rear，有效元素为front->capacity之间、0->front之间的
			else{
				StringBuildersb=newStringBuilder("[");
				for(inti=front;i<capacity;i++){
					sb.append(elementData[i].toString()+",");
				}
				for(inti=0;i<rear;i++){
					sb.append(elementData[i].toString()+",");
				}
				intlen=sb.length();
				returnsb.delete(len-2,len).append("]").toString();
			}
		}
	}

	publicstaticvoidmain(String[]args){
		LoopQueue<String>queue=newLoopQueue<String>("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);
	}
}

㈣ queue java 是怎么实现的

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

队列是一种数据结构．它有两个基本操作：在队列尾部加人一个元素，和从队列头部移除一个元素就是说，队列以一种先进先出的方式管理数据，如果你试图向一个 已经满了的阻塞队列中添加一个元素或者是从一个空的阻塞队列中移除一个元索，将导致线程阻塞．在多线程进行合作时，阻塞队列是很有用的工具。工作者线程可 以定期地把中间结果存到阻塞队列中而其他工作者线线程把中间结果取出并在将来修改它们。队列会自动平衡负载。如果第一个线程集运行得比第二个慢，则第二个 线程集在等待结果时就会阻塞。如果第一个线程集运行得快，那么它将等待第二个线程集赶上来。下表显示了jdk1.5中的阻塞队列的操作：

add 增加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常
remove 移除并返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
element 返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
offer 添加一个元素并返回true 如果队列已满，则返回false
poll 移除并返问队列头部的元素 如果队列为空，则返回null
peek 返回队列头部的元素 如果队列为空，则返回null
put 添加一个元素 如果队列满，则阻塞
take 移除并返回队列头部的元素 如果队列为空，则阻塞

remove、element、offer 、poll、peek 其实是属于Queue接口。

阻塞队列的操作可以根据它们的响应方式分为以下三类：aad、removee和element操作在你试图为一个已满的队列增加元素或从空队列取得元素时 抛出异常。当然，在多线程程序中，队列在任何时间都可能变成满的或空的，所以你可能想使用offer、poll、peek方法。这些方法在无法完成任务时 只是给出一个出错示而不会抛出异常。

注意：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方法在队列空时阻塞。

java.ulil.concurrent包提供了阻塞队列的4个变种。默认情况下，LinkedBlockingQueue的容量是没有上限的（说的不准确，在不指定时容量为Integer.MAX_VALUE，不要然的话在put时怎么会受阻呢），但是也可以选择指定其最大容量，它是基于链表的队列，此队列按 FIFO（先进先出）排序元素。

ArrayBlockingQueue在构造时需要指定容量， 并可以选择是否需要公平性，如果公平参数被设置true，等待时间最长的线程会优先得到处理（其实就是通过将ReentrantLock设置为true来 达到这种公平性的：即等待时间最长的线程会先操作）。通常，公平性会使你在性能上付出代价，只有在的确非常需要的时候再使用它。它是基于数组的阻塞循环队 列，此队列按 FIFO（先进先出）原则对元素进行排序。

PriorityBlockingQueue是一个带优先级的 队列，而不是先进先出队列。元素按优先级顺序被移除，该队列也没有上限（看了一下源码，PriorityBlockingQueue是对 PriorityQueue的再次包装，是基于堆数据结构的，而PriorityQueue是没有容量限制的，与ArrayList一样，所以在优先阻塞 队列上put时是不会受阻的。虽然此队列逻辑上是无界的，但是由于资源被耗尽，所以试图执行添加操作可能会导致 OutOfMemoryError），但是如果队列为空，那么取元素的操作take就会阻塞，所以它的检索操作take是受阻的。另外，往入该队列中的元 素要具有比较能力。

最后，DelayQueue（基于PriorityQueue来实现的）是一个存放Delayed 元素的无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部，并且poll将返回null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时，则出现期满，poll就以移除这个元素了。此队列不允许使用 null 元素。

㈤ java 有关ArrayList，可不可以用toString输出的问题

首先，我们知道ArrayList是List的实现类，继承于AbstractList，它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。虽然它也是一个Object，但总体上来讲，并没有实现toString方法，所以其类来调用toString方法是不对的 (也就是说 不能ArrayList.toString)，但是既然是一个数组序列，而数组是可以调用toString方法，所以在不重写的情况下，可以转变为相应的数组，恰巧ArrayList实现的List中是有这个方法即list.toArray()。

如果你对基础类型输出，可以采用转为相应的数组，进而可以调用Arrays.toString()方法输出。

//比如
ArrayList<String>list=newArrayList<String>(Arrays.asList("BuenosAires","Córdoba","LaPlata"));
System.out.println(Arrays.toString(list.toArray()));

㈥ 高手请帮忙用java版的数据结构，设置3个队列，实现入队出队。

import java.util.ArrayList;

/**
*
* @author 狱韬
*/
public class SnakeBody {
private int size=0; //队列的长度
private int cursor=-1; //指针
private ArrayList<int[]> list=null; //存储器

public SnakeBody() {
list=new ArrayList<int[]>(); //存储器
}

//返回底部的数据
public int[] getLast(){
return list.get(list.size()-1);
}

//返回顶部的数据
public int[] getFirst(){
return list.get(0);
}

//压入数据
public void put(int[] arry){
list.add(arry);
}

//删除底部数据
public void removeLast(){
list.remove(list.size()-1);
}

//重置
public void reSet(){
list=new ArrayList<int[]>(); //存储器
}

//删除顶部数据
public void removeFirst(){
list.remove(0);
}

//返回数据长度
public int size(){
return list.size();
}

public static void main(String[] args) {
SnakeBody data = new SnakeBody();
for(int i=0;i<10;i++){
data.put(new int[]{0,i});
}
System.out.println(data.getFirst()[0]+"-------"+data.getFirst()[1]);
System.out.println(data.getLast()[0]+"-------"+data.getLast()[1]);
data.removeLast();
System.out.println(data.getFirst()[0]+"-------"+data.getFirst()[1]);
System.out.println(data.getLast()[0]+"-------"+data.getLast()[1]);
}
}