Java 如何为实例成员编写compareTo？ 公共类Ch3Ex2{ 静态类节点{ 节点（对象值）{ 这个值=值； } 对象值；//需要此字段的比较器 节点下一步； } 静态类堆栈{ 节点顶部； 节点最小值； 无效推送（对象值）{ 节点=新节点（值）； if（Top==null）{ Min=节点； }否则{ Min=（Min.value

我不确定，但试试这个

让类实现

Comparable接口

，该接口提供了

compareTo

方法。然后，您可以在if语句中使用数字的值（-1表示较小，1表示较大，0表示相等）

如果你想把这些对象放在列表中（比如排序），你还应该@Override.equals方法

例如：

public class Ch3Ex2 {
static class Node {
    Node(Object value) {
        this.value = value;
    }
    Object value; // Comparator for this field required
    Node next;
}


static class Stack {
    Node Top;
    Node Min;
    void push(Object value) {
        Node node = new Node(value);
        if(Top == null) {
            Min = node;
        } else {
            Min = (Min.value < node.value) ? Min : node;  // Comparator Needed to be used here
        }
        node.next = Top;
        Top = node; 
    }

import java.util.compariable；
公共类BlockOffset实现可比较
{
私有整数块号；
私有整数偏移；
@凌驾
公共整数比较（块偏移量实例2）{
if（this.blockNumberinstance2.blockNumber）返回1；
if（this.offsetinstance2.offset）返回1；
返回0；
}   
}

---

有关更多详细信息，请查看链接。

我想您应该声明您的

节点

类，如：

import java.util.Comparable;

public class BlockOffset implements Comparable<BlockOffset>
{
   private int blockNumber;
   private int offset;

   @Override
   public int compareTo(BlockOffset instance2) {
   if (this.blockNumber < instance2.blockNumber) return -1;
   if (this.blockNumber > instance2.blockNumber) return 1;
   if (this.offset < instance2.offset) return -1;
   if (this.offset > instance2.offset) return 1;

   return 0;
 }   
}

更新

我认为你实际上要求的是：

class Stack<T extends Comparable<T> {
    Node<T> Top;
    Node<T> Min;
    void push(T value) {
        Node<T> node = new Node<T>(value);
        if(Top == null) {
            Min = node;
        } else {
            Min = Min.value.compareTo(node.value) < 0 ? Min : node;
        }
        node.next = Top;
        Top = node; 
    }
}

类节点{
T值；
节点下一步；
节点（T值）{
这个值=值；
}
}
类堆栈{
节点顶部；
节点最小值；
最终比较器值比较器；
公共堆栈（Comparator valueComparer）{this.valueComparer=valueComparer；}
无效推力（T值）{
节点=新节点（值）；
if（Top==null）{
Min=节点；
}否则{
最小值=值比较器。比较（最小值，节点值）<0？最小值：节点；
}
node.next=Top；
顶部=节点；
}
}

---

这意味着您的值类不需要实现

Comparable

，只要构建

堆栈的类知道如何通过传入比较值。
我看到的唯一逻辑方法是为我的节点类实现Comparable。只为“value”实例成员实现比较协议似乎不合逻辑。
问题是什么？您尝试了什么？我们知道
值所引用的对象的运行时类型吗？实际上，我需要根据它们的值比较两个节点对象，并且我想为实例成员“值”实现一个比较器。我知道我可以为类节点实现一个，但这不是我想要的ant为“value”实现Comparator。是否可能？让我们假设value的对象类型在运行时有字符串。
string
类已经实现了
Comparable
。我正在考虑一种只为实例成员“value”实现Comparator的方法。是否可能？是的，您可以这样做在。我编辑了我的答案并共享了一个链接，请参考。它可能会对您有所帮助。如果您愿意，您可以使用
节点
实现
可比
，并且
compareTo
方法将只检查
值
。但是，您仍然需要知道如何比较
值
。如果它仅作为对象键入，您只能使用
Object
上定义的方法对其进行比较，这可能不符合您的要求。我的回答的另一个选择是定义您自己的接口，该接口“value”将实现，该接口公开您可以用于比较的方法。如果我实现了节点的Compariable，那么我就可以按照我想要的方式比较两个节点对象。如果我st需要“值”的可比性。为此，我需要在对象类中实现可比性。如何定义它以便只影响“值”呢？我可以重写对象类方法来定义我自己的对象类副本，但这不是正确的方法。是否有某种方法可以使用匿名类来实现这一点？
class Stack<T extends Comparable<T> {
    Node<T> Top;
    Node<T> Min;
    void push(T value) {
        Node<T> node = new Node<T>(value);
        if(Top == null) {
            Min = node;
        } else {
            Min = Min.value.compareTo(node.value) < 0 ? Min : node;
        }
        node.next = Top;
        Top = node; 
    }
}

class Node<T> {
    T value;
    Node next;
    Node(T value) {
        this.value = value;
    }
}

class Stack<T> {
    Node<T> Top;
    Node<T> Min;
    final Comparator<T> valueComparer;
    public Stack(Comparator<T> valueComparer) { this.valueComparer = valueComparer; }
    void push(T value) {
        Node<T> node = new Node<T>(value);
        if(Top == null) {
            Min = node;
        } else {
            Min = valueComparer.compare(Min.value, node.value) < 0 ? Min : node;
        }
        node.next = Top;
        Top = node; 
    }
}