未选中的方法'；排序（列表<；T>；）&x27；Java11中的泛型调用

我有三个类叫做

League

，

Team

和

Player

，League有一个包含团队的数组，我有一个方法叫做

showLeagueTable

，它显示按

排名排序的团队（这是
团队
类中存在的一个方法），而class团队有一个球员数组

League.java

公共阶级联盟{
公共字符串名称；
私有列表团队=新的ArrayList（）；
公共联盟（字符串名称）{
this.name=名称；
}
公共布尔加法（T组）{
if（团队包含（团队））{
返回false；
}
返回团队。添加（团队）；
}
公共空间展示联盟表（）{
Collections.sort（this.teams）；
对于（T：团队）{
System.out.println（t.getName（）+“：”+t.ranking（））；
}
}
}

Team.java

公共类团队实现了可比较的{
私有字符串名称；
int=0；
整数=0；
int lost=0；
int=0；
私有ArrayList成员=新ArrayList（）；
公共团队（字符串名称）{
this.name=名称；
}
公共字符串getName（）{
返回名称；
}
公共布尔addPlayer（T播放器）{
如果（成员包含（玩家））{
System.out.println（player.getName（）+“已在此团队中”）；
返回false；
}否则{
成员。添加（玩家）；
System.out.println（player.getName（）+“为团队挑选”+此.name）；
返回true；
}
}
公共int numPlayers（）{
返回此.members.size（）；
}
公开无效的比赛结果（团队对手、内线得分、内线得分）{
字符串消息；
如果（我们的分数>他们的分数）{
韩元++；
message=“beat”；
}否则如果（我们的分数==他们的分数）{
绑定++；
message=“使用绘制”；
}否则{
丢失的++；
message=“丢失到”；
}
播放++；
如果（对手！=null）{
System.out.println（this.getName（）+message+opporter.getName（））；
对手。匹配结果（空，他们的核心，我们的分数）；
}
}
公共int排名（）{
回报（韩元*2）+平局；
}
@凌驾
公共int比较（团队）{
返回整数.compare（team.ranking（），this.ranking（））；
}
}

Player.java

公共类播放器{
私有字符串名称；
公共播放器（字符串名称）{
this.name=名称；
}
公共字符串getName（）{
返回名称；
}
}

但是在行
Collections.sort（this.teams）中
从类
League
中，我得到了警告
未检查的方法“sort（List）”调用，我读到可能问题在于我没有在我的类团队中使用类型实现可比较的接口，但我做到了。您可以在第行看到它：

公共类团队实现了可比较的

有人能帮帮我吗，谢谢
 这里有一个针对您的特定问题的完全可行的代码：

它将删除警告和错误。

第1阶段：消除类似行为

阶段2：在没有警告的情况下尝试编译

第3阶段：尝试真正的新分配：重要，因为如果您不做任何新的操作，就不会使用T泛型，并且您无法检测错误。

阶段4：添加可比较的行为

最终来源[见A）B）和C）来源错误]

League.java
Test.java
可能重复的
联盟
<代码>团队
缺少其泛型类型。请将此作为答案发布@Tom@VinayPrajapati这个问题是重复的，我们应该关闭它，而不是重复回答。谢谢@Tom，因此我已更改为
，这将删除警告！为什么要向菱形运算符添加泛型类型？这些都是多余的。同样，重复大量未更改的代码只会增加这个答案和这个，这个问题是重复的，一开始不需要额外的答案。感谢
a
注释帮助我，B和C是不必要的
package test;

import java.util.ArrayList;
import java.util.List;
import test.Team;
import java.util.Collections;

// -- A) missing precision about Team , Team based on Player 
// -- public class League<T extends Team> 
public class League<T extends Team<E>, E extends Player>
{
    public String name;
    
    
    // B) ! miss <T> after new : 
    //    private List<T> teams = new ArrayList<>();
    private List<T> teams = new ArrayList<T>();
    
    

    public League(String name) {
        this.name = name;
    }

    public boolean add(T team) {
        if (teams.contains(team)) {
            return false;
        }

        return teams.add(team);
    }

