Question

我试图将N对整数 - 一个Nx2 ArrayList - 相加并将N个求和作为ArrayList返回。虽然我理解没有必要设立一个课程来完成这个，但我希望这样做是为了未来的项目。

import java.util.ArrayList;

public class SumsInLoop {
    public SumsInLoop(int numberOfPairs, ArrayList<ArrayList<Integer>> numbersList) {}

    public ArrayList<Integer> getSums(int numberOfPairs, ArrayList<ArrayList<Integer>> numbersList) {
        ArrayList<Integer> pairsOfSums = new ArrayList<Integer>();
        for (ArrayList<Integer> Pair : numbersList) {
            int x = Pair.get(0);
            int y = Pair.get(1);
            int sum = x + y;
            pairsOfSums.add(sum);
        }
        System.out.println(pairsOfSums);
        return pairsOfSums;
    }

我给出的数据是N对（numbersOfPairs）整数的随机分类，例如612673 108695.我想将这些整数对添加到将由getSums调用的2D ArrayList（numbersList）。

但是，我在初始化numbersList时遇到了困难。我的主要功能如下：

    public static void main(String[] args) {
        int myNumberOfPairs = 13;
        ArrayList[][] myNumbersList = new ArrayList[13][2];
        myNumbersList[0][0] = new ArrayList<>();
        myNumbersList[0][0].add(612673);
        myNumbersList[0][1].add(108695);
        myNumbersList[1][0] = new ArrayList<>();
        myNumbersList[1][0].add(756875);
        myNumbersList[1][1].add(496058);
        SumsInLoop mySum = new SumsInLoop(myNumberOfPairs,myNumbersList);
        mySum.getSums(myNumberOfPairs, myNumbersList);

最后两行代码抛出错误，要求我将myNumbersList更改为ArrayList<List<Integer>>类型，即使将所有2D ArrayLists更改为ArrayList<List<Integer>>类型，也会引发更多错误。

所以，我的两个问题如下：

如何初始化NxM ArrayList并正确填充？
在使用类方法时是否有更快的方法来完成此任务？

P.S。我以前习惯使用Python进行编码，并且自己自学Java，所以您可以为我提供的任何其他信息或资源都非常感谢。

Answer 1

您获得的（编译）异常是由于您期望ArrayList<ArrayList<Integer>>，但是传递ArrayList[][]。（在Java中不一样）

在您的情况下，您需要（使用main方法）：

ArrayList<ArrayList<Integer>> myNumbersList = new ArrayList</* when java > 6 ;)*/>(13);

这只设置（父）列表（..和底层/内部支持数组）的容量初始化子列表，你不会绕过循环（不知何故......甚至不在python中）：

for (int i = 0; i < 13; i++) {
    myNumbersList.add(new ArrayList<Integer>(2));
}

取决于“正确”的含义...但我假设“随机数据”，理想情况下你会再次内循环：

java.util.Random rnd = new Random(/*seed default current timestamp*/);
//...
for (int i = 0; i < 13; i++) {
  ArrayList<Integer> innerList = new ArrayList<>(2);
  for (int j = 0; j < 2; j++) {
    innerList.add(rnd.netxInt(/*bound default Integer.MAX_VALUE*/) /*+/-/% offset*/);
  }
  myNumberList.add(innerList);
}

抱歉，我不知道一个（更快的方式），但很大程度上取决于“输入格式”。

Answer 2

由于您已经知道对中的值的数量，因此不需要ArrayList。您可以创建自己的，更简单的一对实现。

class Pair {
    public final int left;
    public final int right;

    public Pair(int left, int right){
        this.left = left;
        this.right = right;
    }
}

然后，您可以通过创建配对对象并访问其字段来访问这些值。

Pair p = new Pair(10, 7);
System.out.println(p.left); // 10
System.out.println(p.right); // 7

然后，您可以更轻松地重新定义getSums方法。

public static List<Integer> getSums(List<Pair> pairs){
    List<Integer> pairsOfSums = new ArrayList<>();
    for(Pair pair : pairs){
        int sum = pair.left + pair.right;
        pairsOfSums.add(sum);
    }
    return pairsOfSums;
}

请注意，该功能可以是static，您无需传递对数。无论如何，for-each循环都会遍历所有循环。

初始化数组比您在问题中描述的方法更容易。

List<Pair> pairs = new ArrayList<>();
pairs.add(new Pair(7, 10));
pairs.add(new Pair(18, 3));
pairs.add(new Pair(-6, 0));
pairs.add(new Pair(4, 2));
System.out.println(SumsInLoop.getSums(pairs));

Answer 3

您可能希望使用int：int[][] myNumbersList = new int[13][2];的二维数组来简化输入在这种情况下，预期的输出是int[13]的一维数组，可以如下获得（用2对证明。见mcve）：

public class SumsInLoop {
    //pairsOfInts should be an [n][2] array
    private static int[] sumOfPairs(int[][] pairsOfInts) {

        int[] sums = new int[pairsOfInts.length];
        for(int pairIndex = 0; pairIndex < pairsOfInts.length; pairIndex++) {
            sums[pairIndex]= pairsOfInts[pairIndex][0]+pairsOfInts[pairIndex][1];
        }
        return sums;
    }

    public static void main(String[] args) {
        int numberOfPairs = 2;
        int[][] pairsOfInts = new int[numberOfPairs][2];
        pairsOfInts[0] = new int[] {612673,108695 };
        pairsOfInts[1] = new int[] {756875,496058 };
        int[] sumOfPairs = sumOfPairs(pairsOfInts);
        System.out.println(Arrays.toString(sumOfPairs));
    }
}

如果您希望使用List实施解决方案，则可以使用javafx Pair（或制作您自己的配对类。）输入可以定义为List<Pair<Integer,Integer>> pairsOfInts = new ArrayList<>();
输出可以是上面的数组，也可以是List<Integer>：

import java.util.ArrayList;
import java.util.List;
import javafx.util.Pair;

public class SumsInLoop {

    private static List<Integer> sumOfPairs(List<Pair<Integer, Integer>> pairsOfInts) {
        List<Integer> sums = new ArrayList<>();
        for(Pair<Integer,Integer> pair : pairsOfInts) {
            sums.add(pair.getKey()+ pair.getValue());
        }
        return sums;
    }

    public static void main(String[] args) {
        List<Pair<Integer,Integer>> pairsOfInts = new ArrayList<>();
        pairsOfInts.add (new Pair<>(612673,108695 ));
        pairsOfInts.add (new Pair<>(756875,496058));
        List<Integer> sumOfPairs = sumOfPairs(pairsOfInts);
        System.out.println(sumOfPairs); 
    }
}

初始化2D ArrayList以进行for循环求和（Java）

3 个答案: