「java任务队列限定长度」java队列任务重复执行

博主：adminadmin 2023-03-17 17:26:14 270

本篇文章给大家谈谈java任务队列限定长度，以及java队列任务重复执行对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

java：编写数据访问接口，再分别以堆栈和队列的形式实现

链队列的定义：

队列的链式存储结构简称为链队列。它是限制仅在表头删除和表尾插入的单链表。

链队列的数据存储形式：

链队列基本运算的实现：

[java] view plain copy

package study_02.datastructure.queue;

/**

* 链队列

* @author WWX

*/

public class LinkQueueT {

//链的数据结构

private class Node{

public T data;

public Node next;

//无参构造函数

public Node(){}

public Node(T data,Node next){

this.data=data;

this.next=next;

}

}

//队列头指针

private Node front;

//队列尾指针

private Node rear;

//队列长度

private int size=0;

public LinkQueue(){

Node n=new Node(null,null);

n.next=null;

front=rear=n;

}

/**

* 队列入队算法

* @param data

* @author WWX

*/

public void enqueue(T data){

//创建一个节点

Node s=new Node(data,null);

//将队尾指针指向新加入的节点，将s节点插入队尾

rear.next=s;

rear=s;

size++;

}

/**

* 队列出队算法

* @return

* @author WWX

*/

public T dequeue(){

if(rear==front){

try {

throw new Exception("堆栈为空");

} catch (Exception e) {

e.printStackTrace();

}

return null;

}else{

//暂存队头元素

Node p=front.next;

T x=p.data;

//将队头元素所在节点摘链

front.next=p.next;

//判断出队列长度是否为1

if(p.next==null)

rear=front;

//删除节点

p=null;

size--;

return x;

}

}

/**

* 队列长队

* @return

* @author WWX

*/

public int size(){

return size;

}

/**

* 判断队列是否为空

* @return

* @author WWX

*/

public boolean isEmpty(){

return size==0;

}

public String toString() {

if(isEmpty()){

return "[]";

}else{

StringBuilder sb = new StringBuilder("[");

for(Node current=front.next;current!=null;current=current.next){

sb.append(current.data.toString() + ", ");

}

int len = sb.length();

return sb.delete(len - 2, len).append("]").toString();

}

}

//测试

public static void main(String[] args) {

LinkQueueInteger queue=new LinkQueueInteger();

queue.enqueue(1);

queue.enqueue(2);

queue.enqueue(3);

queue.enqueue(4);

queue.enqueue(5);

queue.enqueue(6);

System.out.println(queue);

System.out.println("出队："+queue.dequeue());

System.out.println("队列长度="+queue.size());

System.out.println(queue);

System.out.println("出队："+queue.dequeue());

System.out.println("队列长度="+queue.size());

System.out.println(queue);

System.out.println("出队："+queue.dequeue());

System.out.println("队列长度="+queue.size());

System.out.println(queue);

}

}

输出结果：

[1, 2, 3, 4, 5, 6]

出队：1

队列长度=5

[2, 3, 4, 5, 6]

出队：2

队列长度=4

[3, 4, 5, 6]

出队：3

队列长度=3

[4, 5, 6]

java如何编写用鼠标脱出轨迹 我的代码怎么修改就有轨迹了 求帮助

把鼠标的x和y放一个队列里，限定队列长度，每次都把队列里的点画出来就行了。

在java规范中类命名的字符长度是多少？

在java规范中没有限制类名的长度，但是系统本身会限制。

下面是详细说明：

java这个语言本身：没有限制。

java虚拟机本身的规范：

The length of field and method names, field and method descriptors, 

and other constant string values (including those referenced by 

ConstantValue (§4.7.2) attributes) is limited to 65535 characters by 

the 16-bit unsigned length item of the CONSTANT_Utf8_info structure

 (§4.4.7).

在java虚拟机看来类名本生也是字符串，所以java虚拟机规范是限制为65535

3.系统本身

Linux文件名的长度限制是255个字符

windows下完全限定文件名必须少于260个字符，目录名必须小于248个字符。

④求长度Java中X[O][1]=abcde长度length?

根据题目描述，可以得知X是一个二维数组，X[0][1]代表该数组的第1行第2列元素，值为字符串"abcde"。要求求出字符串"abcde"的长度length，可以使用Java中String类的length()方法，示例如下：

String str = X[0][1]; // 获取X的第1行第2列元素，即字符串"abcde"

int length = str.length(); // 使用String类的length()方法获取字符串长度

System.out.println(length); // 输出字符串长度，结果为5

因此，字符串"abcde"的长度为5。

java 队列

//通过LinkedList实现队列

package 队列和堆栈;

import java.util.*;