    public void showLeagueTable() {
        Collections.sort(this.teams);

        for (T t: teams) {
            System.out.println(t.getName() + ": " + t.ranking());
        }
    }
}

    package test;
    
    
    import java.util.ArrayList;
    
       
    public class Team<T extends Player> implements Comparable<Team<T>> {
           
        private String name;
        int played = 0;
        int won = 0;
        int lost = 0;
        int tied = 0;
    
        // C) !! MISS <T> after new ArrayList
        // private ArrayList<T> members = new ArrayList<>();
        private ArrayList<T> members = new ArrayList<T>();
    
    
        @Override
        public int compareTo(Team<T> team) {
            return Integer.compare(team.ranking(), this.ranking());
        }
        
        
        
       public Team(String name) {
           this.name = name;
       }
    
       public String getName() {
           return name;
       }
    
       public boolean addPlayer(T player) {
           if (members.contains(player)) {
               System.out.println(player.getName() + " is already on this team");
               return false;
           } else {
               members.add(player);
               System.out.println(player.getName() + " picked for team " + this.name);
    
               return true;
           }
       }
    
       public int numPlayers() {
           return this.members.size();
       }
       
       public void showPlayers() {
           for (T element : members) {
               System.out.println(element.getName());
           }
       }
    
       public void matchResult(Team<T> opponent, int ourScore, int theirScore) {
           String message;
           if (ourScore > theirScore) {
               won++;
               message = " beat ";
           } else if (ourScore == theirScore) {
               tied++;
               message = " drew with ";
           } else {
               lost++;
               message = " lost to ";
           }
    
           played++;
    
           if (opponent != null) {
               System.out.println(this.getName() + message + opponent.getName());
               opponent.matchResult(null, theirScore, ourScore);
           }
       }
    
       public int ranking() {
           return (won * 2) + tied;
       }
    
    }

package test;

public class Player {
    private String name;

    public Player(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

package test;

import test.League;
import test.Team;
import test.Player;

public class Test {

     Player p1;
     Player p2;
     Player p3;
     Player p4;
     Player p5;
     Player p6;
     Player p7;
     Player p8;
     Player p9;
        
     Team<Player> t1;
     Team<Player> t2;
     Team<Player> t3;
     Team<Player> t4;

    
    public void test() {
        
        System.out.println("RUNNING TEST");
        
         p1=new Player("Mike");
         p2=new Player("John");
         p3=new Player("Jenny");
         p4=new Player("Sunny");
         p5=new Player("Mike");
         p6=new Player("Jeremy");
         p7=new Player("Gwen");
         p8=new Player("Hector");
         p9=new Player("Henry");
            
         t1=new Team<Player>("Team1");
         t2=new Team<Player>("Team2");
         t3=new Team<Player>("Team3");
         t4=new Team<Player>("Team4");
         
         t1.addPlayer(p1);
         t1.addPlayer(p2);
         t2.addPlayer(p3);
         t2.addPlayer(p4);
         t2.addPlayer(p5);
         t3.addPlayer(p6);
         t3.addPlayer(p7);
         t4.addPlayer(p8);
         t4.addPlayer(p9);
         
    
         // test show players
         t1.showPlayers();
         System.out.println("------------");
         System.out.println("num players in team is "+t1.numPlayers());
        
         System.out.println("---adding team in league ---------");
         League<Team<Player>, Player> g1=new League<Team<Player>, Player>("League 1");
         g1.add(t1);
         g1.add(t2);
         
         League<Team<Player>, Player> g2=new League<Team<Player>, Player>("League 2");
         g2.add(t3);
         g2.add(t4);
         
         System.out.println("---settings results ---------");
         t1.matchResult(t2, 2, 8);
         t2.matchResult(t1, 1, 7);
         t3.matchResult(t4, 4, 5);
         t3.matchResult(t4, 4, 0);
         
         System.out.println("-----League 1---------");
         g1.showLeagueTable();
         System.out.println("-----League 2---------");
         g2.showLeagueTable();
         
     
         
         
    }
    
}

import test.Test;

public class Main  
{
   
    public static void main(String[] args) {        
      System.out.println("running MAIn");
      Test test = new Test();
      test.test();
    }    
}