集册 Java实例教程 将两个整数数组元素中的值相加

将两个整数数组元素中的值相加

欢马劈雪     最近更新时间:2020-01-02 10:19:05

509
提示:您可在线编辑运行本教程的实例 - 运行实例,去试试!
将两个整数数组的值逐元素相加。


//package com.nowjava;
/*时代Java - N o w  J a v a . c o m 提 供*/

public class Main {

    public static void main(String[] argv) throws Exception {

        int[] a = new int[] { 34, 35, 36, 37, 37, 37, 67, 68, 69 };

        int[] b = new int[] { 34, 35, 36, 37, 37, 37, 67, 68, 69 };

        System.out.println(java.util.Arrays.toString(addElementwise(a, b)));

    }


    /**

     * Adds up the values in the two arrays of integers element-wise.

     *

     * @param a   Array of integers.

     * @param b   Array of integers.

     * @return   Element-wise sum of arrays.

     * @throws ArithmeticException   Throws an exception when the arrays differ in

     * length.

     */

    public static int[] addElementwise(int[] a, int[] b)

            throws ArithmeticException {/** 时 代 J a v a 公 众 号 - nowjava.com 提供 **/


        if (a.length != b.length) {

            throw new ArithmeticException();

        } else {

            int[] result = new int[a.length];

            for (int i = 0; i < a.length; i++) {

                result[i] = a[i] + b[i];

            }

            return result;

        }


    }


    /**

     * Adds up the values in the two arrays of doubles element-wise.

     *

     * @param a   Array of doubles.

     * @param b   Array of doubles.

     * @return   Element-wise sum of arrays.

     * @throws ArithmeticException   Throws an exception when the arrays differ in

     * length.

     */

    public static double[] addElementwise(double[] a, double[] b)

            throws ArithmeticException {


        if (a.length != b.length) {

            throw new ArithmeticException();

        } else {

            double[] result = new double[a.length];

            for (int i = 0; i < a.length; i++) {

                result[i] = a[i] + b[i];

            }

            return result;

        }


    }


    /**

     * Adds up the values in the two arrays of longs element-wise.

     *

     * @param a   Array of longs.

     * @param b   Array of longs.

     * @return   Element-wise sum of arrays.

     * @throws ArithmeticException   Throws an exception when the arrays differ in

     * length.

     */

    public static long[] addElementwise(long[] a, long[] b)

            throws ArithmeticException {


        if (a.length != b.length) {

            throw new ArithmeticException();

        } else {

            long[] result = new long[a.length];

            for (int i = 0; i < a.length; i++) {

                result[i] = a[i] + b[i];

            }

            return result;

        }


    }


    /**

     * Adds up the values in the two arrays of floats element-wise.

     *

     * @param a   Array of floats.

     * @param b   Array of floats.

     * @return   Element-wise sum of arrays.

     * @throws ArithmeticException   Throws an exception when the arrays differ in

     * length.

     */

    public static float[] addElementwise(float[] a, float[] b)

            throws ArithmeticException {


        if (a.length != b.length) {

            throw new ArithmeticException();

        } else {

            float[] result = new float[a.length];

            for (int i = 0; i < a.length; i++) {

                result[i] = a[i] + b[i];

            }

            return result;

        }


    }


    /**

     * Adds up the values in the two arrays of bytes element-wise.

     *

     * @param a   Array of bytes.

     * @param b   Array of bytes.

     * @return   Element-wise sum of arrays.

     * @throws ArithmeticException   Throws an exception when the arrays differ in

     * length.

     */

    public static byte[] addElementwise(byte[] a, byte[] b)

            throws ArithmeticException {


        if (a.length != b.length) {

            throw new ArithmeticException();

        } else {

            byte[] result = new byte[a.length];

            for (int i = 0; i < a.length; i++) {

                result[i] = (byte) (a[i] + b[i]);

            }

            return result;

        }


    }


