Java ArrayList的铸造<；对象>；给我自己的班级

我有两个ArrayList，teamList1和teamList2，每个都包含五个团队对象。我用一种方法将这些内容相互比较。我必须将这两个ArrayList作为单个2元素简单数组参数Objects[]传递到方法中。我遇到了一个编译器错误，因为我正在努力将类型对象转换为类型团队。换句话说，从集合更改为简单数组再更改为集合会给我带来一个错误。有人知道我选角的错误吗

CommonElements.java

package test;

import javax.swing.*;
import java.util.*;

public class CommonElements {

    List<Comparable> teamList1 = new ArrayList<Comparable>();
    List<Comparable> teamList2 = new ArrayList<Comparable>();  
    List<Comparable> commonList = new ArrayList<Comparable>();

    Object[] listCollection = new Object[2];   
    int comparisonCount;

    public static void main(String[] args) {
        new CommonElements();       
    }

    public CommonElements() {

        comparisonCount = 0;

        Team a = new Team("Boston");
        Team b = new Team("Seattle");
        Team c = new Team("Newark");
        Team d = new Team("Houston");
        Team e = new Team("Salt Lske City");

        teamList1.add(a);
        teamList1.add(b);
        teamList1.add(c);
        teamList1.add(d);
        teamList1.add(e);

        Team f = new Team("Seattle");
        Team g = new Team("Nashville");
        Team h = new Team("St. Louis");
        Team i = new Team("New York");
        Team j = new Team("Boston");

        teamList2.add(f);
        teamList2.add(g);
        teamList2.add(h);
        teamList2.add(i);
        teamList2.add(j);    


        listCollection[0] = teamList1;
        listCollection[1] = teamList2;

        findCommonElements(listCollection);
        System.out.println(comparisonCount);          
    }

    public Comparable[] findCommonElements(Object[] collections)
    {        
        ArrayList<Object> objectTeam1 = new ArrayList<Object>(Arrays.asList(collections[0]));
        ArrayList<Object> objectTeam2 = new ArrayList<Object>(Arrays.asList(collections[1]));

        ArrayList<Team> team1 = (ArrayList)objectTeam1;
        ArrayList<Team> team2 = (ArrayList)objectTeam2;


        Team[] commonList = new Team[5];
        int  i = 0;
        for(Team x:team1)
        {
            for(Team y:team2)
            {       
                comparisonCount++;
                if(x.compareTo(y) == 0)
                { 
                    commonList[i] = x;                      
                    System.out.println(commonList[i].teamName); 
                    i++;
                    break; /*to ensure it looks for only one match per entry*/                    
                }
            } 
        }        
        return commonList;
    }

    public int getComparisons()
    {
        return comparisonCount;
    }
}

package test;

public class Team implements Comparable<Team> {

    String teamName = new String();

    public void setName ( String n ) {
        teamName = n;
    } 

    public Team(String n) {
        setName(n);
    }


    public int compareTo(Team x)
    {
        if(this.teamName.equals(x.teamName))
        {
            return 0;
        }
        else
        {
            return -1;
        }
    }


}

封装测试；
导入javax.swing.*；
导入java.util.*；
公共类公共元素{
List teamList1=new ArrayList（）；
List teamList2=new ArrayList（）；
List commonList=new ArrayList（）；
Object[]listCollection=新对象[2]；
整数比较计数；
公共静态void main（字符串[]args）{
新元素（）；
}
公共元素（）{
comparisonCount=0；
团队a=新团队（“波士顿”）；
团队b=新团队（“西雅图”）；
团队c=新团队（“纽瓦克”）；
d队=新队（“休斯顿”）；
团队e=新团队（“盐城”）；
团队列表1.添加（a）；
团队列表1.添加（b）；
团队列表1.添加（c）；
团队列表1.添加（d）；
团队列表1.添加（e）；
团队f=新团队（“西雅图”）；
团队g=新团队（“纳什维尔”）；
团队h=新团队（“圣路易斯”）；
第一队=新队（“纽约”）；
团队j=新团队（“波士顿”）；
团队列表2.添加（f）；
团队列表2.添加（g）；
团队列表2.添加（h）；
团队列表2.添加（i）；
团队列表2.添加（j）；
listCollection[0]=teamList1；
listCollection[1]=teamList2；
findCommonElements（listCollection）；
系统输出打印项次（比较项次）；
}
公共可比[]findCommonElements（对象[]集合）
{        
ArrayList objectTeam1=新的ArrayList（Arrays.asList（集合[0]）；
ArrayList objectTeam2=新的ArrayList（Arrays.asList（collections[1]）；
ArrayList team1=（ArrayList）objectTeam1；
ArrayList team2=（ArrayList）objectTeam2；
团队[]commonList=新团队[5]；
int i=0；
对于（第x组：第1组）
{
对于（y组：第2组）
{       
comparisonCount++；
如果（x.compareTo（y）==0）
{ 
公共列表[i]=x；
System.out.println（commonList[i].teamName）；
i++；
中断；/*以确保每个条目只查找一个匹配项*/
}
} 
}        
返回公共列表；
}
公共整数比较（）
{
返回比较计数；
}
}