public class LinkedListQueueTest {

//字段

private LinkedList list;

//无参数构造

public LinkedListQueueTest()

{

list=new LinkedList();

}

//队列元素的个数

public int size()

{

return list.size();

}

//进入队列

public void enqueue(Object obj)

{

list.addLast(obj);

}

//对头出来

public Object dequeue()

{

return list.removeFirst();

}

//浏览对头元素

public Object front()

{

//return list.getFirst();

return list.peekFirst();

}

//判断队列是否为空

public boolean isEmpty()

{

return list.isEmpty();

}

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

LinkedListQueueTest llq=new LinkedListQueueTest();

System.out.println(llq.isEmpty());

llq.enqueue("147");

llq.enqueue("258");

llq.enqueue("369");

System.out.println(llq.size());

System.out.println("移除队列头元素："+llq.dequeue());

System.out.println(llq.size());

llq.enqueue("abc");

llq.enqueue("def");

System.out.println(llq.size());

System.out.println("查看队列的头元素："+llq.front());

System.out.println(llq.size());

System.out.println(llq.isEmpty());

}

}

通过数组实现

package 队列和堆栈;

import java.util.NoSuchElementException;

//通过数组来实现队列

public class ArrayQueue {

//字段

public static Object[] data;

//队列的元素个数

protected int size ;

//队列头

protected int head;

//队列尾

public static int tail;

/**

*

*/

//无参数构造函数

public ArrayQueue() {

final int INITIAL_LENGTH=3;

data=new Object[INITIAL_LENGTH];

size=0;

head=0;

tail=-1;

}

//队列元素个数方法

public int size()

{

return size;

}

public boolean isEmpty()

{

return size==0;

}

//得到队列头元素

public Object front()

{

if(size==0)

throw new NoSuchElementException();

return data[head];

}

//进入队列enqueue()方法

public void enqueue(Object obj)

{

//此时队列已经满

if(size==data.length){

Object[] oldData=data;

data=new Object[data.length*2];

//if(head==0)

System.arraycopy(oldData, head, data, 0, oldData.length-head);

if(head0)

System.arraycopy(oldData, 0, data, head+1, tail+1);

head=0;

tail=oldData.length-1;

}

tail=(tail+1)%data.length;

size++;

data[tail]=obj;

}

//队列的元素出队

public Object dequeue()

{

if(size==0)

throw new NoSuchElementException();

Object ele=data[head];

//循环队列

head=(head+1)%data.length;

size--;

return ele;

}

@Override

public String toString() {

// TODO Auto-generated method stub

return super.toString();

}

}

通过向量实现：

//通过向量实现栈

package 队列和堆栈;

import java.util.*;

public class VectorStackTest {

//字段

Vector v;

//构造函数

public VectorStackTest()

{

v=new Vector();

}

//元素的个数

public int size()

{

return v.size();

}

//是否为空

public boolean isEmpty()

{

return size()==0;

}

//进栈

public Object Push(Object obj)

{

v.addElement(obj);

return obj;

}

//出栈方法

public Object Pop()

{

int len=size();

Object obj=Peek();

v.removeElementAt(len-1);

return obj;

}

//查看栈顶元素

public Object Peek()

{

int len = size();

if (len == 0)

throw new EmptyStackException();

return v.elementAt(len - 1);

}

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

VectorStackTest vst=new VectorStackTest();

System.out.println("大小："+vst.size());

vst.Push("123");

vst.Push("456");

vst.Push("789");

vst.Push("abc");

System.out.println("大小："+vst.size());

System.out.println("栈顶："+vst.Peek());

System.out.println("出栈："+vst.Pop());

vst.Push("def");

vst.Push("147");

System.out.println("大小："+vst.size());

System.out.println("栈顶："+vst.Peek());

System.out.println("出栈："+vst.Pop());

System.out.println(vst.Peek());

vst.Push("def");

vst.Push("147");

System.out.println(vst.Pop());

System.out.println(vst.Pop());

System.out.println(vst.Peek());

System.out.println(vst.Pop());

System.out.println(vst.Pop());

vst.Push("1aadf");

vst.Push("2dafad");

vst.Push("123789");

System.out.println(vst.Pop());

System.out.println(vst.Peek());

System.out.println(vst.Pop());

System.out.println(vst.Peek());

System.out.println("------------------end------------");

VectorStackTest llst=new VectorStackTest();

llst.Push("123");

llst.Push("456");

System.out.println("栈顶："+llst.Peek());

System.out.println("出栈："+llst.Pop());

System.out.println(llst.Peek());

llst.Push("789");

llst.Push("abc");

System.out.println("栈顶："+llst.Peek());

System.out.println("出栈："+llst.Pop());

System.out.println(llst.size());

System.out.println("栈顶："+llst.Peek());

}

}

推荐：都看API文档。有疑问可以问我，QQ：285479197

Java设计一个名为Queue的类用于存储整数。像栈一样，队列具有元素。在栈中，元素以“后进先出”的方式

参考代码和注释如下

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

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 = elements.length) {// 数组扩容

int[] temp = new int[elements.length * 2];

System.arraycopy(elements, 0, temp, 0, elements.length);

elements = temp;

}

elements[size++] = v;

}

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

if (empty()) {

throw new RuntimeException("异常");

}

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

// 左移一位

// int[] temp = new int[elements.length];

// System.arraycopy(elements,1, temp, 0, elements.length-1);

// elements = temp;

// 左移一位

for (int i = 0; i  elements.length - 1; i++) {

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

}

elements[elements.length - 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

java任务队列限定长度的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java队列任务重复执行、java任务队列限定长度的信息别忘了在本站进行查找喔。

标签：