    /**

     * Adds up the values in an array of doubles and an array of integers

     * element-wise.

     *

     * @param a   Array of doubles.

     * @param b   Array of integers.

     * @return   Element-wise sum of arrays.

     * @throws ArithmeticException   Throws an exception when the arrays differ in

     * length.

     */

    public static double[] addElementwise(double[] a, int[] b)

            throws ArithmeticException {


        if (a.length != b.length) {

            throw new ArithmeticException();

        } else {

            double[] result = new double[a.length];

            for (int i = 0; i < a.length; i++) {

                result[i] = a[i] + b[i];

            }

            return result;

        }


    }


    /**

     * Adds up two matrices of doubles element-wise.

     *

     * @param a   Matrix of doubles.

     * @param b   Matrix of doubles.

     * @return   Element-wise sum of the two matrices.

     * @throws ArithmeticException   Throws an exception when the two matrices are

     * not of the same size.

     */

    public static double[][] addElementwise(double[][] a, double[][] b)

            throws ArithmeticException {


        if (a.length != b.length || a[0].length != b[0].length) {

            throw new ArithmeticException();

        } else {

            double[][] result = new double[a.length][a[0].length];

            for (int i = 0; i < a.length; i++) {

                for (int j = 0; j < a[0].length; j++) {

                    result[i][j] = a[i][j] + b[i][j];

                }

            }

            return result;

        }


    }


    /**

     * Adds up two matrices of doubles and integers element-wise.

     *

     * @param a   Matrix of doubles.

     * @param b   Matrix of integers.

     * @return   Element-wise sum of the two matrices.

     * @throws ArithmeticException   Throws an exception when the two matrices are

     * not of the same size.

     */

    public static double[][] addElementwise(double[][] a, int[][] b)

            throws ArithmeticException {


        if (a.length != b.length || a[0].length != b[0].length) {

            throw new ArithmeticException();

        } else {

            double[][] result = new double[a.length][a[0].length];

            for (int i = 0; i < a.length; i++) {

                for (int j = 0; j < a[0].length; j++) {

                    result[i][j] = a[i][j] + b[i][j];

                }

            }

            return result;

        }


    }


    /**

     * Adds up two matrices of integers element-wise.

     *

     * @param a   Matrix of integers.

     * @param b   Matrix of integers.

     * @return   Element-wise sum of the two matrices.

     * @throws ArithmeticException   Throws an exception when the two matrices are

     * not of the same size.

     */

    public static int[][] addElementwise(int[][] a, int[][] b)

            throws ArithmeticException {


        if (a.length != b.length || a[0].length != b[0].length) {

            throw new ArithmeticException();

        } else {

            int[][] result = new int[a.length][a[0].length];

            for (int i = 0; i < a.length; i++) {

                for (int j = 0; j < a[0].length; j++) {

                    result[i][j] = a[i][j] + b[i][j];

                }

            }

            return result;

        }


    }


    /**

     * Adds up two matrices of doubles element-wise.

     *

     * @param a   Matrix of doubles.

     * @param b   Matrix of doubles.

     * @return   Element-wise sum of the two matrices.

     * @throws ArithmeticException   Throws an exception when the two matrices are

     * not of the same size.

     */

    public static float[][] addElementwise(float[][] a, float[][] b)

            throws ArithmeticException {


        if (a.length != b.length || a[0].length != b[0].length) {

            throw new ArithmeticException();

        } else {

            float[][] result = new float[a.length][a[0].length];

            for (int i = 0; i < a.length; i++) {

                for (int j = 0; j < a[0].length; j++) {

                    result[i][j] = a[i][j] + b[i][j];

                }

            }

            return result;

        }


    }


    /**

     * Adds up two matrices of longs element-wise.

     *

     * @param a   Matrix of longs.

     * @param b   Matrix of longs.

     * @return   Element-wise sum of the two matrices.

     * @throws ArithmeticException   Throws an exception when the two matrices are

     * not of the same size.

     */
展开阅读全文