Java-如何比较泛型类型？

Question

这是通用二进制搜索树的代码。 现在，它可以完美运行并编译，但是在完成本课后，我才注意到一个问题。 问题在于，insert方法使用compareTo（）（在比较节点元素时）根据其值决定将下一个节点放置在树中的位置。 例如，输入：

1，112，2

而不是得到这棵树：

 1  
  \   
    2    
     \    
     112

我最终得到的是：

       1
         \
          2
         / 
        112

因为比较可能是按字典顺序进行的，所以它看到2> 112。

这是Tree类的代码：

import java.util.*;
import java.io.*;
import java.lang.*;

public class Tree<T extends Comparable<T>>
    { private Node<T> root = null;
    static String S="";

    public Tree()
        {File file=new File("date.in.txt");

            try 
            { Scanner input = new Scanner( file );
            while(input.hasNext())
                 insert((T)input.next());} 

            catch (FileNotFoundException ex) 
                { System.out.printf("ERROR: %s!\n", ex); } }


    public void show(){ printLevelOrder(maxDepth()); }

    public void printLevelOrder(int depth) 
        { for (int i = 1; i <= depth; i++) 
            { System.out.print("Level " + (i-1) + ": ");
            String levelNodes = printLevel(root, i);
            System.out.print(levelNodes + "\n"); } }

    public String printLevel(Node<T> t, int level) 
        { if (t == null) 
            return "";
        if (level == 1) 
            return t.element + " ";
         else if (level > 1) 
            { String leftStr = printLevel(t.left, level - 1);
            String rightStr = printLevel(t.right, level - 1);
            return leftStr + rightStr; }
        else 
          return ""; }


    int maxDepth(){ return maxDepth2(root); }

    int maxDepth2(Node<T> node) 
        { if (node == null) 
            return (0);
         else 
            { int leftDepth = maxDepth2(node.left);
            int rightDepth = maxDepth2(node.right);

            if (leftDepth > rightDepth )
                return (leftDepth + 1);
            else
                return (rightDepth + 1); } }


    public String toString(){ return this.InOrder(); }


    public String InOrder(){ inOrder2(root); return S; }

    public void inOrder2(Node<T> root) 
        { if(root !=  null)   
            { inOrder2(root.left);    
            S=S+root.element+" ";  
            inOrder2(root.right); } }


    public boolean insert(T element)  // I N S E R T    M E T H O D
        { if (isEmpty()) 
            { root = new Node<T>(element);
            return true; }

         Node<T> current = root; 
         Node<T> parent;         

         do 
            { parent = current;

             if (element.compareTo(current.element)<0) 
                 current = current.left; 
              else if (element.compareTo(current.element)>0) 
                 current = current.right; 
              else 
                 return false; } 
             while (current != null);

         Node<T> node = new Node<T>(element);


             if ( element.compareTo(parent.element)>0  ) 
                 parent.right = node;
          else 
             parent.left = node;

         return true; } 


    public boolean isEmpty() { return root == null; }


    private static class Node<T extends Comparable<T>>   
        { Node<T> left  = null;
        Node<T> right = null;
        final T element;

        Node(T element) { this.element = element; } } }

这是主要的：

import java.util.*;
import java.io.*;

public class Main 
    {public static void main(String[]args)
        {Tree <Double> T=new Tree<>(); } }

现在，我做了一些研究，并在这里和那里问了一些，我有点喜欢比较器，但是我以前还没有用过，所以我不确定如何实现它。 现在，如果您对如何解决此问题或添加/执行操作有任何解决方案，那么我就是耳目一新。

Answer 1

您的行insert((T)input.next()); 没道理input.next()是String ，但是您现在将其强制转换为T即使此时T与实际类型都不相关。 例如，在构造Tree ，调用者可以说new Tree<Integer>进行该行，本质上是insert((Integer)input.next()); ，它已损坏。

如果您的目标是让Tree始终包含String ，则只需从Tree删除通用T类型，然后使用String 。 如果您实际上想支持任意类型，则需要将文件读取行为移出Tree构造函数（例如，移到返回Tree<String>的静态方法中）。

例如：

public static Tree<String> readFromFile(Path file) throws FileNotFoundException {
  try (Scanner input = new Scanner(file)) {
    Tree<String> tree = new Tree<>();
    while(input.hasNext()) {
      tree.insert(input.next());
    }
    return tree;
  }
}

请注意，我使用Path而不是File ，使用try-with-resources模式，并且我不抑制异常，而是调用方（可能是main方法）应正确处理异常（可能是通过报告文件不存在）然后退出）。 或者像这样添加一个catch块：

catch (IOException e) {
  throw new RuntimeException("Could not open " + file, e);
}

避免强迫调用者处理该异常。

---

现在我们已经清理了Tree类型，您的订购问题可能更容易回答。 如果打算将元素排序为整数，则将输入转换为Integers，例如

public static Tree<Integer> readIntsFromFile(Path file) throws FileNotFoundException {
  ...
  tree.insert(Integer.valueOf(input.next()));
  ...
}

这将根据整数顺序而不是字符串的字典顺序对树进行排序。 这就是我建议你做的。 它很简单，可以做您想要的。

---

如果您确实想要Tree<String>但想要像整数一样对它们进行排序，则需要一个自定义的Comparator ，如上所述。 然后，您需要将Comparator传递到Tree的构造函数中，并在当前调用element.compareTo(current.element)地方调用element.compareTo(current.element) comparator.compare(element, current.element) element.compareTo(current.element) 。