用嵌套在另一个扩展Comparable的类中的类重写compareTo方法

Question

我的任务是用Java编写自己的PriorityQueue类。它基于LinkedLists。引用指示：

存储在节点中的数据类型应该是可比较的泛型类型。这是为类声明编写的：public class PriorityQueue(E扩展Comparable((->注意：大括号的意思是<>，我在<>之间写的任何内容正在消失。。。

我将使用PriorityQueue编写另外两个类，一个是patient类型，另一个是waitingRoom类型。这就是compareTo方法的作用所在，因为我将这两个类排序到它们各自的PriorityQueues中。

我一直在PriorityQueue类本身内部定义ListNode类，所以我在一个类中有一个类。现在问题来了：

我将在哪里实现/覆盖从Comparable继承的compareTo方法？

它无法在PriorityQueue类中实现，因为compareTo只能接受一个参数。然而，这似乎是它应该去的地方，因为这是扩展Comparable的实际类。

如果我在ListNode类中实现它，那么，我不知道该如何实现。我要把ListNode变成一个接口吗？抽象课堂？

下面是我写的相当新手的代码，感谢的帮助

package hostpitalQueue;
import java.util.AbstractList;
public class PriorityQueue<E extends Comparable<E>>  {
private ListNode front;
public PriorityQueue() {
front = null;
}
public PriorityQueue(ListNode n1) {
front = n1;
}

//method for addingNode to beginning, 
//perhaps overload method for next nodes?
public void addNode(ListNode n1) {
if(front == null) {
front = n1;
}else {
//need to find last node and add n1 to it
ListNode lastNode = findLastNode(n1);
lastNode.addNode(n1);
}
}

//need to compare, remember, this is a priorityqueue
public ListNode findLastNode(ListNode n) {
//compare the data of both
//compare to front
ListNode n1 = front;
int i = n1.compareTo(n);
//only do something here if n is higher priority
if(i > 0) {
E frontData = n1.data;
E nodesData = n.data;
ListNode holder = n1;
front = n;
n.next = holder;
holder.previous = n;
}else if(n1.next == null) {
n1.next = n;
n.previous = n1;
}
else {
while(front.next != null) {
n1 = front.next;
//is n1 a higher priority?
Integer ii = n1.compareTo(n);
if(ii > 0) {
//this means that we should return the previous node, to insert
//before this one
return n1.previous;
}
}
}
return n1;
}

public class ListNode  {
//contains a left and a right, as well as a data field
public E data;
public ListNode previous,next;

//construct
public ListNode() {
data = null;
previous = null;
next = null;
}
//previous to next
public ListNode(E data) {
this.data = data;
previous = null;
next = null;
}
public ListNode(E data,ListNode n1) {
this.data = data;
previous = n1;
next = null;
}
public ListNode(E data,ListNode n1,ListNode n2) {
this.data = data;
previous = n1;
next = n2;
}
public void addNode(ListNode n1) {
//gotta check if my next is null
ListNode holder = null;
if(this.next != null) {
holder = this.next;
}
this.next = n1;
n1.previous = this;
n1.next = holder;
}
public int compareTo(ListNode n1) {
return 0;
}
public void printMe() {
System.out.println(this.data);
}
}



}

Answer 1

将用作PriorityQueue元素类型的每个类都必须实现Comparable接口和compareTo方法。

请注意，由于ListNode类实现了compareTo方法，因此可以使其实现Comparable<ListNode>:

public class ListNode implements Comparable<ListNode>  {

@Override
public int compareTo(ListNode n1) {
return data.compareTo(n1.data);
}

注意，由于ListNode类不依赖于PriorityQueue的实例，因此可以将其设为static；在这种情况下，您必须声明一个通用参数：

public static class ListNode<T extends Comparable<T>>
implements Comparable<ListNode<T>>  {
//contains a left and a right, as well as a data field
public T data;
public ListNode<T> previous,next;

//construct
public ListNode() {
data = null;
previous = null;
next = null;
}
//previous to next
public ListNode(T data) {
this.data = data;
previous = null;
next = null;
}
public ListNode(T data,ListNode<T> n1) {
this.data = data;
previous = n1;
next = null;
}
public ListNode(T data,ListNode<T> n1,ListNode<T> n2) {
this.data = data;
previous = n1;
next = n2;
}
public void addNode(ListNode<T> n1) {
//gotta check if my next is null
ListNode<T> holder = null;
if(this.next != null) {
holder = this.next;
}
this.next = n1;
n1.previous = this;
n1.next = holder;
}
@Override
public int compareTo(ListNode<T> n1) {
return data.compareTo(n1.data);
}
public void printMe() {
System.out.println(this.data);
}
}

类ListNode有字段，所以不能将其更改为接口(你到底为什么要这么做？(

也许你应该问问自己，你是否真的需要一个双链接列表，一个单链接列表是否不够。

您的问题中不清楚您是否需要实现链表，或者您是否可以使用类LinkedList，在这种情况下，您不需要ListNode类：PriorityQueue只封装一个LinkedList<E>。

Answer 2

如果您想比较两个ListNodes，如行中所示：

n1.compareTo(n)

你需要让它实现Comparable:

public class ListNode implements Comparable<ListNode> {

并将compareTo方法实现为类似的方法

return this.data.compareTo(that.data);

(因为您知道data就是Comparable(。但是您必须处理空数据的情况。

---

注意，您还应该将顶级类上的类型变量声明为：

<E extends Comparable<? super E>>