Java中两个数组的元素和

对两个数组逐元素求和的最简单方法是什么

我知道您可以使用

for

循环，例如：

int[] a = {0, 1, 2};
int[] b = {3, 4, 5};
int[] c = new int[a.length];
for (int i = 0; i < a.length; ++i) {
    c[i] = a[i] + b[i];
}

int[]a={0,1,2}；
int[]b={3,4,5}；
int[]c=新的int[a.长度]；
对于（int i=0；i

但是在MATLAB等语言中，您可以通过编写

c=a+b

来实现元素对元素数组的求和。在Java中有没有一种简单的方法可以做到这一点

---

想到的方法是使用Apache Commons Math中的RealVector类，但该方法相当冗长。

在该语言中肯定没有启用此功能。我也不知道标准库中有什么东西，但是把你写的代码放到一个实用方法中是很简单的，你可以在任何需要的地方调用它

c=a+b

在Java中有没有一种简单的方法可以做到这一点

不，这并不容易，因为您不能重写java中的运算符

您可以使用（正如@crush在另一条评论中所说的，[感谢他]）来支持，但这只不过是添加值：

/**
  * Sets the value of this tuple to the vector sum of itself and tuple t1.
  * @param t1  the other tuple
  */
public final void add(Tuple3d t1) {
    x += t1.x;
    y += t1.y;
    z += t1.z;
}

您可以这样使用它：

vectorC = vectorA.copy().add(vectorB);
//you need to copy the vectorA because add manipulates the object your calling it on

或者使用具有数学模型的库-

---

但是如果你想要一种高效的方法：在我看来，你的解决方案是最好的

检查此项：已使用的求和和和进位

public class SumOfTwoArrays{    

    public static int[] sumOfTwoArrays(int[] arr1, int[] arr2){

        int na = arr1.length;
        int nb = arr2.length;
        int nc;
        int min;

        if(na > nb){
            nc = na + 1;
            min = nb;
        }else{
            nc = nb + 1;
            min = na;
        }

        int[] c = new int[nc];
        int sum = 0;
        int carry = 0;
        int i = na - 1;
        int j = nb - 1;
        int k = nc - 1;

        while(i >= 0 && j>=0){
            sum  = arr1[i] + arr2[j] + carry;
            i--;
            j--;
            c[k] = sum % 10;
            sum = sum / 10;
            carry = sum % 10;
            k--;        
        }//end of while loop

        while(i >= 0){          //n2 has exhausted
            sum  = arr1[i] + carry;
            c[k] = sum % 10;
            sum = sum / 10;
            carry = sum % 10;
            i--;
            k--;
        }

        while(j >= 0){        //n1 has exhausted  
            sum  = arr2[j] + carry;
            c[k] = sum % 10;
            sum = sum / 10;
            carry = sum % 10;
            k--;        
            j--;
        }

        c[k] = carry;

        return c;
    }
}

输入： arr1={2,1,3}； arr2={3，2}

输出：

---

c:{0,2,4,5}

使用Java8流，很容易做到这一点。这种方法在添加大数组时非常有效

class TestClass {
    public static void main(String args[] ) throws Exception {
       Scanner scan = new Scanner(System.in);
       Integer arrSize = scan.nextInt();
       Integer firstArr[] = new Integer[arrSize];
       Integer secArr[] = new Integer[arrSize];
       Integer sumArr[] = new Integer[arrSize];
       for(int i = 0; i < arrSize; i++) firstArr[i] = scan.nextInt();
       for(int i = 0; i < arrSize; i++) secArr[i] = scan.nextInt();
       IntStream.range(0, arrSize).forEach(i -> sumArr[i] = firstArr[i] + secArr[i]);
       System.out.println(Arrays.asList(sumArr).stream().map(n->n.toString()).collect(Collectors.joining(" ")));
   }
}

class测试类{
公共静态void main（字符串args[]）引发异常{
扫描仪扫描=新扫描仪（System.in）；
整数arrSize=scan.nextInt（）；
整数firstArr[]=新整数[arrSize]；
整数secArr[]=新整数[arrSize]；
整数sumArr[]=新整数[arrSize]；
对于（inti=0；isumArr[i]=firstArr[i]+secArr[i]）；
System.out.println（Arrays.asList（sumArr.stream（）.map（n->n.toString（））.collect（collector.joining（“”））；
}
}

使用流并提供更通用的解决方案，再回答一个问题：

import org.junit.Assert;
import org.junit.Test;

import java.util.function.IntBinaryOperator;
import java.util.stream.IntStream;

public class SOTest {

