环形队列问题 请编写一个环形队列类,要求支持多线程读写,读写长度可参数化,队列长度限制在 256 个单元,读写策越为先进先出。当队列发生溢出时,依照先进先出的策略覆盖最早进入队列的元素。求大神解读啊 解决方案 » 免费领取超大流量手机卡,每月29元包185G流量+100分钟通话, 中国电信官方发货 用list模拟了一个你说的要求,希望对你有帮助package com.study.stack;import java.util.ArrayList;import java.util.List;public class MyStack<E> { private List<E> datas; private int size; private int maxSize = 256; private Object lock = new Object(); public MyStack(){ datas = new ArrayList<E>(); } @SuppressWarnings({"unchecked", "hiding"}) public <E> E get(){ synchronized(lock){ if(size == 0){ return null; } size--; return (E) datas.remove(0); } } public void add(E e){ synchronized(lock){ if(size == maxSize){ datas.remove(0); datas.add(e); } datas.add(e); size++; } }}package com.study.stack;public class Test { public static void main(String[] args) { MyStack<String> s = new MyStack<String>(); T1 t1 = new T1(s); T11 t11 = new T11(s); T2 t2 = new T2(s); T22 t22 = new T22(s); t2.start(); t22.start(); t1.start(); t11.start(); } }class T1 extends Thread{ private MyStack<String> s; public T1(MyStack<String> s){ this.s = s; } public void run(){ while(true){ System.out.println(s.get()); try { this.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }}class T11 extends Thread{ private MyStack<String> s; public T11(MyStack<String> s){ this.s = s; } public void run(){ while(true){ System.out.println(s.get()); try { this.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }}class T2 extends Thread{ private MyStack<String> s; public T2(MyStack<String> s){ this.s = s; } public void run(){ int i = 0; while(true){ s.add("a"+i++); try { this.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }}class T22 extends Thread{ private MyStack<String> s; public T22(MyStack<String> s){ this.s = s; } public void run(){ int i = 0; while(true){ s.add("b"+i++); try { this.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }} 双向链表,组成一个环状的队列。public class CycleQueue<E> { public static int DEFAULT_CAPACITY = 256; class Entry{ Entry previous; Entry next; E element; } private Entry header; private int capacity; private int size=0; public CycleQueue(){ this(DEFAULT_CAPACITY); } public CycleQueue(int capacity){ this.capacity=capacity; header = new Entry(); header.next=header; header.previous=header; } /**向队列里加入元素 * @param elem 所要添加的元素 * @return 当且仅当队列溢出时返回被替换的元素,其他情况返回<code>null</code>。 */ public synchronized E offer(E elem){ if(size>=capacity){ E e = header.next.element; header.element = elem; header = header.next; header.element=null; return e; } Entry e = new Entry(); e.element = elem; e.previous = header.previous; e.next = header; e.previous.next = e; header.previous = e; size++; return null; } /**从队列里取得元素 * @return 当队列为空时,返回<code>null</code> */ public synchronized E poll(){ if(size<=0){ return null; } Entry e = header.next; header.next = e.next; e.next.previous = header; size--; return e.element; } /** * 获得队列的容量 */ public int getCapacity(){ return capacity; } /** * 获得队列当前所含元素的个数 */ public int size() { return size; } /** * 测试用例 */ public static void main(String[] args) { CycleQueue<Integer> queue = new CycleQueue<Integer>(5); System.out.println(queue.offer(Integer.valueOf(0))); System.out.println(queue.offer(Integer.valueOf(1))); System.out.println(queue.offer(Integer.valueOf(2))); System.out.println(queue.poll()); System.out.println(queue.poll()); for(int i=1;i<=5;i++){ queue.offer(i); } System.out.println(queue.offer(10)); System.out.println(queue.poll()); System.out.println(queue.poll()); }} 双向链表组成环状队列。public class CycleQueue<E> { public static int DEFAULT_CAPACITY = 256; class Entry{ Entry previous; Entry next; E element; } private Entry header; private int capacity; private int size=0; public CycleQueue(){ this(DEFAULT_CAPACITY); } public CycleQueue(int capacity){ this.capacity=capacity; header = new Entry(); header.next=header; header.previous=header; } /**向队列里加入元素 * @param elem 所要添加的元素 * @return 当且仅当队列溢出时返回被替换的元素,其他情况返回<code>null</code>。 */ public synchronized E offer(E elem){ if(size>=capacity){ E e = header.next.element; header.element = elem; header = header.next; header.element=null; return e; } Entry e = new Entry(); e.element = elem; e.previous = header.previous; e.next = header; e.previous.next = e; header.previous = e; size++; return null; } /**从队列里取得元素 * @return 当队列为空时,返回<code>null</code> */ public synchronized E poll(){ if(size<=0){ return null; } Entry e = header.next; header.next = e.next; e.next.previous = header; size--; return e.element; } /** * 获得队列的容量 */ public int getCapacity(){ return capacity; } /** * 获得队列当前所含元素的个数 */ public int size() { return size; } /** * 测试用例 */ public static void main(String[] args) { CycleQueue<Integer> queue = new CycleQueue<Integer>(5); System.out.println(queue.offer(Integer.valueOf(0))); System.out.println(queue.offer(Integer.valueOf(1))); System.out.println(queue.offer(Integer.valueOf(2))); System.out.println(queue.poll()); System.out.println(queue.poll()); for(int i=1;i<=5;i++){ queue.offer(i); } System.out.println(queue.offer(10)); System.out.println(queue.poll()); System.out.println(queue.poll()); }} 与JS和上传用的file对象美化有关的问题 菜鸟提问,学习中不知道学习方向 java读入文件之后打印输出,怎么输出源文件的行号??? Runtime.getRuntime().exec()应用程序打开IE浏览器的问题!! Hodex(小何才露尖尖角) 来问个菜菜菜菜题,关于我的第一个java程序。。。 十万火急! copy文件时候的一个小问题, Windows 98下可否运行Tomcat? 【求助】初学者求助 swing中如何让jtextarea得到另一个线程中不断更新的值? 环形队列问题
import java.util.List;public class MyStack<E> { private List<E> datas;
private int size;
private int maxSize = 256;
private Object lock = new Object();
public MyStack(){
datas = new ArrayList<E>();
}
@SuppressWarnings({"unchecked", "hiding"})
public <E> E get(){
synchronized(lock){
if(size == 0){
return null;
}
size--;
return (E) datas.remove(0);
}
}
public void add(E e){
synchronized(lock){
if(size == maxSize){
datas.remove(0);
datas.add(e);
}
datas.add(e);
size++;
}
}
}package com.study.stack;public class Test { public static void main(String[] args) {
MyStack<String> s = new MyStack<String>();
T1 t1 = new T1(s);
T11 t11 = new T11(s);
T2 t2 = new T2(s);
T22 t22 = new T22(s);
t2.start();
t22.start();
t1.start();
t11.start();
}
}class T1 extends Thread{
private MyStack<String> s;
public T1(MyStack<String> s){
this.s = s;
}
public void run(){
while(true){
System.out.println(s.get());
try {
this.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class T11 extends Thread{
private MyStack<String> s;
public T11(MyStack<String> s){
this.s = s;
}
public void run(){
while(true){
System.out.println(s.get());
try {
this.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class T2 extends Thread{
private MyStack<String> s;
public T2(MyStack<String> s){
this.s = s;
}
public void run(){
int i = 0;
while(true){
s.add("a"+i++);
try {
this.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class T22 extends Thread{
private MyStack<String> s;
public T22(MyStack<String> s){
this.s = s;
}
public void run(){
int i = 0;
while(true){
s.add("b"+i++);
try {
this.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Entry{
Entry previous;
Entry next;
E element;
}
private Entry header;
private int capacity;
private int size=0;
public CycleQueue(){
this(DEFAULT_CAPACITY);
}
public CycleQueue(int capacity){
this.capacity=capacity;
header = new Entry();
header.next=header;
header.previous=header;
}
/**向队列里加入元素
* @param elem 所要添加的元素
* @return 当且仅当队列溢出时返回被替换的元素,其他情况返回<code>null</code>。
*/
public synchronized E offer(E elem){
if(size>=capacity){
E e = header.next.element;
header.element = elem;
header = header.next;
header.element=null;
return e;
}
Entry e = new Entry();
e.element = elem;
e.previous = header.previous;
e.next = header;
e.previous.next = e;
header.previous = e;
size++;
return null;
}
/**从队列里取得元素
* @return 当队列为空时,返回<code>null</code>
*/
public synchronized E poll(){
if(size<=0){
return null;
}
Entry e = header.next;
header.next = e.next;
e.next.previous = header;
size--;
return e.element;
}
/**
* 获得队列的容量
*/
public int getCapacity(){
return capacity;
}
/**
* 获得队列当前所含元素的个数
*/
public int size() {
return size;
} /**
* 测试用例
*/
public static void main(String[] args) {
CycleQueue<Integer> queue = new CycleQueue<Integer>(5);
System.out.println(queue.offer(Integer.valueOf(0)));
System.out.println(queue.offer(Integer.valueOf(1)));
System.out.println(queue.offer(Integer.valueOf(2)));
System.out.println(queue.poll());
System.out.println(queue.poll());
for(int i=1;i<=5;i++){
queue.offer(i);
}
System.out.println(queue.offer(10));
System.out.println(queue.poll());
System.out.println(queue.poll());
}}
class Entry{
Entry previous;
Entry next;
E element;
}
private Entry header;
private int capacity;
private int size=0;
public CycleQueue(){
this(DEFAULT_CAPACITY);
}
public CycleQueue(int capacity){
this.capacity=capacity;
header = new Entry();
header.next=header;
header.previous=header;
}
/**向队列里加入元素
* @param elem 所要添加的元素
* @return 当且仅当队列溢出时返回被替换的元素,其他情况返回<code>null</code>。
*/
public synchronized E offer(E elem){
if(size>=capacity){
E e = header.next.element;
header.element = elem;
header = header.next;
header.element=null;
return e;
}
Entry e = new Entry();
e.element = elem;
e.previous = header.previous;
e.next = header;
e.previous.next = e;
header.previous = e;
size++;
return null;
}
/**从队列里取得元素
* @return 当队列为空时,返回<code>null</code>
*/
public synchronized E poll(){
if(size<=0){
return null;
}
Entry e = header.next;
header.next = e.next;
e.next.previous = header;
size--;
return e.element;
}
/**
* 获得队列的容量
*/
public int getCapacity(){
return capacity;
}
/**
* 获得队列当前所含元素的个数
*/
public int size() {
return size;
} /**
* 测试用例
*/
public static void main(String[] args) {
CycleQueue<Integer> queue = new CycleQueue<Integer>(5);
System.out.println(queue.offer(Integer.valueOf(0)));
System.out.println(queue.offer(Integer.valueOf(1)));
System.out.println(queue.offer(Integer.valueOf(2)));
System.out.println(queue.poll());
System.out.println(queue.poll());
for(int i=1;i<=5;i++){
queue.offer(i);
}
System.out.println(queue.offer(10));
System.out.println(queue.poll());
System.out.println(queue.poll());
}}