В Java массивы различной размерности имеют разные типы. Поэтому метод, который принимает int[]
в качестве параметра, не может принимать значения int[][]
или int[][][]
. У меня много кода, где я создаю методы, которые очень похожи, но для размерности массива. Есть ли способ обрабатывать массивы произвольной размерности и, таким образом, абстрагировать эту общую функциональность?
Абстрактная размерность массивов в Java
Ответ 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));
}
}
Ответ 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);
}
}
... и т.д.
Ответ 3
Короткий ответ - нет. Длинный ответ извиняется, но нет. Из-за того, как Java обрабатывает массивы, эти два являются принципиально разными типами, и на самом деле нет никакого хорошего способа обработки массивов любого измерения с помощью одного фрагмента кода.
Ответ 4
Ответ нет! но вы можете делать все, что хотите, только с линейными массивами.... подумайте об этом
Ответ 5
Вы можете реализовать многомерный массив, скрывая его реализацию в классе (простить или исправить мой синтаксис 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. Вы также можете добавить функции для создания индексов разных размеров.
Все это происходит по цене некоторых накладных расходов.
Ответ 6
Ответ "возможно, нет". Как указывалось в других ответах, типы массивов с разной размерностью не совместимы с назначением. Однако есть возможный выход.
Типы int[]
int[][]
и int[][][]
- все подтипы Object
. И (например) int[][]
на самом деле представляет собой массив экземпляров 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);
}
}
... но там еще много шаблонов... и вы получите удар производительности.