Team.java

package test;

import javax.swing.*;
import java.util.*;

public class CommonElements {

    List<Comparable> teamList1 = new ArrayList<Comparable>();
    List<Comparable> teamList2 = new ArrayList<Comparable>();  
    List<Comparable> commonList = new ArrayList<Comparable>();

    Object[] listCollection = new Object[2];   
    int comparisonCount;

    public static void main(String[] args) {
        new CommonElements();       
    }

    public CommonElements() {

        comparisonCount = 0;

        Team a = new Team("Boston");
        Team b = new Team("Seattle");
        Team c = new Team("Newark");
        Team d = new Team("Houston");
        Team e = new Team("Salt Lske City");

        teamList1.add(a);
        teamList1.add(b);
        teamList1.add(c);
        teamList1.add(d);
        teamList1.add(e);

        Team f = new Team("Seattle");
        Team g = new Team("Nashville");
        Team h = new Team("St. Louis");
        Team i = new Team("New York");
        Team j = new Team("Boston");

        teamList2.add(f);
        teamList2.add(g);
        teamList2.add(h);
        teamList2.add(i);
        teamList2.add(j);    


        listCollection[0] = teamList1;
        listCollection[1] = teamList2;

        findCommonElements(listCollection);
        System.out.println(comparisonCount);          
    }

    public Comparable[] findCommonElements(Object[] collections)
    {        
        ArrayList<Object> objectTeam1 = new ArrayList<Object>(Arrays.asList(collections[0]));
        ArrayList<Object> objectTeam2 = new ArrayList<Object>(Arrays.asList(collections[1]));

        ArrayList<Team> team1 = (ArrayList)objectTeam1;
        ArrayList<Team> team2 = (ArrayList)objectTeam2;


        Team[] commonList = new Team[5];
        int  i = 0;
        for(Team x:team1)
        {
            for(Team y:team2)
            {       
                comparisonCount++;
                if(x.compareTo(y) == 0)
                { 
                    commonList[i] = x;                      
                    System.out.println(commonList[i].teamName); 
                    i++;
                    break; /*to ensure it looks for only one match per entry*/                    
                }
            } 
        }        
        return commonList;
    }

    public int getComparisons()
    {
        return comparisonCount;
    }
}

package test;

public class Team implements Comparable<Team> {

    String teamName = new String();

    public void setName ( String n ) {
        teamName = n;
    } 

    public Team(String n) {
        setName(n);
    }


    public int compareTo(Team x)
    {
        if(this.teamName.equals(x.teamName))
        {
            return 0;
        }
        else
        {
            return -1;
        }
    }


}

封装测试；
公共类团队实现了可比较的{
String teamName=新字符串（）；
公共void集合名（字符串n）{
团队名称=n；
} 
公共团队（字符串n）{
集合名（n）；
}
公共int比较（团队x）
{
if（this.teamName.equals（x.teamName））
{
返回0；
}
其他的
{
返回-1；
}
}
}

这是一种非常不幸和奇怪的参数传递方式，但无论如何，要使其工作，您可以：

@SuppressWarnings("unchecked")
ArrayList<Team> team1 = (ArrayList<Team>)collections[0];
@SuppressWarnings("unchecked")
ArrayList<Team> team2 = (ArrayList<Team>)collections[1];