    @Test
    public void test() {
        int[] a = {0, 1, 2};
        int[] b = {3, 4, 5};

        int[] sum = applyOn2Arrays((x, y) -> x + y, a, b);
        int[] diff = applyOn2Arrays((x, y) -> x - y, a, b);
        int[] mult = applyOn2Arrays((x, y) -> x * y, a, b);


        Assert.assertArrayEquals(new int [] {3,5,7}, sum);
        Assert.assertArrayEquals(new int [] {-3,-3,-3}, diff);
        Assert.assertArrayEquals(new int [] {0,4,10}, mult);
    }

    private int[] applyOn2Arrays(IntBinaryOperator operator, int[] a, int b[]) {
        return IntStream.range(0, a.length)
                .map(index -> operator.applyAsInt(a[index], b[index]))
                .toArray();
    }
}

---

将数组值与其数字相加，如

21+9=30

。当

9+1=10

tens place值被借用并添加到tens place。 其中，java 8的结果是

21+9=210

Array 1      +  Array 2    = Reslut Array    ~ Java8 Result

{0, 1, 2}    +  {3, 4, 9}  = [0, 3, 6, 1]    ~ [3, 5, 11]
{0, 1, 2, 1} +  {3, 4, 9}  = [0, 0, 4, 7, 0] ~ [3, 5, 11, 1]

---

将所有两个数组值转换为单个数组的简单java逻辑：

注意：第一个数组的长度必须大于第二个数组的长度

公共静态int[]arraysAddition_int（int[]a1，int[]a2）{
int=0；
int[]resultar=新int[a1.长度+1]；
对于（int i=a1.length-1，j=a2.length-1；i>=0；i--，j--）{
int n1=a1[i]；
int n2=0；
如果（j>=0）{
n2=a2[j]；
}
内部温度=n1+n2+借用；
借用=0；//添加后设为零。
如果（温度>9）{
借款=1；
温度-=10；
}
结果r[i+1]=温度；
}
如果（借用>0）{
Resultar[0]=借用；
}
System.out.format（“[%s+%s]=[%s]\n---\n”，
Arrays.toString（a1）、Arrays.toString（a2）、Arrays.toString（resultar））；
返回结果器；
}

使用Java 8：

private static int[]arraysAddition_java8（int[]a，int[]b）{
int startInclusive=0，endExclusive=Math.max（a.length，b.length）；
IntUnaryOperator mapper=index->（index

公共类测试{
公共静态void main（字符串[]args）{
int a[]={12,13,14,44}；
int b[]={11,10,15,20,50}；
int[]cs=新的int[a.length]；
System.out.println（“-------------------------”第一个表----------------------------------------------------”；
对于（int i:a）{
System.out.println（“元素：+i”）；
}
System.out.println（“-------------------------第二个表------------------------------------------”；
对于（int j:b）{
System.out.println（“元素：+j”）；
}
System.out.println（“-------------------------------表的总和-----------------------------------------------”；
如果（a.length==b.length）{
对于（int i=0，j=0，k=0；i

使用您的代码

public class Test{

    public static void main(String[] args){

        int[] a = {0, 1, 2};
        int[] b = {3, 4, 5};
        int[] c = new int[a.length];
        if(a.length==b.length) {
        for (int i = 0 ,j=0,k=0; i < a.length; i++,j++,k++) {
            c[k] = a[i] + b[j];

            System.out.println(c[k]);
        }}
        else {
            System.out.println("Should be same length in two arrays");

        }

    }

}

公共类测试{
公共静态void main（字符串[]args）{
int[]a={0,1,2}；
int[]b={3,4,5}；
int[]c=新的int[a.长度]；
如果（a.length==b.length）{
对于（int i=0，j=0，k=0；i

没有比现有的更简单的了。您不能使用Java中的标准数组，但可以查找一些matricies类。我肯定他们有你正在寻找的求和方法，这些方法也是高度优化的。@Dgrin91比他上面写的优化多了？@Dgrin91为什么你要多线程处理这个…我想如果它是一个巨大的数组，你可以将它分成块…@crush是的。。。线程假设这不是一个简单的例子。总是假设大量的输入。如果这是一个微不足道的例子，尽管线程可能会使它慢一点，但不会明显慢一点。只是我认为标准库没有元素加法之类的东西是疯狂的？对于一种像Java一样有着无数的铃铛和哨子的语言来说，这似乎是一个非常基本的缺失特性。@Peter google for operator overloading。很多人

public class Test{

    public static void main(String[] args){

        int[] a = {0, 1, 2};
        int[] b = {3, 4, 5};
        int[] c = new int[a.length];
        if(a.length==b.length) {
        for (int i = 0 ,j=0,k=0; i < a.length; i++,j++,k++) {
            c[k] = a[i] + b[j];

            System.out.println(c[k]);
        }}
        else {
            System.out.println("Should be same length in two arrays");

        }

    }

}