在Java中，如何为扩展comparator的类实现多个comparator方法？

我有一个通用的AVL树实现，Node类扩展了comparator，我希望将一个对象作为节点传递，并能够选择comparator将与之进行比较的属性

我的对象的类实现并重写了comparator方法，但我已经硬编码了用于比较的属性

我尝试过的事情：

• 创建多个comparator方法，但我只能用其中一个覆盖comparator
• 重载比较器方法，也不起作用

做这件事最好的方法是什么

我的节点类：

package compare;

import java.util.Comparator;

public class Node<T extends Comparator<T>>  { 
    int depth;
    int level;
    Node<T> left, right; 
    T data;
  
    Node(T data) { 
        this(data, null, null);
    } 
    
    Node(T data, Node<T> left, Node<T> right){
        super();
        this.data = data;
        this.left = left;
        this.right = right;
        
        if (left == null && right == null)
            setDepth(1);
        else if (left == null)
            setDepth(right.getDepth() + 1);
        else if (right == null)
            setDepth(left.getDepth() + 1);
        else
            setDepth(Math.max(left.getDepth(), right.getDepth()) + 1);
    }
    
    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Node<T> getLeft() {
        return left;
    }

    public void setLeft(Node<T> left) {
        this.left = left;
    }

    public Node<T> getRight() {
        return right;
    }

    public void setRight(Node<T> right) {
        this.right = right;
    }

    /**
     * @return the depth
     */
    public int getDepth() {
        return depth;
    }
    
    /**
     * @param depth
     *            the depth to set
     */
    public void setDepth(int depth) {
        this.depth = depth;
    }

    public int comp(Node<T> o, T o2) {
        return this.data.compare(o.getData(),o2);
    }
    

    @Override
    public String toString() {
        return "Level " + level + ": " + data;
    }
    
    
}

包比较；
导入java.util.Comparator；
公共类节点{
智力深度；
智力水平；
左、右淋巴结；
T数据；
节点（T数据）{
这（数据，空，空）；
} 
节点（T数据、左节点、右节点）{
超级（）；
这个数据=数据；
this.left=左；
这个。右=右；
if（left==null&&right==null）
设置深度（1）；
else if（left==null）
setDepth（right.getDepth（）+1）；
else if（right==null）
setDepth（left.getDepth（）+1）；
其他的
setDepth（Math.max（left.getDepth（），right.getDepth（））+1）；
}
公共T getData（）{
返回数据；
}
公共无效设置数据（T数据）{
这个数据=数据；
}
公共节点getLeft（）{
左转；
}
公共void setLeft（节点左侧）{
this.left=左；
}
公共节点getRight（）{
返还权；
}
公共无效设置权限（节点权限）{
这个。右=右；
}
/**
*@返回深度
*/
公共int getDepth（）{
返回深度；
}
/**
*@param深度
*设置的深度
*/
公共void setDepth（int-depth）{
这个。深度=深度；
}
公共内部组件（节点o，T o2）{
返回此.data.compare（o.getData（），o2）；
}
@凌驾
公共字符串toString（）{
返回“级别”+级别+”：“+数据；
}
}

AVL树类：

    package compare;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.Queue;
class AVLTree<T extends Comparator<T>> {
    
    Node<T> root;
    AVLTree(){
        root = null;
    }
        
    T Maximum() {
        Node<T> local = root;
        if (local == null)
            return null;
        while (local.getRight() != null)
            local = local.getRight();
        return local.getData();
    }
    
    T Minimum() {
        Node<T> local = root;
        if (local == null)
            return null;
        while (local.getLeft() != null) {
            local = local.getLeft();
        }
        return local.getData();
    }
    
    private int depth(Node<T> node) {
        if (node == null)
            return 0;
        return node.getDepth();
    }
    
    Node<T> insert(T data) {
         
            root = insert(root, data);
            switch (balanceNumber(root)) {
            case 1:
                root = rotateLeft(root);
                break;
            case -1:
                root = rotateRight(root);
                break;
            default:
                break;
            }
            
        return root;        
    }
    
