java 自行编写程序实现队列的效果

class myqueue

{

ArrayList<Integer>

list = new ArrayList<Integer>();

public boolean add(Integer value)

{

return listadd(value);

}

public boolean offer(Integer value)

{

return listadd(value);

}

/

function: 获取但不移除对象的头 为空时抛出异常

@return

/

public Integer element()

{

if(listsize() == 0) throw new NoSuchElementException();

return listget(0);

}

/

function: 获取但不移除对象的头 为空时 返回null

@return

/

public Integer peek()

{

if(listsize() == 0) return null;

return listget(0);

}

/

function: 获取并移除对象的头 为空时未null

@return

/

public Integer poll()

{

if(listsize() == 0) return null;

Integer i = listget(0);

listremove(0);

return i;

}

/

function:获取并移除对象的头 为空时抛出异常

@return

/

public Integer remove()

{

if(listsize() == 0) throw new NoSuchElementException();

Integer i = listget(0);

listremove(0);

return i;

}

}

真正需要的其实很简单，就是个BlcokingQueue

你可以在主线程里，向BlockingQueue添加对象，这个过程是即时返回的，不会阻塞。然后另外启动一个线程专门读取BlockingQueue的对象，进行处理，一旦队列里没有新对象，这个线程会自动阻塞到有新的对象加入到队列为止。

public class HelloWorld{

public static void main(String[] args){

Systemoutprintln("hello world!");

}

}

一 基本概念

Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。

二 体系

Java分为三个体系，分别为Java SE（J2SE，Java2 Platform Standard Edition，标准版），

JavaEE（J2EE，Java 2 Platform, Enterprise Edition，企业版）。

Java ME（J2ME，Java 2 Platform Micro Edition，微型版）。

java中的消息队列

消息队列是线程间通讯的手段：

importjavautil

publicclassMsgQueue{

privateVectorqueue=null;

publicMsgQueue(){

queue=newVector();

}

publicvoidsend(Objecto)

{

queueaddElement(o);

}

publicObjectrecv()

{

if(queuesize()==0)

returnnull;

Objecto=queue();

queue(0);//orqueue[0]=nullcanalsowork

returno;

}

}

因为java中是lockedbyobject的所以添加就可以用于线程同步锁定对象

可以作为多线程处理多任务的存放task的队列。他的client包括封装好的task类以及thread类

Java的多线程-线程间的通信2009-08-2521:58

1线程的几种状态

线程有四种状态，任何一个线程肯定处于这四种状态中的一种：

1)产生（New）：线程对象已经产生，但尚未被启动，所以无法执行。如通过new产生了一个线程对象后没对它调用start()函数之前。

2)可执行（Runnable）：每个支持多线程的系统都有一个排程器，排程器会从线程池中选择一个线程并启动它。当一个线程处于可执行状态时，表示它可能正处于线程池中等待排排程器启动它；也可能它已正在执行。如执行了一个线程对象的start()方法后，线程就处于可执行状态，但显而易见的是此时线程不一定正在执行中。

3)死亡（Dead）：当一个线程正常结束，它便处于死亡状态。如一个线程的run()函数执行完毕后线程就进入死亡状态。

4)停滞（Blocked）：当一个线程处于停滞状态时，系统排程器就会忽略它，不对它进行排程。当处于停滞状态的线程重新回到可执行状态时，它有可能重新执行。如通过对一个线程调用wait()函数后，线程就进入停滞状态，只有当两次对该线程调用notify或notifyAll后它才能两次回到可执行状态。

2classThread下的常用函数函数

21suspend()、resume()

1)通过suspend()函数，可使线程进入停滞状态。通过suspend()使线程进入停滞状态后，除非收到resume()消息，否则该线程不会变回可执行状态。

2)当调用suspend()函数后，线程不会释放它的“锁标志”。

例11：

classextendsThread{

publicstaticintshareVar=0;

public(Stringname){

super(name);

}

publicvoidrun(){

if(shareVar==0){

for(inti=0;i

shareVar;

if(shareVar==5){

thissuspend();//（1）

}}}

else{

Systemoutprint(Thread()getName());

Systemoutprintln("shareVar="shareVar);

thisresume();//（2）

}}

}

publicclassTestThread{

publicstaticvoidmain(String[]args){

t1=new("t1");

t2=new("t2");

t1start();//（5）

//t1start();//（3）

t2start();//（4）

}}

参考代码和注释如下

简单测试了下,如果有问题接着在讨论

public class Queue {

private int[] elements;

public static final int DEFAULT_CAPACITY =8;//默认长度8

private int size = 0;

public Queue() {

elements = new int[DEFAULT_CAPACITY];

}

public Queue(int capacity) {

elements = new int[capacity];

}

public void enqueue(int v) {

if (size >= elementslength) {// 数组扩容

int[] temp = new int[elementslength  2];

Systemarraycopy(elements, 0, temp, 0, elementslength);

elements = temp;

}

elements[size++] = v;

}

public int dequeue() {// 先进先出

if (empty()) {

throw new RuntimeException("异常");

}

int x = elements[0];// 先把第一个元素保存出来

// 左移一位

// int[] temp = new int[elementslength];

// Systemarraycopy(elements,1, temp, 0, elementslength-1);

// elements = temp;

// 左移一位

for (int i = 0; i < elementslength - 1; i++) {

elements[i] = elements[i + 1];

}

elements[elementslength - 1] = 0;// 外面一般访问不了elements 后面的元素可以不用归零,但是归零了感觉舒服点

size--;

return x;

}

public boolean empty() {

return size == 0;

}

public int getSize() {

return size;

}

}

输出

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

import javautilArrayList;

/

@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 listget(listsize()-1);

}

//返回顶部的数据

public int[] getFirst(){

return listget(0);

}

//压入数据

public void put(int[] arry){

listadd(arry);

}

//删除底部数据

public void removeLast(){

listremove(listsize()-1);

}

//重置

public void reSet(){

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

}

//删除顶部数据

public void removeFirst(){

listremove(0);

}

//返回数据长度

public int size(){

return listsize();

}

public static void main(String[] args) {

SnakeBody data = new SnakeBody();

for(int i=0;i<10;i++){

dataput(new int[]{0,i});

}

Systemoutprintln(datagetFirst()[0]+"-------"+datagetFirst()[1]);

Systemoutprintln(datagetLast()[0]+"-------"+datagetLast()[1]);

dataremoveLast();

Systemoutprintln(datagetFirst()[0]+"-------"+datagetFirst()[1]);

Systemoutprintln(datagetLast()[0]+"-------"+datagetLast()[1]);

}

}

import javautilStack;

public class Translate {

//程序入口

public static void main(String[]args){

int n = Translatetranslate(3467,8);

Systemoutprintln("结果是："+n);

}

public static int translate(int number, int base_num) {

//使用栈

Stack<Integer>stack = new Stack<Integer>();

while(number>0){

//压栈

stackpush(number % base_num);

number /= base_num;

}

int n = stacksize();

int val=0;

//依次出栈并合成结果（用我们熟悉的十进制表示，所以乘以10）

for(int i=0;i<n;i++){

val=val10+stackpop();

}

return val;

}

}

以上就是关于java 自行编写程序实现队列的效果全部的内容，包括:java 自行编写程序实现队列的效果、请教一个关于JAVA任务队列的实现、我需要一段最简单的java代码程序等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！