泛型类

zsxxn

java编程完成泛型类CircularQueue（循环队列），CircularQueue的基本功能设计要求：创建循环队列、入队、出队、获取队头元素、判队空、获取队列元素个数。

isdkz

1. public class CircularQueue<T> {
   
2.     private int front;
   
3.     private int rear;
   
4.     private int size;
   
5.     private int capacity;
   
6.     private T[] elements;
   
7. 
   
8.     public CircularQueue(int capacity) {
   
9.         this.capacity = capacity;
   
10.         this.elements = (T[]) new Object[capacity];
    
11.         this.front = 0;
    
12.         this.rear = 0;
    
13.         this.size = 0;
    
14.     }
    
15. 
    
16.     public void enqueue(T element) {
    
17.         if (size == capacity) {
    
18.             throw new IllegalStateException("Queue is full");
    
19.         }
    
20.         elements[rear] = element;
    
21.         rear = (rear + 1) % capacity;
    
22.         size++;
    
23.     }
    
24. 
    
25.     public T dequeue() {
    
26.         if (size == 0) {
    
27.             throw new IllegalStateException("Queue is empty");
    
28.         }
    
29.         T element = elements[front];
    
30.         elements[front] = null;
    
31.         front = (front + 1) % capacity;
    
32.         size--;
    
33.         return element;
    
34.     }
    
35. 
    
36.     public T getFront() {
    
37.         if (size == 0) {
    
38.             throw new IllegalStateException("Queue is empty");
    
39.         }
    
40.         return elements[front];
    
41.     }
    
42. 
    
43.     public boolean isEmpty() {
    
44.         return size == 0;
    
45.     }
    
46. 
    
47.     public int size() {
    
48.         return size;
    
49.     }
    
50. }
    

复制代码

这段代码定义了一个泛型类CircularQueue，实现了循环队列的基本功能。循环队列通过数组实现，使用front和rear指针分别指向队头和队尾，size记录队列中元素的个数。在入队enqueue操作中，首先判断队列是否已满，然后将元素添加到rear指向的位置，并更新rear指针和size；在出队dequeue操作中，首先判断队列是否为空，然后取出front指向的元素，更新front指针和size。获取队头元素getFront、判队空isEmpty和获取队列元素个数size操作则比较简单，直接根据相应的条件进行判断或返回相应的值。

Mike_python小

当然，以下是一个简单的泛型类CircularQueue的实现，满足上述的基本功能设计要求：

[/code]java
import java.util.NoSuchElementException;

public class CircularQueue<T> {
    private Object[] queue;
    private int head;
    private int tail;
    private int size;
    private int capacity;

    public CircularQueue(int capacity) {
        this.capacity = capacity;
        queue = new Object[capacity];
        head = 0;
        tail = 0;
        size = 0;
    }

    public void enqueue(T item) {
        if (size == capacity) {
            throw new IllegalStateException("Queue is full");
        }
        queue[tail] = item;
        tail = (tail + 1) % capacity;
        size++;
    }

    public T dequeue() {
        if (size == 0) {
            throw new NoSuchElementException("Queue is empty");
        }
        T item = (T) queue[head];
        head = (head + 1) % capacity;
        size--;
        return item;
    }

    public T peek() {
        if (size == 0) {
            throw new NoSuchElementException("Queue is empty");
        }
        return (T) queue[head];
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }
}
[/code]

这个泛型类CircularQueue实现了循环队列的基本功能，包括创建循环队列、入队、出队、获取队头元素和判队空、获取队列元素个数。你可以根据这个基础上进行进一步扩展和优化。希望这个例子能够帮助你完成泛型类CircularQueue的基本功能设计。

liuhongrun2022

我们可以根据你的需求创建一个泛型的循环队列类。下面是泛型类CircularQueue的一个基本实现：

1. public class CircularQueue<T> {
2.     private T[] queue;
3.     private int head;
4.     private int tail;
5.     private int size;
7.     @SuppressWarnings("unchecked")
8.     public CircularQueue(int capacity) {
9.         queue = (T[]) new Object[capacity];
10.         head = 0;
11.         tail = 0;
12.         size = 0;
13.     }
14.    
15.     public boolean enqueue(T element) {
16.         if (size == queue.length) {
17.             return false; // 队列已满
18.         }
19.         queue[tail] = element;
20.         tail = (tail + 1) % queue.length;
21.         size++;
22.         return true;
23.     }
25.     public T dequeue() {
26.         if (size == 0) {
27.             return null; // 队列为空
28.         }
29.         T result = queue[head];
30.         head = (head + 1) % queue.length;
31.         size--;
32.         return result;
33.     }
35.     public T getFront() {
36.         if (size == 0) {
37.             return null; // 队列为空
38.         }
39.         return queue[head];
40.     }
42.     public boolean isEmpty() {
43.         return size == 0;
44.     }
46.     public int getSize() {
47.         return size;
48.     }
49. }

复制代码

这个泛型类包含了以下方法：

- CircularQueue(int capacity): 创建指定容量的循环队列。
- enqueue(T element): 将元素添加到队列末尾，如果队列已满，返回false。
- dequeue(): 从队列头部删除元素并返回，如果队列为空，返回null。
- getFront(): 返回队列头部的元素，如果队列为空，返回null。
- isEmpty(): 判断队列是否为空，如果为空，返回true。
- getSize(): 返回队列中元素的个数。

请注意，这个循环队列的容量是固定的，如果你需要动态扩容的循环队列，需要进行适当的修改。