Question

如果我有一个数组int[] a = new int[]{1, 2, 3};和另一个int[] b = new int[]{3, 2};，我想将两者加在一起，我会这样做：

if (a.length >= b.length){
    int[] c = new int[a.length];

    for(int i=0; i<c.length; i++){
        c[i] = a[i] + b[i];
        return c;
    }
}
else{
    int[]c = new int[b.length];

    for(int i=0; i<c.length; i++){
        c[i] = a[i] + b[i];
        return c;
    }

但是当我打印c时，我得到{4,4}并且结尾的3被遗漏了，我哪里出错？

提前感谢您的帮助！

public Poly add(Poly a){

    if (coefficients.length <= a.coefficients.length){
        int[] c = new int[coefficients.length]; 

        for (int i=0; i<added.length; i++){
            c[i] = a.coefficients[i] + coefficients[i];
        }

        Poly total = new Poly(c);
        return total;
    }
    else{
        int[] added = new int[a.coefficients.length];

        for (int i=0; i<added.length; i++){
            added[i] = a.coefficients[i] + coefficients[i];
        }

        Poly total = new Poly(c);
        return total;
    }       
}

和Poly是一个构造函数，它将int数组作为参数（Poly ex = new Poly(new int[]{1, 2, 3})）

Answer 1

您可以定义目标数组，其长度为两个源数组的最大值。之后，您只需进行数组边界检查。当然，在开始循环c之前，您还应该添加null检查。

import java.util.Arrays;

class AddArrays {
    private static int[] a = new int[] { 1, 2, 3 };
    private static int[] b = new int[] { 3, 2 };
    private static int[] c = add(a, b);

    private static int[] add(int[] a, int[] b) {
        int[] c = new int[(int) Math.max(a.length, b.length)];
        for (int i = 0; i < c.length; i++) {
            if (a.length > i) {
                c[i] += a[i];
            }
            if (b.length > i) {
                c[i] += b[i];
            }
        }
        return c;
    }

    public static void main (String[] args) {
        System.out.println(Arrays.toString(c));
    }
}

输出：

[4, 4, 3]

Answer 2

int[] vector1={1,2,3,4};
int[] vector2={1,2,3};
int result[]=new int[(int)Math.max(vector1.length,vector2.length)];
for(int i=0;i<result.length; i++) {
    if(vector1.length>i && vector2.length>i) 
        result[i]=vector1[i] + vector2[i];

    else if(vector1.length<vector2.length)
        result[i]+=vector2[i];

    else if(vector2.length<vector1.length) 
        result[i]+=vector1[i];

    System.out.print(result[i]+"    ");
}

在这里，首先通过比较两个输入数组的大小并从两个比较中设置最大大小来预测结果的第一个数组大小。

接下来，通过比较for循环内输入数组的大小，将比另一个数组大的输入数组添加到结果数组中。

结果：

2    4    6    4

Answer 3

首先，你会得到一个ArrayIndexOutOfBoundsException，因为在最后一次迭代（第三次迭代）：c[2] = a[2] + b[2]，b[2]因为它更小而超出范围。所以你不能检查null在这种情况下你必须检查较短的数组的长度。

此外，我不确定你是如何获得{4,4}的，因为我需要更多的代码来了解正在发生的事情。

但无论如何这里是一个避免ArrayIndexOutOfBoundsException的解决方案：

public static int[] add(int[] a, int[] b) {
    int[] c;

    if (a.length >= b.length){
        c = new int[a.length];

        for(int i=0; i<c.length; i++){
            c[i] = (i < b.length) ? a[i] + b[i]: a[i];
        }
    }
    else{
        c = new int[b.length];

        for(int i=0; i<c.length; i++){
            c[i] = (i < a.length) ? a[i] + b[i]: b[i];
        }
    }
    return c;
}

Answer 4

你已经超出界限，因为程序正在寻找“a”和“b”数组中第三位的数字。在“a”数组中它是3号，但是数组“b”没有这样的数字，所以你得到一个超出界限的错误索引。我通过做下一件事来解决这个问题：

if (a.length >= b.length){
    int[] c = new int[a.length];

    for(int i=0; i < c.length; i++){
        if (i < b.length)
            c[i] = a[i] + b[i];
        else
            c[i] = a[i];
    }

    return c;

} else {
    int[]c = new int[b.length];

    for(int i=0; i<c.length; i++){
        if (i < a.length)
            c[i] = a[i] + b[i];
        else
            c[i] = b[i];
    }

    return c;

}

新数组得到数字之和，而两个数组都得到该索引上的数字，当较短数组超出数字时，其余数字只是复制到新数组中。希望它有所帮助，如果您有任何其他问题，请告诉我。

Answer 5

你有几个问题，即：

你的长度混乱，所以你会得到一个例外。您应该为较小的数组长度添加，然后复制较大数组的其余部分。（假设这是期望的行为。）
在第一个示例中，您的循环中包含return语句。将它们移到外面。

如果是我，我会做的是假设一个是较长的数组并交换引用，如果不是。这样你只需编写一个循环。

static int[] sum(int[] a, int[] b) {
    int[] c;

    if(b.length > a.length) {
        c = a;
        a = b;
        b = c;
    }

    c = Arrays.copyOf(a, a.length);

    for(int i = 0; i < b.length; i++) {
        c[i] += b[i];
    }

    return c;
}

而不是copyOf，你能做到的另一种方式就是这样：

    ...

    c = new int[a.length];

    int i = 0;
    for(; i < b.length; i++) {
        c[i] = a[i] + b[i];
    }
    for(; i < a.length; i++) {
        c[i] = a[i];
    }

    return c;
}

