1. 用java實現循環隊列
簡單寫了下，希望你能看明白
import java.util.ArrayList;
public class SeqQueue {
ArrayList<String> list;
public SeqQueue() {
list = new ArrayList<String>();
}
public String getFirst() {
if (!list.isEmpty()) {
String s = list.get(0);
list.remove(0);
return s;
}
return null;
}
public void insertLast(String s) {
list.add(s);
}
public static void main(String[] args) {
SeqQueue seq = new SeqQueue();
seq.insertLast("111");
seq.insertLast("222");
seq.insertLast("333");
System.out.println(seq.getFirst());
System.out.println(seq.getFirst());
System.out.println(seq.getFirst());
}
}
2. 怎樣用java代碼實現一個隊列
class Stack<T> {
private Vector<T> v;
public Stack(){
v = new Vector<T>();
}
public T pop(){
if (v.size()==0) return null;
return v.get(v.size()-1);
}
public void push(T t){
v.add(t);
}
public boolean isEmpty(){
return v.size()==0;
}
}
class Queue<T>{
private Vector<T> v;
public Queue(){
v = new Vector<T>();
}
//入隊列
public void enqueue(T t){
v.add(t);
}
//出隊列
public T dequeue(){
if (v.size()==0) return null;
return v.get(0);
}
public boolean isEmpty(){
return v.size() == 0;
}
}
3. 怎麼編寫一個簡單的java隊列
import java.util.*;
public class MyQueue<T> {
private LinkedList<T> list = new LinkedList<T>();
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) {
MyQueue<String> mq = new MyQueue<String>();
mq.addLast("hello world");
mq.addLast("hello world2");
System.out.println(mq.getFirst());
mq.remove();
System.out.println(mq.getFirst());
}
}
4. java動態增長隊列的實現
java裡面支持隊列這種數據結構，只要實現Queue<E>介面即可，比如下面實現了一個能容納String的隊列：
import java.util.*;
public class DynamicQueue{
private Queue<String> queue = new LinkedList<String>();
public void enque(String s) {
queue.offer(s);
}
public String deque() {
return queue.poll();
}
public static void main(String[] args){
DynamicQueue d_queue = new DynamicQueue();
d_queue.enque("123");
d_queue.enque("234");
d_queue.enque("345");
System.out.println(d_queue.deque());
System.out.println(d_queue.deque());
System.out.println(d_queue.deque());
}
}
5. java 用什麼實現 FIFO隊列
java使用數據結構來實現FIFO先進先出的隊列，實例如下：
/*
*Tochangethistemplate,chooseTools|Templates
*andopenthetemplateintheeditor.
*/
packagelinkedlisttest;
importjava.util.ArrayList;
importjava.util.Deque;
importjava.util.LinkedList;
importjava.util.List;
/**
*
*@authorVicky.H
*@[email protected]
*/
publicclassFIFOTest{
/**
*@
*/
publicstaticvoidmain(String[]args){
FIFO<A>fifo=newFIFOImpl<A>(5);
for(inti=0;i<20;i++){
Aa=newA("A:"+i);
Ahead=fifo.addLastSafe(a);
System.out.println(i+" head:"+head+" size:"+fifo.size());
}
System.out.println("---------------");
System.out.println("彈出數據");
List<A>polls=fifo.setMaxSize(3);
for(Aa:polls){
System.out.println(" head:"+a);
}
System.out.println("剩餘數據");
for(Aa:fifo){
System.out.println(" head:"+a);
}
System.out.println(fifo.size());
}
}
interfaceFIFO<T>extendsList<T>,Deque<T>,Cloneable,java.io.Serializable{
/**
*向最後添加一個新的，如果長度超過允許的最大值，則彈出一個*
*/
TaddLastSafe(TaddLast);
/**
*彈出head，如果Size=0返回null。而不同於pop拋出異常
*@return
*/
TpollSafe();
/**
*獲得最大保存
*
*@return
*/
intgetMaxSize();
/**
*設置最大存儲范圍
*
*@return返回的是，因為改變了隊列大小，導致彈出的head
*/
List<T>setMaxSize(intmaxSize);
}
classFIFOImpl<T>extendsLinkedList<T>implementsFIFO<T>{
privateintmaxSize=Integer.MAX_VALUE;
privatefinalObjectsynObj=newObject();
publicFIFOImpl(){
super();
}
publicFIFOImpl(intmaxSize){
super();
this.maxSize=maxSize;
}
@Override
publicTaddLastSafe(TaddLast){
synchronized(synObj){
Thead=null;
while(size()>=maxSize){
head=poll();
}
addLast(addLast);
returnhead;
}
}
@Override
publicTpollSafe(){
synchronized(synObj){
returnpoll();
}
}
@Override
publicList<T>setMaxSize(intmaxSize){
List<T>list=null;
if(maxSize<this.maxSize){
list=newArrayList<T>();
synchronized(synObj){
while(size()>maxSize){
list.add(poll());
}
}
}
this.maxSize=maxSize;
returnlist;
}
@Override
publicintgetMaxSize(){
returnthis.maxSize;
}
}
classA{
privateStringname;
publicA(){
}
publicA(Stringname){
this.name=name;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
@Override
publicStringtoString(){
return"A{"+"name="+name+'}';
}
}
6. java中怎麼實現隊列
public class Queue<E> {
private Object[] data=null;
private int maxSize; //隊列容量
private int front; //隊列頭，允許刪除
private int rear; //隊列尾，允許插入
//構造函數
public Queue(){
this(10);
}
public Queue(int initialSize){
if(initialSize >=0){
this.maxSize = initialSize;
data = new Object[initialSize];
front = rear =0;
}else{
throw new RuntimeException("初始化大小不能小於0：" + initialSize);
}
}
//判空
public boolean empty(){
return rear==front?true:false;
}
//插入
public boolean add(E e){
if(rear== maxSize){
throw new RuntimeException("隊列已滿，無法插入新的元素！");
}else{
data[rear++]=e;
return true;
}
}
//返回隊首元素，但不刪除
public E peek(){
if(empty()){
throw new RuntimeException("空隊列異常！");
}else{
return (E) data[front];
}
}
//出隊
public E poll(){
if(empty()){
throw new RuntimeException("空隊列異常！");
}else{
E value = (E) data[front]; //保留隊列的front端的元素的值
data[front++] = null; //釋放隊列的front端的元素
return value;
}
}
//隊列長度
public int length(){
return rear-front;
}
}
7. JAVA中，常用的隊列實現是哪個
用的比較多的是線程安全的
arrayblockingqueue
或者是
linkedblockingqueue.
8. Java中關於如何實現多線程消息隊列的實例
java中的消息隊列
消息隊列是線程間通訊的手段：
import java.util.*
public class MsgQueue{
private Vector queue = null;
public MsgQueue(){
queue = new Vector();
}
public synchronized void send(Object o)
{
queue.addElement(o);
}
public synchronized Object recv()
{
if(queue.size()==0)
return null;
Object o = queue.firstElement();
queue.removeElementAt(0);//or queue[0] = null can also work
return o;
}
}
因為java中是locked by object的所以添加synchronized 就可以用於線程同步鎖定對象
可以作為多線程處理多任務的存放task的隊列。他的client包括封裝好的task類以及thread類
Java的多線程-線程間的通信2009-08-25 21:58
1. 線程的幾種狀態
線程有四種狀態，任何一個線程肯定處於這四種狀態中的一種：
1) 產生（New）：線程對象已經產生，但尚未被啟動，所以無法執行。如通過new產生了一個線程對象後沒對它調用start()函數之前。
2) 可執行（Runnable）：每個支持多線程的系統都有一個排程器，排程器會從線程池中選擇一個線程並啟動它。當一個線程處於可執行狀態時，表示它可能正處於線程池中等待排排程器啟動它；也可能它已正在執行。如執行了一個線程對象的start()方法後，線程就處於可執行狀態，但顯而易見的是此時線程不一定正在執行中。
3) 死亡（Dead）：當一個線程正常結束，它便處於死亡狀態。如一個線程的run()函數執行完畢後線程就進入死亡狀態。
4) 停滯（Blocked）：當一個線程處於停滯狀態時，系統排程器就會忽略它，不對它進行排程。當處於停滯狀態的線程重新回到可執行狀態時，它有可能重新執行。如通過對一個線程調用wait()函數後，線程就進入停滯狀態，只有當兩次對該線程調用notify或notifyAll後它才能兩次回到可執行狀態。
2. classThread下的常用函數函數
2.1 suspend()、resume()
1) 通過suspend()函數，可使線程進入停滯狀態。通過suspend()使線程進入停滯狀態後，除非收到resume()消息，否則該線程不會變回可執行狀態。
2) 當調用suspend()函數後，線程不會釋放它的「鎖標志」。
例11：
class TestThreadMethod extends Thread{
public static int shareVar = 0;
public TestThreadMethod(String name){
super(name);
}
public synchronized void run(){
if(shareVar==0){
for(int i=0; i<5; i++){
shareVar++;
if(shareVar==5){
this.suspend();//（1）
}}}
else{
System.out.print(Thread.currentThread().getName());
System.out.println(" shareVar = " + shareVar);
this.resume();//（2）
}}
}
public class TestThread{
public static void main(String[] args){
TestThreadMethod t1 = new TestThreadMethod("t1");
TestThreadMethod t2 = new TestThreadMethod("t2");
t1.start();//（5）
//t1.start();//（3）
t2.start();//（4）
}}
9. java 隊列
java類庫有Queue類，但是如果樓主想自己定義隊列的話，可以模仿C++指針定義隊列的方式。java和C#雖然沒有指針，但是它們的對象默認都是傳引用的，也就像指針傳遞地址一樣，呵呵。
10. java誰能舉個隊列中offer比add好的例子
一般list或是queue都不用限制大小，如果在超出jvm限制的時候用add方法會拋出異常，而offer方法會返回false。我覺得offer和add不存在誰好誰壞的說法。add用在鏈表中，offer用在隊列中，前者是實現了list介面的方法，後者是實現了queue介面的方法，主要是針對不同的場景，選擇合適的方法就行了。