我遇到了Java内置的Collections.sort（）方法的问题。我正在尝试对名为TreeNode的自定义对象类型的ArrayList进行排序。我过去使用过这种方法并取得了成功，并希望看到外面看看我是否遗漏了任何明显的东西。
我想对这些TreeNode对象进行排序的方法是通过一个整数字段来调用myWeight，它是特定字符在文本文件中出现的次数的整数表示。在我的项目中，我使用一个名为TreeNode的自定义类和该类名为InternalNode和LeafNode的两个子类。这些节点用于构建用于编码文本文件的霍夫曼树。我已经确保所有这些都实现了Comparable并且我尝试了仅具有compareTo（）方法的父TreeNode类的变体，所有这些都具有相同的compareTo（）方法，我已经放弃了我的compareTo（）实现在其中使用Integer.compare（）方法，但没有骰子。
我也尝试过使用比较器并将其作为Collections.sort（）方法的参数传递，但也没有改变。
这是我试图调用排序并显示结果的地方：
private void generateHuffmanTreeTest(final HashMap<Character, Integer> theMap) {
ArrayList<TreeNode> sortedList = new ArrayList<TreeNode>();
System.out.println("Generating the Huffman Tree with new logic...");
for (Map.Entry<Character, Integer> entry : theMap.entrySet()) {
sortedList.add(new LeafNode(entry.getKey(), entry.getValue()));
}
Collections.sort(sortedList);
for (int i = 0; i < sortedList.size(); i++) {
LeafNode n = (LeafNode) sortedList.get(i);
System.out.println(n.myData + " " + n.myWeight);
}
以下是我正在尝试比较的对象类。
public class TreeNode implements Comparable<TreeNode> {
/** Left child of this node. */
public TreeNode myLeft;
/** Right child of this node. */
public TreeNode myRight;
/**
* Weight of all nodes branching from this one, or the weight
* of just this node if this node is a leaf.
*/
public int myWeight;
/**
* Default constructor. Should not be used to create pure
* TreeNode objects.
* No TreeNodes should be constructed, only InternalNodes
* and LeafNodes should comprise the tree.
*/
public TreeNode() {
}
/**
* Sets the left child of this node.
*
* @param theNode The node to become the left child.
*/
public void setLeft(final TreeNode theNode) {
myLeft = theNode;
}
/**
* Sets the right child of this node.
*
* @param theNode The node to become the right child.
*/
public void setRight(final TreeNode theNode) {
myRight = theNode;
}
/**
* Compares two TreeNodes based on their myWeight field.
*/
@Override
public int compareTo(TreeNode theOther) {
int result = 0;
if (myWeight < theOther.myWeight) result = -1;
if (myWeight > theOther.myWeight) result = 1;
return result;
}
}
public class InternalNode extends TreeNode implements Comparable<TreeNode> {
/**
* Creates a new InternalNode.
*/
public InternalNode() {
super();
}
/**
* Calculates the weight of both children from this Node.
*/
public void calcWeight() {
int result = 0;
if (myLeft != null) result = result + myLeft.myWeight;
if (myRight != null) result = result + myRight.myWeight;
myWeight = result;
}
/**
* Sets the left child of this node.
*
* @param theNode The child to be set.
*/
public void setLeft(final TreeNode theNode) {
myLeft = theNode;
}
/**
* Sets the right child of this node.
*
* @param theNode The child to be set.
*/
public void setRight(final TreeNode theNode) {
myRight = theNode;
}
/**
* Compares two TreeNodes based on their myWeight field.
*/
@Override
public int compareTo(TreeNode theOther) {
int result = 0;
if (myWeight < theOther.myWeight) result = -1;
if (myWeight > theOther.myWeight) result = 1;
return result;
}
}
public class LeafNode extends TreeNode implements Comparable<TreeNode> {
/** Char value for this node to hold. */
public char myData;
/** Weight value of the char this node holds. */
public int myWeight;
/**
* Creates a new LeafNode that contains a char value for it to
* hold as well as a weight value that is equal to the number
* of times that character appears in the target String.
*
* @param theData The char value for this node to hold.
* @param theWeight The frequency of the char value in the text.
*/
public LeafNode(final char theData, final int theWeight) {
super();
myData = theData;
myWeight = theWeight;
}
/**
* Compares two TreeNodes based on their myWeight field.
*/
@Override
public int compareTo(TreeNode theOther) {
int result = 0;
if (myWeight < theOther.myWeight) result = -1;
if (myWeight > theOther.myWeight) result = 1;
return result;
}
}
编辑***如果我发布了这个东西的输出，也许会有所帮助。 这是我从我读过的文本文件中运行此代码时得到的结果：
65007
514908
! 3923
" 17970
# 1
$ 2
% 1
' 7529
( 670
) 670
* 300
, 39891
- 6308
. 30806
/ 29
0 179
1 392
2 147
3 61
4 23
5 55
6 57
7 40
8 193
9 35
: 1014
; 1145
= 2
? 3137
@ 2
A 6574
B 3606
C 2105
D 2017
E 2259
F 1946
G 1303
H 4378
I 7931
J 308
K 1201
L 713
M 3251
N 3614
O 1635
P 6519
Q 35
R 3057
S 2986
T 6817
U 254
V 1116
W 2888
X 673
Y 1265
Z 108
[ 1
] 1
à 4
a 199232
b 31052
c 59518
d 116273
ä 1
e 312974
f 52950
g 50023
h 163026
i 166350
é 1
j 2266
ê 11
k 19230
l 95814
m 58395
n 180559
o 191244
p 39014
q 2295
r 145371
s 159905
t 219589
u 65180
v 25970
w 56319
x 3711
y 45000
z 2280
1
答案 0 :(得分：3)
您遇到的问题是您已在myWeight和TreeNode中定义了LeafNode。因此，myWeight方法使用的compareTo变量可能与LeafNode构造函数写入的变量不同，并且在您打印LeafNode.myWeight时写出。
您可能只想从myWeight删除LeafNode的重复定义。
请参阅此处有关变量隐藏的部分：https://dzone.com/articles/variable-shadowing-and-hiding-in-java
答案 1 :(得分：1)
您可以使用Comparator<TreeNode>。这样，如果您向TreeNode类添加字段，则可以实现不同的比较器并将其传递给Collections.sort()方法。但是，默认情况下，如果您仍希望它们为Comparable，则可以使用默认的compareTo()方法保留它们：
输出：
[1, 5, 6, 0, 1, 0, 8, 3, 7, 4]
[0, 0, 1, 1, 3, 4, 5, 6, 7, 8]
树节点：
public static class TreeNode implements Comparable<TreeNode> {
public TreeNode(int weight) {
this.myWeight = weight;
}
public int myWeight;
public String toString() {
return "" + myWeight;
}
@Override
public int compareTo(TreeNode o) {
int val = 0;
if (myWeight > o.myWeight) {
val = 1;
} else if (myWeight < o.myWeight){
val = -1;
}
return val;
}
}
比较器，用于排序：
public static class TreeNodeComparator implements Comparator<TreeNode> {
// Sorts by default `compareTo()`, You can always change this
// If you want to sort by another property
@Override
public int compare(TreeNode o1, TreeNode o2) {
return o1.compareTo(o2);
}
}
主：
public static void main(String[] args) throws Exception {
java.util.ArrayList<TreeNode> nodes = new java.util.ArrayList<>();
for (int i = 10; i > 0; i--) {
int val = ThreadLocalRandom.current().nextInt(0, 10);
TreeNode node = new TreeNode(val);
nodes.add(node);
}
System.out.println(nodes);
Collections.sort(nodes, new TreeNodeComparator());
System.out.println(nodes);
}
答案 2 :(得分：1)
您可以创建一个实现Comparator接口的单独类，并覆盖compare方法，如下所示：
public class SortByWeight implements Comparator<TreeNode> {
@Override
public int compare(TreeNode o1, TreeNode o2) {
return o1.myWeight - o2.myWeight;
}
}
然后在方法中进行比较时，创建比较器的新实例。
ArrayList<TreeNode> sortedList = new ArrayList<TreeNode>();
System.out.println("Generating the Huffman Tree with new logic...");
TreeNode t = new TreeNode();
t.myWeight = 2;
TreeNode r = new TreeNode();
r.myWeight = 5;
TreeNode q = new TreeNode();
q.myWeight = 1;
sortedList.add(t);
sortedList.add(r);
sortedList.add(q);
//new comparator here
Collections.sort(sortedList, new SortByWeight());
for (int i = 0; i < sortedList.size(); i++) {
System.out.println(sortedList.get(i).myWeight);
}
这是
的输出1
2
5
希望它有所帮助。