    Node<T> insert(Node<T> node, T data) {
        if (node == null)
            return new Node<T>(data);
        if (node.comp(node,data)>0) {
            node = new Node<T>(node.getData(), insert(node.getLeft(), data), node.getRight());
        } else if (node.comp(node,data)<0) {
            node = new Node<T>(node.getData(), node.getLeft(), insert(node.getRight(), data));
        }
        // After insert, balance tree.
        switch (balanceNumber(node)) {
        case 1:
            node = rotateLeft(node);
            break;
        case -1:
            node = rotateRight(node);
            break;
        default:
            return node;
        }
        return node;
    }
    
    
    
    
    private int balanceNumber(Node<T> node) {
        int L = depth(node.getLeft());
        int R = depth(node.getRight());
        if (L - R >= 2)
            return -1;
        else if (L - R <= -2)
            return 1;
        return 0;
    }
    
    private Node<T> rotateLeft(Node<T> node) {
        Node<T> q = node;
        Node<T> p = q.getRight();
        Node<T> c = q.getLeft();
        Node<T> a = p.getLeft();
        Node<T> b = p.getRight();
        q = new Node<T>(q.getData(), c, a);
        p = new Node<T>(p.getData(), q, b);
        return p;
    }

    private Node<T> rotateRight(Node<T> node) {
        Node<T> q = node;
        Node<T> p = q.getLeft();
        Node<T> c = q.getRight();
        Node<T> a = p.getLeft();
        Node<T> b = p.getRight();
        q = new Node<T>(q.getData(), b, c);
        p = new Node<T>(p.getData(), a, q);
        return p;
    }
    
    public boolean search(T data) {
        Node<T> local = root;
        while (local != null) {
            if (local.getData().compare(local.getData(), data) == 0)
                return true;
            else if (local.getData().compare(local.getData(), data) > 0)
                local = local.getLeft();
            else
                local = local.getRight();
        }
        return false;
    }
    
    public String toString() {
        return root.toString();
    }
    
    public void PrintTree() {
        root.level = 0;
        Queue<Node<T>> queue = new LinkedList<Node<T>>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node<T> node = queue.poll();
            System.out.println(node);
            int level = node.level;
            Node<T> left = node.getLeft();
            Node<T> right = node.getRight();
            if (left != null) {
                left.level = level + 1;
                queue.add(left);
            }
            if (right != null) {
                right.level = level + 1;
                queue.add(right);
            }
        }
    }
    
    
}

包比较；
导入java.util.Comparator；
导入java.util.LinkedList；
导入java.util.Queue；
类AVLTree{
节根；
AVLTree（）{
root=null；
}
T最大值（）{
节点本地=根；
if（local==null）
返回null；
while（local.getRight（）！=null）
local=local.getRight（）；
返回local.getData（）；
}
T最小值（）{
节点本地=根；
if（local==null）
返回null；
while（local.getLeft（）！=null）{
local=local.getLeft（）；
}
返回local.getData（）；
}
专用整数深度（节点）{
if（node==null）
返回0；
返回node.getDepth（）；
}
节点插入（T数据）{
根=插入（根，数据）；
开关（平衡编号（根））{
案例1：
根=旋转英尺（根）；
打破
案例1：
根=旋转右（根）；
打破
违约：
打破
}
返回根；
}
节点插入（节点，T数据）{
if（node==null）
返回新节点（数据）；
如果（节点组件（节点，数据）>0）{
node=新节点（node.getData（），insert（node.getLeft（），data），node.getRight（））；
}else if（node.comp（node，data）=2）
返回-1；
else if（L-r0）
local=local.getLeft（）；
其他的
local=local.getRight（）；
}
返回false；
}
公共字符串toString（）{
返回root.toString（）；
}
公共void printree（）{
root.level=0；
Queue Queue=new LinkedList（）；
添加（根）；
而（！queue.isEmpty（））{
Node=queue.poll（）；
System.out.println（节点）；
int-level=node.level；
Node left=Node.getLeft（）；
Node right=Node.getRight（）；
if（左！=null）{
left.level=level+1；
queue.add（左）；
}
if（右！=null）{
right.level=level+1；
queue.add（右）；
}
}
}
}