或者代替第二个循环：

    System.arraycopy(a, i, c, i, a.length - i);

我认为其中任何一个都比替代方法更明确，那就是在循环中放入一个if语句：

    for(int i = 0; i < c.length; i++) {
        if(i < b.length) {
            c[i] = a[i] + b[i];
        } else {
            c[i] = a[i];
        }
    }

这样做也是另一个技术上会慢一点的分支。

Answer 6

这是一个解决问题的测试驱动方法。构建你的边界情况并开始编写代码。你应该能够解决这个问题。

public static void main(String[] args) {
    //second array is bigger
    int[] array1 = {1, 3, 4, 5, 7};
    int[] array2 = {4, 45, 54, 65, 34, 45, 234, 56};
    int[] resultArr = add(array1, array2);
    for (int i = 0; i < resultArr.length; i++) {
        System.out.println(resultArr[i]);
    }
    //first array is bigger
    int[] array3 = {4, 45, 54, 65, 34, 45, 234, 56};
    int[] array4 = {1, 3, 4, 5, 7};
    resultArr = add(array3, array4);
    for (int i = 0; i < resultArr.length; i++) {
        System.out.println(resultArr[i]);
    }

    //first array is empty
    int[] array5 = {};
    int[] array6 = {1, 3, 4, 5, 7};
    resultArr = add(array5, array6);
    for (int i = 0; i < resultArr.length; i++) {
        System.out.println(resultArr[i]);
    }

    //Second array is empty
    int[] array7 = {1, 3, 4, 5, 7};
    int[] array8 = {};
    resultArr = add(array7, array8);
    for (int i = 0; i < resultArr.length; i++) {
        System.out.println(resultArr[i]);
    }

    //Both arrays are empty
    int[] array9 = {};
    int[] array10 = {};
    resultArr = add(array9, array10);
    for (int i = 0; i < resultArr.length; i++) {
        System.out.println(resultArr[i]);
    }

    //Both arrays are of equal length
    int[] array11 = {1, 3, 4, 5, 7};
    int[] array12 = {1, 3, 4, 5, 7};
    resultArr = add(array11, array12);
    for (int i = 0; i < resultArr.length; i++) {
        System.out.println(resultArr[i]);
    }

}

public static int[] add(int[] arr1, int[] arr2) {
    int arrLength1 = arr1.length;
    int arrLength2 = arr2.length;
    int[] resultArr;
    int smallerLength = 0;
    if (arrLength1 > arrLength2) {
        resultArr = Arrays.copyOf(arr1, arrLength1);
        smallerLength = arrLength2;
    } else {
        resultArr = Arrays.copyOf(arr2, arrLength2);
        smallerLength = arrLength1;
    }
    for (int i = 0; i < smallerLength; i++) {
        resultArr[i] = arr1[i] + arr2[i];

    }

    return resultArr;
}

import java.util.Arrays;

public class AddArray {

void foo(float a)
{
    std::cout << "Float!" << a << std::endl;
}
void foo(int a)
{
    std::cout << "Int!" << a << std::endl;
}

}

如何添加两个不同大小的数组？

6 个答案: