Java 包含任意对象的ArrayList

我想创建一个自定义类

MultipleResult

，它可以包含不同类型的

ArrayList

s，但我不确定如何实现它。我想将多个

ArrayList

封装到一个对象中，但有时我会使用

ArrayList

，有时则使用

ArrayList

。 我已尝试将泛型输入声明为

ArrayList

，但在执行以下操作时，会出现

不兼容类型的错误：

MultipleResult arrays = reduce(theInputValues,10);
ArrayList<Float> arrayA =arrays.getResultA();

下面是
reduce
方法：

private MultipleResult reduce(ArrayList<Float> theInput,Integer n){

    ArrayList<Float> opens=new ArrayList<>();
    ArrayList<Float> highs=new ArrayList<>();
    ArrayList<Float> lows=new ArrayList<>();
    ArrayList<Float> closes=new ArrayList<>();

    Integer N = theInput.size();

    for (int i=0;i<n;i++){

        Integer nMin = Math.round((N/n)*i);
        Integer nMax = Math.round((N/n)*(i+1))-1;

        Float open=theInput.get(nMax);
        Float high=theInput.get(nMin);
        Float low=theInput.get(nMin);
        Float close=theInput.get(nMin);

        for(int j=nMin;j<=nMax;j++){
            if (theInput.get(j)>high){
                high=theInput.get(j);
            }
            if (theInput.get(j)<low){
                low=theInput.get(j);
            }
        }

        opens.add(i,open);
        highs.add(i,high);
        lows.add(i,low);
        closes.add(i,close);

    }

    return new MultipleResult(opens,highs,lows,closes);
}

