在
Java中添加两个n维数组
addVectors
可以像这样添加Java中的两个1维数组/向量：
public static int[] addVectors( int[] a,int[] b )
{
int[] c = new int[a.length];
for ( int i = 0; i < a.length; i++ )
{
c[i] = a[i] + b[i];
}
return c;
}
addMatrices
可以像这样添加Java中的两个二维数组/矩阵：
public static int[][] addMatrices( int[][] a,int[][] b )
{
int[][] c = new int[a.length][a[0].length];
for ( int i = 0; i < a.length; i++ )
{
c[i] = addVectors( a[i],b[i] );
}
return c;
}
这两个函数都要求数组具有相同的大小以避免arrayOutOfBoundsException.
addArraysN
应该有一种方法可以使用递归添加两个未知维度的数组.
例如,以下代码使用假设函数addArraysN(arr1,arr2)
int[][][] a = {
{ { 1,1,1 },{ 1,1 } },{ { 1,1 } }
};
int[][][] b = {
{ { 2,2,2 },{ 2,2 } },{ { 2,2 } }
};
int[][][] sum = addArraysN( a,b );
System.out.println( java.util.Arrays.deepToString( sum ) );
应该输出
[[[3,3,3],[3,3]],[[3,3]]]
现在我想知道如何实现这个函数addArraysN(arr1,arr2).
我开始使用以下伪代码：
addArraysN( arr1,arr2 )
{
int dimension = getDimension( arr1 );
if ( dimension == 0 ) //there are no arrays,only numbers
return arr1 + arr2;
else
{
//create a new arrays with the same dimension and size as arr1 / arr2
//loop through the fields with for
//call itself when adding the fields of arr1 and arr2
//return the sum
}
}
可以使用java.lang.reflect.Array中的newInstance方法创建新数组.
循环可以像这样：
for ( int i = 0; i < ((int[])arr1).length; i++ )
sum = addArraysN( ((int[])arr1)[i],((int[])arr2)[i] );
题
但我偶然发现了许多运行时错误和其他问题.有没有人知道如何实现这个addArrayN方法的想法甚至解决方案？
它也应该可以使用ArrayList或任何其他类,但我主要感兴趣的是如何使用数组…(但如果有人知道它请发布！)
提前致谢
附录1
我原来的代码：
import java.util.Arrays;
import java.lang.reflect.Array;
public class ArrayN
{
public static void main( String[] args )
{
//Vector
int[] vector1 = {0,4};
int[] vector2 = {4,0};
int[] vector3 = ArrayN.addVectors( vector1,vector2 );
for ( int num : vector3 )
{
System.out.print( num );
}
System.out.println();
System.out.println();
//Matrix
int[][] matrix1 = {{0,4},{4,0}};
int[][] matrix2 = {{4,0},{0,4}};
int[][] matrix3 = ArrayN.addMatrices( matrix1,matrix2 );
for ( int[] vector : matrix3 )
{
for ( int num : vector )
{
System.out.print( num );
}
System.out.println();
}
System.out.println();
//N-Array
System.out.println( Arrays.deepToString( (Object[])ArrayN.addArraysN( (Object)matrix1,(Object)matrix2,5 ) ) );
}
public static int[] addVectors( int[] a,int[] b )
{
int[] c = new int[a.length];
for ( int i = 0; i < a.length; i++ )
{
c[i] = a[i] + b[i];
}
return c;
}
public static int[][] addMatrices( int[][] a,int[][] b )
{
int[][] c = new int[a.length][a[0].length];
for ( int i = 0; i < a.length; i++ )
{
c[i] = ArrayN.addVectors( a[i],b[i] );
}
return c;
}
public static Object addArraysN( Object arrayN1,Object arrayN2,int dimension,int innerlength )
{
if ( dimension == 0 )
{
return (int)arrayN1 + (int)arrayN2;
}
else
{
int[] dimensions = new int[dimension];
for ( int i = 0; i < dimension; i++ )
{
dimensions[i] = innerlength;
}
Object arrayN3 = Array.newInstance( Array.class,dimensions );
for ( int i = 0; i < Array.getLength( arrayN1 ); i++ )
{
Array.set( arrayN3,i,ArrayN.addArraysN( Array.get( arrayN1,i ),Array.get( arrayN2,dimension-1,innerlength ) );
}
return arrayN3;
}
}
}
输出：
44444
44444
44444
Exception in thread "main" java.lang.IllegalArgumentException: array element type mismatch
at java.lang.reflect.Array.set(Native Method)
at ArrayN.addArraysN(ArrayN.java:85)
at ArrayN.addArraysN(ArrayN.java:85)
at ArrayN.main(ArrayN.java:41)
附录2
我发现了错误.它是以下行：
Object arrayN3 = Array.newInstance( Array.class,dimensions );
我不得不用int.class替换Array.class.更正后的行应为：
Object arrayN3 = Array.newInstance( int.class,dimensions );
现在我意识到代码有另一个问题：
由于innerlength参数,多维数组中的每个数组必须具有相同的大小.如果数组较短,则其他值变为零：
44444 44444 44444 [[4,4,4],[4,[0,0],0]]
所以我首先使matrix1和matrix2更长一些：
//Matrix
int[][] matrix1 = {{0,4}};
int[][] matrix2 = {{4,0}};
但这不是一个好的解决方案.
Nikoloz写了一个方法来找出数组的维数.使用它和另一个方法arrayToString(Object)我现在编写了我的最终代码：
import java.util.Arrays;
import java.lang.reflect.Array;
import java.util.List;
import java.util.ArrayList;
public class ArrayN
{
public static void main( String[] args )
{
int[][] matrix1 = {{0,4}};
System.out.println( ArrayN.arrayToString( ArrayN.addArraysN( matrix1,matrix2 ) ) );
}
public static Object addArraysN( Object arrayN1,Object arrayN2 )
{
ArrayList<Integer> dimensions = new ArrayList<Integer>();
ArrayN.getDimensions( arrayN1,dimensions );
int[] dims = new int[dimensions.size()];
for ( int i = 0; i < dims.length; i++ )
{
dims[i] = dimensions.get( i );
}
if ( dims.length == 0 )
{
return (int)arrayN1 + (int)arrayN2;
}
else
{
Object arrayN3 = Array.newInstance( int.class,dims );
for ( int i = 0; i < Array.getLength( arrayN1 ); i++ )
{
Array.set( arrayN3,i ) ) );
}
return arrayN3;
}
}
public static void getDimensions( Object array,List<Integer> dimensions )
{
if ( array != null && array.getClass().isArray() )
{
dimensions.add( Array.getLength( array ) );
if ( Array.getLength( array ) > 0)
{
ArrayN.getDimensions( Array.get( array,0 ),dimensions );
}
}
}
public static String arrayToString( Object arr )
{
if ( arr instanceof byte[] )
return Arrays.toString( (byte[])arr );
else if ( arr instanceof short[] )
return Arrays.toString( (short[])arr );
else if ( arr instanceof int[] )
return Arrays.toString( (int[])arr );
else if ( arr instanceof long[] )
return Arrays.toString( (long[])arr );
else if ( arr instanceof float[] )
return Arrays.toString( (float[])arr );
else if ( arr instanceof double[] )
return Arrays.toString( (double[])arr );
else if ( arr instanceof char[] )
return Arrays.toString( (char[])arr );
else if ( arr instanceof boolean[] )
return Arrays.toString( (boolean[])arr );
else
return Arrays.deepToString( (Object[])arr );
}
}
另一种可能性是将维度1作为基本情况：
public static Object addArraysN( Object arrayN1,Object arrayN2 )
{
ArrayList<Integer> dimensions = new ArrayList<Integer>();
ArrayN.getDimensions( arrayN1,dimensions );
int[] dims = new int[dimensions.size()];
for ( int i = 0; i < dims.length; i++ )
{
dims[i] = dimensions.get( i );
}
if ( dims.length == 1 )
{
Object arrayN3 = Array.newInstance( int.class,dims );
for ( int i = 0; i < Array.getLength( arrayN1 ); i++ )
{
int sum = ((int[])arrayN1)[i] + ((int[])arrayN2)[i];
Array.set( arrayN3,sum );
}
return arrayN3;
}
else
{
Object arrayN3 = Array.newInstance( int.class,dims );
for ( int i = 0; i < Array.getLength( arrayN1 ); i++ )
{
Array.set( arrayN3,(int[])ArrayN.addArraysN( Array.get( arrayN1,i ) ) );
}
return arrayN3;
}
}
相关问题
How to sum arrays in Java
Is it possible to dynamically build a multi-dimensional array in Java?
Iterating over arrays by reflection
Java Reflection – Get size of array object
Creating an n-dimension Array in Java during runtime
Initialising a multidimensional array in Java
finding sum of two dimensional array java
Adding matrices Java
Java Matrices Arrays
解决方法
这是完整而简单的解决方案.您可以将任何维数组传递给copyArray方法.
package com.azry.test;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
public class MultiDimArray {
public Object copyArray(Object srcArray1,Object srcArray2) {
ArrayList<Integer> dimensions = new ArrayList<Integer>();
getDimensions(srcArray1,dimensions);
int[] dims = new int[dimensions.size()];
for (int i = 0; i < dims.length; i++) {
dims[i] = dimensions.get(i);
}
Object dstArray = Array.newInstance(int.class,dims);
copyArray(srcArray1,srcArray2,dstArray);
return dstArray;
}
public void copyArray(Object srcArray1,Object srcArray2,Object dstArray) {
if (srcArray1 != null && srcArray1.getClass().isArray()) {
if (srcArray1 instanceof int[]) {
int[] s1 = (int[])srcArray1;
int[] s2 = (int[])srcArray2;
int[] d = (int[])dstArray;
for (int i = 0; i < s1.length; i++) {
d[i] = s1[i] + s2[i];
}
}
for (int i = 0; i < Array.getLength(srcArray1); i++) {
copyArray(Array.get(srcArray1,i),Array.get(srcArray2,Array.get(dstArray,i));
}
}
}
public void getDimensions(Object array,List<Integer> dimensions) {
if (array != null && array.getClass().isArray()) {
dimensions.add(Array.getLength(array));
if (Array.getLength(array) > 0) {
getDimensions(Array.get(array,0),dimensions);
}
}
}
public static void main(String[] args) {
int[][][] srcArray1 = new int[2][3][4];
for (int i = 0; i < srcArray1.length; i++) {
for (int j = 0; j < srcArray1[i].length; j++) {
for (int k = 0; k < srcArray1[i][j].length; k++) {
srcArray1[i][j][k] = 2;
}
}
}
int[][][] srcArray2 = new int[2][3][4];
for (int i = 0; i < srcArray2.length; i++) {
for (int j = 0; j < srcArray2[i].length; j++) {
for (int k = 0; k < srcArray2[i][j].length; k++) {
srcArray2[i][j][k] = 3;
}
}
}
int[][][] dstArray = (int[][][])new MultiDimArray().copyArray(srcArray1,srcArray2);
for (int i = 0; i < dstArray.length; i++) {
for (int j = 0; j < dstArray[i].length; j++) {
for (int k = 0; k < dstArray[i][j].length; k++) {
System.out.println("[" + i + "," + j + "," + k + "] = " + dstArray[i][j][k]);
}
}
}
}
}