驱动程序代码：

public static void main(String[] args) throws IOException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
        // TODO Auto-generated method stub

        String pathToCsv = "data_tiny.csv";
        ArrayList<HDTestData<?>> HDlist = readFromCSV(pathToCsv);

        AVLTree<HDTestData<?>> tree1 = new AVLTree<>();
        
        
        for(int i=0; i<HDlist.size(); i++) {
//          adding elements to tree
            tree1.insert(HDlist.get(i));
        }
        
        tree1.PrintTree();

}  

publicstaticvoidmain（String[]args）抛出IOException、NoSuchFieldException、SecurityException、IllegalArgumentException、IllegalAccessException{
//TODO自动生成的方法存根
字符串pathtosv=“data\u tiny.csv”；
ArrayList>tree1=新的AVLTree（）；
对于（int i=0；itwo）{
返回1；
}
如果（一=二）{
返回0；
}
返回-1；
}
@凌驾
公共字符串toString（）{
字符串输出=this.serial+”，“+this.model+”，“+this.capacity+”，“+this.powerOnHours；
返回输出；
}
公共字符串getSerial（）{
返回序列号；
}
公共无效设置序列（字符串序列）{
this.serial=serial；
}
公共字符串getModel（）{
收益模型；
}
公共void集合模型（字符串模型）{
this.model=模型；
}
公共字符串getCapacity（）{
返回能力；
}
公共空间设置容量（字符串容量）{
这个。容量=容量；
}
公共字符串getPowerOnHours（）{
返回开机时间；
}
公共无效设置powerOnHours（字符串powerOnHours）{
this.powerOnHours=powerOnHours；
}
}

我的HDtestData中的compare方法是通过“PowerOnHours”进行比较的，我希望在构建AVLTree对象时能够选择它正在使用的属性。

package compare;

import java.util.Comparator;

public class HDTestData<T> implements Comparator<HDTestData<T>>{
    String serial, model, capacity, powerOnHours;
    
    HDTestData (String serial, String model, String capacity, String powerOnHours){
        this.serial = serial;
        this.model = model;
        this.capacity = (capacity);
        this.powerOnHours = (powerOnHours);
    }
    
    @Override
    public int compare(HDTestData<T> o1,HDTestData<T> o2) {
        int one = Integer.parseInt(o1.powerOnHours);
        int two = Integer.parseInt(o2.powerOnHours);

        if(one>two) {
            return 1;
        }
        if(one == two) {
            return 0;
        }
        return -1;
    }

    
      @Override
      public String toString() {
          String output = this.serial+", "+this.model+", "+this.capacity+", "+this.powerOnHours;
        return output;
      }
      

    public String getSerial() {
        return serial;
    }

    public void setSerial(String serial) {
        this.serial = serial;
    }

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public String getCapacity() {
        return capacity;
    }

    public void setCapacity(String capacity) {
        this.capacity = capacity;
    }

    public String getPowerOnHours() {
        return powerOnHours;
    }

    public void setPowerOnHours(String powerOnHours) {
        this.powerOnHours = powerOnHours;
    }
      
      

}

Comparator<HDTestData> p = Comparator.comparing( t -> Integer.valueOf(t.getPowerOnHours()));
Comparator<HDTestData> s = Comparator.comparing( HDTestData::getSerial );

class AVLTree<T, Comparator<T>> {
    Node<T> root;
    Comparator<T> comp;
    AVLTree( Comparator<T> aComp ){
        comp = aComp;
    }
...
    Node<T> insert(Node<T> node, T data) {
    if (comp.compare(node.getData(),data)>0) {
...