10

在Java中，不同维度的数组有不同的类型。因此，int[]作为参数的方法不能采用int[][]or int[][][]。我有很多代码，我在其中创建了非常相似但针对数组维度的方法。有没有办法处理任意维度的数组，从而抽象出这个通用功能？

4

6 回答 6

2

我想说你能做的最接近的事情是制作一些重载方法，它们采用数组的所有可用维度，并让它们中的每一个都调用一个具有大部分逻辑的通用方法。

public void method ( int [] i ) {  //1-d array
    //logic 
}

public void method ( int [][] i) {  //2-d array
     for (int [] j : i) {
         method(j);
     }
}

public void method ( int [][][] i) {   // 3-d array
    for ( int [][] j : i ) {
        method(j);
    }
}

...ETC

于 2012-05-27T03:13:50.393 回答
2

如果你愿意放弃类型安全，你可以通过一点递归（这并不奇怪，对吧？）和反思来做到这一点。

这个想法是以一种向下递归的方式编写您的方法，直到数组只有一个维度。一旦你处于单维级别，就开始工作；否则，递归调用自己，并在必要时汇总先前级别的发现。

这是一个快速演示：

import java.util.*;
import java.lang.*;
import java.lang.reflect.Array;

class Main {
    public static int sumArray(Object array) {
            Class type = array.getClass();
            if (!type.isArray()) {
                    throw new IllegalArgumentException("array");
            }
            Class ct = type.getComponentType();
            int res = 0;
            int len = Array.getLength(array);
            if (ct.isArray()) {
                    for (int i = 0 ; i != len ; i++) {
                            res += sumArray(Array.get(array, i));
                    }
            } else {
                    for (int i = 0 ; i != len ; i++) {
                            res += Array.getInt(array, i);
                    }
            }
            return res;
    }
    public static void main (String[] args) throws java.lang.Exception
    {
            int[] a = new int[] {1,2,3,4,5,6,7,8,9,10};
            int aa[][] = new int[][] {{1,2},{3,4},{5,6}};
            int aaa[][][] = new int[][][]{{{1,2},{3,4},{5,6}},{{7,8},{9,10},{11,12}}};
            System.out.println(sumArray(a));
            System.out.println(sumArray(aa));
            System.out.println(sumArray(aaa));
    }
}
于 2012-05-27T12:23:23.477 回答
0

最简洁的答案是不。长答案很抱歉，但没有。由于 Java 处理数组的方式，两者是根本不同的类型，实际上并没有什么好的方法可以用一段代码来处理任何维度的数组。

于 2012-05-27T03:13:36.827 回答
0

答案是不！但是你可以用线性数组做任何你想做的事情……想想看

于 2012-05-27T03:22:23.453 回答
0

您可以通过将其实现隐藏在类中来实现多维数组（请原谅或纠正我的 Java 语法，我不是 Java 编码器）：

class MultidimensionalArray<Type> {

   // Implement N-dimensional 0-origin array of <Type>

   int[] dimensions;

   Type[] body;

   MultidimensionalArray(index1: int)
   {  dimensions=new int[1];
      dimensions[0]=index1;
      body=new Type[index1];
   }

   MultidimensionalArray(index1: int, index2: int)
   {  dimensions=new int[2];
      dimensions[0]=index1;
      dimensions[1]=index2;
      body=new Type[index1*index2];
   }

   MultidimensionalArray(int[] indexes)
   {  size=1;
      dimensions=indexes;
      for(int i=0;i<indexes.size();i++) size*=indexes[i];
      body=new Type[size];
   }

   Type Get(int index1) {
      assert dimensions.size()==1;
      return body[index1];
   }

   Type Get(int index1, int index2) {
      assert dimensions.size()==2;
      return body[index1*dimensions[0]+index2];
   }

   Type Get(int[] indexes) {
      int index=indexes[0];
      assert dimensions.size()==indexes.size();
      for (int i=0;i<indexes.size();i++) index=index*dimensions[i]+indexes[i+1];
      return body[index];
   }

   void Put(int index1, Type v) {
      assert dimensions.size()==1;
      body[index1]=v;
   }

   void Put(int index1, int index2, Type v) {
      assert dimensions.size()==2;
      body[index1*dimensions[0]+index2]=v;
   }

   void Put(int[] indexes, Type v) {
      int index=indexes[0];
      assert dimensions.size()==indexes.size();
      for (int i=0;i<indexes.size();i++) index=index*dimensions[i]+indexes[i+1];
      body[index]=v;
   }

}

您可以通过调用它的构造函数来初始化它，并通过传入一个整数数组作为索引集来访问一个元素。有点笨拙但有效：

int[] mydimensions={2,3,5};
MyArray MultidimensionalArray<int>=new MultidimensionalArray(mydimensions);
... 
int[] indexset={1,2,4};
MyArray.Put(indexset,22);
...
indexset = {0,1,3};
...  MyArray.Get(indexset) ...

我为 1D 和 2D 数组添加了方便函数，它们不需要索引集，而是使用单个参数作为索引。轻松推广到维度 K 的数组。您还可以添加函数来创建不同大小的索引集。

所有这些都是以一些开销为代价的。

于 2012-05-27T03:39:15.140 回答
0

答案是“可能不会”。正如其他答案所指出的那样，具有不同维度的数组类型与分配不兼容。但是，有一个可能的出路。

类型int[] int[][]和int[][][]都是 的子类型Object。并且（例如）anint[][]实际上是一个int[]实例数组。因此，对于某些计算，可能会执行以下操作：

public void calc(Object array) {
    if (array instanceof int[]) {
        calc((int[]) array);
    } else if (array instanceof int[][]) {
        for (a int[] : (int[][]) array) {
            calc(a);
        }
    } else if (array instanceof int[][][]) {
        for (a int[][] : (int[][][]) array) {
            for (a2 int[] : a) {
                calc(a2);
            }
        }
    } else {
        throw new ClassCastException(...);  // or something more appropriate
    }
}

public void calc (int[] array) {
    // do the calculation
}

注意事项：

  • 这仅在计算以这种方式进行时才有效，

  • 您必须为每种方法重复这个丑陋的样板，并且

  • 样板文件实际上可能比使用三种不同的方法更糟糕。

现在，根据计算（和性能要求），您可以通过在可以传递给通用“应用于所有元素”方法的对象中进行计算来概括代码；例如

public interface Calc {
    public void calc(int i);
}

... 

public void doCalc(Object array, Calc calculator) {
    // as above
}

public void doCalc(int[] array, Calc calculator) {
    for (int i : array) {
        calculator.calc(i);
    }
}

......但仍然有很多样板......你会受到性能影响。

于 2012-05-27T04:50:00.430 回答