Java 使用从文件读取时，如何对类泛型类型进行排序

我有这个类，我从文件中读取数据，我的程序是添加单词，我计算每个单词，例如： （WData{word=success，count=1}WData{word=automata，count=1}Data{word=theory，count=2}）如何对输出进行排序并从字符A到Z开始我指的是单词和。这是我的密码 Sa类

    class SA:
public class SA<T> {
int head;
int size;
T[] nodes;
public SA(int maxsize) {
head = 0;
nodes = (T[]) new Object[maxsize];
size = 0;
}
public int size() {
return size;}
public boolean empty() {
return size == 0;
   public void insert(T e) {
   nodes[size] = e;
 size++;
 }
 public T find(T s) {

if (size != 0) {
for (int i = 0; i < size; i++) {
    if (nodes[i].equals(s)) {
        return nodes[i];
    }
}
 }
  return null;
  }
  public void display() {
 for (int i = 0; i < size; i++) {
  System.out.println(nodes[i].toString());
  }}}

SA级：
公共类SA{
int头；
整数大小；
T[]节点；
公共SA（int maxsize）{
水头=0；
节点=（T[]）新对象[maxsize]；
尺寸=0；
}
公共整数大小（）{
返回大小；}
公共布尔空（）{
返回大小==0；
公共空白插入（T e）{
节点[大小]=e；
大小++；
}
公共找不到（TS）{
如果（大小！=0）{
对于（int i=0；i

下面是类TextAnalyzer：

Public class TextAnalyzer<T> {
private static class WData {

@Override
public int hashCode() {
int hash = 7;
hash = 71 * hash + Objects.hashCode(this.word);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
    return true;
}
if (obj == null) {
    return false;
}
if (getClass() != obj.getClass()) {
    return false;
}
final WData other = (WData) obj;
if (!Objects.equals(this.word, other.word)) {
    return false;
}
return true;
}

String word;
int count;

public WData(String w, int f) {
 word = w;
 count = f;
 }
@Override
public String toString() {
return "WData{" + "word=" + word + ", count=" + count + '}';
}

} SA<WData>list;
public TextAnalyzer() {
list=new SA<WData>(11000); 
}
public void processText(String filename) {
long count = 0;
try {

Scanner sc = new Scanner(new File(filename));;

while (sc.hasNext()) {
    String line = sc.next();
    String st = line.replaceAll("[^a-zA-Z ]", "").toLowerCase();

    processWord(st);}
  list.display();

} catch (FileNotFoundException ex) {
System.out.println("There are error in processText");
}
}
public void processWord(String word) {
WData w = new WData(word, 1);
WData s = list.find(w);
if (s == null) {

list.insert(w);

 } else {
s.count = s.count + 1;
}}}

公共类文本分析器{
私有静态类WData{
@凌驾
公共int hashCode（）{
int hash=7；
hash=71*hash+Objects.hashCode（this.word）；
返回散列；
}
@凌驾
公共布尔等于（对象obj）{
if（this==obj）{
返回true；
}
if（obj==null）{
返回false；
}
如果（getClass（）！=obj.getClass（））{
返回false；
}
最终WData其他=（WData）obj；
如果（！Objects.equals（this.word，other.word））{
返回false；
}
返回true；
}
字符串字；
整数计数；
公共WData（字符串w，整数f）{
字=w；
计数=f；
}
@凌驾
公共字符串toString（）{
返回“WData{”+“word=“+word+”，count=“+count+'}”；
}
}萨利斯特；
公共文本分析器（）{
列表=新SA（11000）；
}
public void processText（字符串文件名）{
长计数=0；
试一试{
Scanner sc=新扫描仪（新文件（文件名））；；
while（sc.hasNext（））{
字符串行=sc.next（）；
字符串st=line.replaceAll（“[^a-zA-Z]”，“”）。toLowerCase（）；
进程字（st）；}
list.display（）；
}捕获（FileNotFoundException ex）{
System.out.println（“processText中存在错误”）；
}
}
公共空处理字（字符串字）{
WData w=新的WData（字，1）；
WData s=列表。查找（w）；
如果（s==null）{
列表。插入（w）；
}否则{
s、 计数=s.count+1；
}}}

泛型类型的可能副本

T

必须扩展/实现

Comparable

接口如何创建Comparable接口？接口内部应该写些什么如果您想使用该解决方案，您的类将需要限制

T

泛型类型的使用，以始终实现

Comparable接口e

。稍后，当您想使用类时，要排序的对象类需要实现

Comparable

接口，因此实现

Comparable

的类将能够显式使用与它们进行比较的字段。