private MultipleResult reduce（数组列出输入，整数n）{
ArrayList opens=新建ArrayList（）；
ArrayList highs=新的ArrayList（）；
ArrayList lows=新的ArrayList（）；
ArrayList关闭=新建ArrayList（）；
整数N=输入的大小（）；
对于@Kaostias评论中建议的（int i=0；i），您可以按如下方式制作
MultipleResult

public class MultipleResult<T> {

    private ArrayList<T> resultA;
    private ArrayList<T> resultB;
    private ArrayList<T> resultC;
    private ArrayList<T> resultD;

    public MultipleResult(ArrayList<T> arrayA, ArrayList<T> arrayB) {
        resultA=arrayA;
        resultB=arrayB;
    }

    public MultipleResult(ArrayList<T> arrayA, ArrayList<T> arrayB,
                          ArrayList<T> arrayC, ArrayList<T> arrayD) {
        resultA=arrayA;
        resultB=arrayB;
        resultC=arrayC;
        resultD=arrayD;
    }

    public ArrayList<T> getResultA() {
        return resultA;
    }

    public ArrayList<T> getResultB() {
        return resultB;
    }

    public ArrayList<T> getResultC() {
        return resultC;
    }

    public ArrayList<T> getResultD() {
        return resultD;
    }
}

private MultipleResult<Float> reduce(ArrayList<Float> theInput,Integer n){

    ArrayList<Float> opens=new ArrayList<>();
    ArrayList<Float> highs=new ArrayList<>();
    ArrayList<Float> lows=new ArrayList<>();
    ArrayList<Float> closes=new ArrayList<>();

    Integer N = theInput.size();

    for (int i=0;i<n;i++){

        Integer nMin = Math.round((N/n)*i);
        Integer nMax = Math.round((N/n)*(i+1))-1;

        Float open=theInput.get(nMax);
        Float high=theInput.get(nMin);
        Float low=theInput.get(nMin);
        Float close=theInput.get(nMin);

        for(int j=nMin;j<=nMax;j++){
            if (theInput.get(j)>high){
                high=theInput.get(j);
            }
            if (theInput.get(j)<low){
                low=theInput.get(j);
            }
        }

        opens.add(i,open);
        highs.add(i,high);
        lows.add(i,low);
        closes.add(i,close);

    }

    return new MultipleResult<Float>(opens,highs,lows,closes);
}

公共类MultipleResult{
私有数组列表结果；
私有arraylistresultb；
私有数组列表结果；
私有数组列表结果；
公共多重结果（ArrayList arrayA、ArrayList arrayB）{
结果=arrayA；
resultB=arrayB；
}
公共多重结果（ArrayList arrayA、ArrayList arrayB、，
ArrayList arrayC，ArrayList arrayD）{
结果=arrayA；
resultB=arrayB；
结果c=arrayC；
结果d=arrayD；
}
公共数组列表getResultA（）{
返回结果；
}
公共ArrayList getResultB（）{
返回结果TB；
}
公共数组列表getResultC（）{
返回结果c；
}
公共数组列表getResultD（）{
返回结果d；
}
}

并按如下方式使用它

public class MultipleResult<T> {

    private ArrayList<T> resultA;
    private ArrayList<T> resultB;
    private ArrayList<T> resultC;
    private ArrayList<T> resultD;

    public MultipleResult(ArrayList<T> arrayA, ArrayList<T> arrayB) {
        resultA=arrayA;
        resultB=arrayB;
    }

    public MultipleResult(ArrayList<T> arrayA, ArrayList<T> arrayB,
                          ArrayList<T> arrayC, ArrayList<T> arrayD) {
        resultA=arrayA;
        resultB=arrayB;
        resultC=arrayC;
        resultD=arrayD;
    }

    public ArrayList<T> getResultA() {
        return resultA;
    }

    public ArrayList<T> getResultB() {
        return resultB;
    }

    public ArrayList<T> getResultC() {
        return resultC;
    }

    public ArrayList<T> getResultD() {
        return resultD;
    }
}

private MultipleResult<Float> reduce(ArrayList<Float> theInput,Integer n){

    ArrayList<Float> opens=new ArrayList<>();
    ArrayList<Float> highs=new ArrayList<>();
    ArrayList<Float> lows=new ArrayList<>();
    ArrayList<Float> closes=new ArrayList<>();

    Integer N = theInput.size();

    for (int i=0;i<n;i++){

        Integer nMin = Math.round((N/n)*i);
        Integer nMax = Math.round((N/n)*(i+1))-1;

        Float open=theInput.get(nMax);
        Float high=theInput.get(nMin);
        Float low=theInput.get(nMin);
        Float close=theInput.get(nMin);

        for(int j=nMin;j<=nMax;j++){
            if (theInput.get(j)>high){
                high=theInput.get(j);
            }
            if (theInput.get(j)<low){
                low=theInput.get(j);
            }
        }

        opens.add(i,open);
        highs.add(i,high);
        lows.add(i,low);
        closes.add(i,close);

    }

    return new MultipleResult<Float>(opens,highs,lows,closes);
}

private MultipleResult reduce（数组列出输入，整数n）{
ArrayList opens=新建ArrayList（）；
ArrayList highs=新的ArrayList（）；
ArrayList lows=新的ArrayList（）；
ArrayList关闭=新建ArrayList（）；
整数N=输入的大小（）；
对于（int i=0；i我不确定，但我认为在您的情况下，泛型类型很有用。例如：

ArrayList<T> list = new ArrayList<T>();

ArrayList list=new ArrayList（）；

有关更多信息，请使用下面的链接：


您可以使用泛型完成此操作。例如：

  public class MultipleResult<T> {
   ...
  }

公共类MultipleResult{
...
}

然后：

 MultipleResult<Integer> multipleResult = new MultipleResult<>();

MultipleResult MultipleResult=新的MultipleResult（）；
您可以将MultipleResult本身设置为参数化，使用该参数化类型键入其包含的数组

public class MultipleResult<T extends Number> {
    private List<T> resultA = new ArrayList<>();

    public MultipleResult(List<T> arrayA, ...) {
        this.resultA = arrayA;
    }
}

公共类MultipleResult{
私有列表结果=新的ArrayList（）；
公共多重结果（列表arrayA，…）{
this.resultA=arrayA；
}
}
TL；DR您可以尝试使用
Number
。或者