时代Java，与您同行！关注微信公众号，关注前沿技术，微信搜索：nowjava或时代Java，也可点击这里扫码关注

时代Java

Java 减去两个整数数组元素中的值

欢马劈雪

工程师 (已认证)

原创分享签约作者

发表于实例源码

433

将两个整数数组中的值逐元素相减。

实例源码：

源代码：

执行

执行中...

// 来 自 时代Java公众号 - nowjava.com

//package com.nowjava;

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(subtractElementwise(a,

b)));

}

/**

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

* @param a   Array of integers.

* @param b   Array of integers.

* @return   Result of element-wise subtraction of arrays.

* @throws ArithmeticException   Throws exception when the arrays differ in

* length.

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

throws ArithmeticException {

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

throw new ArithmeticException();
            /** from 
            时 代      J a v a   公   众 号 - nowjava.com**/

} else {

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

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

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

}

return result;

}

/**

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

* @param a   Array of doubles.

* @param b   Array of doubles.

* @return   Result of element-wise subtraction of arrays.

* @throws ArithmeticException   Throws exception when the arrays differ in

* length.

public static double[] subtractElementwise(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;

}

/**

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

* @param a   Array of longs.

* @param b   Array of longs.

* @return   Result of element-wise subtraction of arrays.

* @throws ArithmeticException   Throws exception when the arrays differ in

* length.

public static long[] subtractElementwise(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;

}

/**

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

* @param a   Array of floats.

* @param b   Array of floats.

* @return   Result of element-wise subtraction of arrays.

* @throws ArithmeticException   Throws exception when the arrays differ in

* length.

public static float[] subtractElementwise(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;

}

/**

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

* @param a   Array of bytes.

* @param b   Array of bytes.

* @return   Result of element-wise subtraction of arrays.

* @throws ArithmeticException   Throws exception when the arrays differ in

* length.

public static byte[] subtractElementwise(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;

}

/**

* Subtracts the values in an array of doubles and and array of integers

* element-wise.

* @param a   Array of doubles.

* @param b   Array of integers.

* @return   Result of element-wise subtraction of arrays.

* @throws ArithmeticException   Throws exception when the arrays differ in

* length.

public static double[] subtractElementwise(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;

}

/**

* Subtracts the values in the two matrices 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[][] subtractElementwise(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;

}

/**

* Subtracts the values in the two matrices 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[][] subtractElementwise(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;

}

/**

* Subtracts the values in the two matrices 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[][] subtractElementwise(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;

}

/**

* Subtracts the values in the two matrices 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 long[][] subtractElementwise(long[][] a, long[][] b)

throws ArithmeticException {

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

throw new ArithmeticException();

} else {

long[][] result = new long[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;

}

/**

* Subtracts the values in the two matrices element-wise.

* @param a   Matrix of doubles.

* @param b   Matrix of doubles.

* @return   Element-wise sum of the two matrices.
/**代码未完, 请加载全部代码(NowJava.com).**/

编辑/阅读全部代码

执行结果：

本文系作者在时代Java发表，未经许可，不得转载。如有侵权，请联系nowjava@qq.com删除。

编辑于 2020-03-26 09:23:272020-03-26 09:23:27

实例源码

实例源码订阅