10

Javaでは、さまざまな次元の配列にはさまざまなタイプがあります。したがって、int[]パラメータとして受け取るメソッドは、int[][]またはをとることはできません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);
    }
}

...等

于 2012-05-27T03:13:50.393 に答える
2

型の安全性を無視したい場合は、少しの再帰 (ここで驚きはありませんよね?) とリフレクションを使用してそれを行うことができます。

アイデアは、配列が 1 つの次元だけになるまで再帰的にメソッドを記述することです。1 次元レベルになったら、作業を行います。それ以外の場合は、自分自身を再帰的に呼び出し、必要に応じて前のレベルからの結果を集計します。

簡単なデモを次に示します。

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 が配列を処理する方法が原因で、この 2 つは基本的に異なる型であり、単一のコードで任意の次元の配列を処理する適切な方法は実際にはありません。

于 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
}

警告:

  • これは、計算がこのように機能する場合にのみ機能します。

  • メソッドごとにこの醜いボイラープレートを繰り返す必要があり、

  • ボイラープレートは、実際には 3 つの別々の方法を使用するよりも悪い可能性があります。

ここで、計算 (およびパフォーマンス要件) に応じて、一般化された「すべての要素に適用」メソッドに渡すことができるオブジェクトで計算を行うことにより、コードを一般化できる場合があります。例えば

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 に答える