您可以简单地执行以下操作：

teamList1.add(new Team("Boston"));

您不需要单独创建

listCollection

数组，因为在传递参数时可以内联创建它：

findCommonElements(new Object[] { teamList1, teamList2 });

在团队课程中，这是：

String teamName = new String();

应该是：

String teamName;

在您的compareTo方法中：

public int compareTo(Team x)
{
    if(this.teamName.equals(x.teamName))
    {
        return 0;
    }
    else
    {
        return -1;
    }
}

这应该是：

public int compareTo(Team x)
{
    return teamName.compareTo(x.teamName);
}

---

对于所有的x和y，这是一种非常不幸和奇怪的传递参数的方式，但无论如何，要使其工作，您可以：

@SuppressWarnings("unchecked")
ArrayList<Team> team1 = (ArrayList<Team>)collections[0];
@SuppressWarnings("unchecked")
ArrayList<Team> team2 = (ArrayList<Team>)collections[1];

您可以简单地执行以下操作：

teamList1.add(new Team("Boston"));

您不需要单独创建

listCollection

数组，因为在传递参数时可以内联创建它：

findCommonElements(new Object[] { teamList1, teamList2 });

在团队课程中，这是：

String teamName = new String();

应该是：

String teamName;

在您的compareTo方法中：

public int compareTo(Team x)
{
    if(this.teamName.equals(x.teamName))
    {
        return 0;
    }
    else
    {
        return -1;
    }
}

这应该是：

public int compareTo(Team x)
{
    return teamName.compareTo(x.teamName);
}

---

对于所有的x和y，这是一种非常不幸和奇怪的传递参数的方式，但无论如何，要使其工作，您可以：

@SuppressWarnings("unchecked")
ArrayList<Team> team1 = (ArrayList<Team>)collections[0];
@SuppressWarnings("unchecked")
ArrayList<Team> team2 = (ArrayList<Team>)collections[1];

您可以简单地执行以下操作：

teamList1.add(new Team("Boston"));

您不需要单独创建

listCollection

数组，因为在传递参数时可以内联创建它：

findCommonElements(new Object[] { teamList1, teamList2 });

在团队课程中，这是：

String teamName = new String();

应该是：

String teamName;

在您的compareTo方法中：

public int compareTo(Team x)
{
    if(this.teamName.equals(x.teamName))
    {
        return 0;
    }
    else
    {
        return -1;
    }
}

这应该是：

public int compareTo(Team x)
{
    return teamName.compareTo(x.teamName);
}

---

对于所有的x和y，这是一种非常不幸和奇怪的传递参数的方式，但无论如何，要使其工作，您可以：

@SuppressWarnings("unchecked")
ArrayList<Team> team1 = (ArrayList<Team>)collections[0];
@SuppressWarnings("unchecked")
ArrayList<Team> team2 = (ArrayList<Team>)collections[1];

您可以简单地执行以下操作：

teamList1.add(new Team("Boston"));

您不需要单独创建

listCollection

数组，因为在传递参数时可以内联创建它：

findCommonElements(new Object[] { teamList1, teamList2 });

在团队课程中，这是：

String teamName = new String();

应该是：

String teamName;

在您的compareTo方法中：

public int compareTo(Team x)
{
    if(this.teamName.equals(x.teamName))
    {
        return 0;
    }
    else
    {
        return -1;
    }
}

这应该是：

public int compareTo(Team x)
{
    return teamName.compareTo(x.teamName);
}

---

它较短，并且对所有x和y的

sgn（x.compareTo（y））==-sgn（y.compareTo（x））

表示敬意。

欢迎使用堆栈溢出。你能发布错误日志吗@Shampouya你不能将泛型（我不相信），例如

ArrayList

转换为

ArrayList

…我不明白为什么这里有必要这样做。您有一个

可比较的

对象数组，那么为什么不让您的

比较元素

方法取而代之的是一个

可比较的

对象数组，而不进行任何强制转换呢？欢迎使用堆栈溢出。你能发布错误日志吗@Shampouya你不能将泛型（我不相信），例如

ArrayList

转换为

ArrayList

…我不明白为什么会这样