Wie programmgesteuert in Java auf mehrdimensionales Array zugreifen?

Question

Angenommen, wir haben ein mehrdimensionales Array und die Anzahl der Dimensionen ist nur zur Laufzeit bekannt. Und angenommen, wir haben eine ganzzahlige Anzahl von Indizes.

Wie Indizes auf das Array angewendet werden, um auf das Array-Element zuzugreifen?

UPDATE

Angenommen:

int [] indices = new int { 2, 7, 3, ... , 4}; // indices of some element 
int X = indices.length; // number of dimensions 
Object array = .... // multidimensional array with number of dimensions X 

... 

Ich möchte das Element durch Indizes indices von array adressiert holen.

UPDATE 2

ich folgenden Code geschrieben, basierend auf Rekursion:

package tests; 

import java.util.Arrays; 

public class Try_Multidimensional { 

    private static int element; 

    public static int[] tail(int[] indices) { 
     return Arrays.copyOfRange(indices, 1, indices.length); 
    } 


    public static Object[] createArray(int ... sizes) { 

     Object[] ans = new Object[sizes[0]]; 

     if(sizes.length == 1) { 
      for(int i=0; i<ans.length; ++i) { 
       ans[i] = element++; 
      } 
     } 

     else { 
      for(int i=0; i<ans.length; ++i) { 
       ans[i] = createArray(tail(sizes)); 
      } 
     } 

     return ans; 

    } 

    public static Object accessElement(Object object, int ... indices) { 

     if(object instanceof Object[]) { 

      Object[] array = (Object[]) object; 

      return accessElement(array[indices[0]], tail(indices)); 

     } 

     else { 
      return object; 
     } 

    } 

    public static void main(String[] args) { 

     element = 0; 
     Object array = createArray(4, 5, 12, 7); 

     System.out.println(accessElement(array, 0, 0, 0, 0)); 
     System.out.println(accessElement(array, 0, 0, 0, 1)); 
     System.out.println(accessElement(array, 1, 0, 10, 0)); 
     try { 
      System.out.println(accessElement(array, 0, 5, 0, 1)); 
     } 
     catch(Exception e) { 
      System.out.println(e.toString()); 
     } 

    System.out.println(4*5*12*7-1); 
    System.out.println(accessElement(array, 3, 4, 11, 6)); 

    } 

} 

Die Fragen sind:

1) gibt es keine zuverlässigen fertige Methoden von JDK und/oder berühmte Bibliotheken dafür?

2) Ich habe Object verwendet. Kann es vermieden werden? Kann ich ein Array mit variabler Dimensionalität mit eingebautem oder spezifischem Typ erstellen/darauf zugreifen? Wie groß ist eine Auszahlung aufgrund der Verwendung von Object?

Answer 1

int index(Object arrayToIndex, int... indices) { 
    for (int i = 0; i < indices.length - 1; i++) { 
     arrayToIndex = ((Object[]) arrayToIndex)[indices[i]]; 
    } 
    return ((int[]) arrayToIndex)[indices[indices.length-1]]; 
} 

Durchlaufen Sie die Dimensionen und indizieren Sie jede Dimension nacheinander. Die Umwandlungen und der Sonderfall für die letzte Dimension werden nervig sein, daher empfehle ich, dies in eine Art n-dimensionale Array-Klasse zu verpacken. (It looks like some options already exist.)

Answer 2

Sie können die Größe jeder Dimension als einzelne Arrays entdecken (denn das ist, was sie sind):

public void someMEthod(int[][][] matrix) { 
    int d1 = matrix.length; 
    int d2 = 0; 
    int d3 = 0; 
    if(d1 > 0) { 
     d2 = matrix[0].length; 
     if(d2 > 0) { 
      d3 = matrix[0][0].length; 
     } 
    } 
    System.out.println("Dimension 1 is " + d1); 
    System.out.println("Dimension 2 is " + d2); 
    System.out.println("Dimension 3 is " + d3); 
} 

Ich hoffe, das hilft.

Answer 3

Ich fand eine Art Spaß, es mit Reflektion zu tun. Dies ist nur ein Code, den ich zusammengeworfen habe, aber du könntest ihn in eine Klasse einpacken und alles schön machen.

// build and fill an array to the given depth 
public static Object[] constructArray(Object[] array, int depth) { 
    if(depth == 0) 
     return null; 

    for(int i=0;i<array.length;i++) { 
     Array.set(array, i, constructArray(new Object[array.length], depth-1)); 
    } 
    return array; 
} 

// sets a value in the multi dimensional array using the indicies 
public static void setArrayUsingIndecies(Object array, int[] indicies, Object value) { 
    if(indicies.length == 0) 
     return; 

    for(int i=0;i<indicies.length-1;i++) { 
     array = Array.get(array, indicies[i]); 
    } 

    Array.set(array, indicies[indicies.length-1], value); 
} 

// gets a value in the multi dimmensional array using the indicies 
public static Object getArrayUsingIndecies(Object array, int[] indicies) { 

    Object value = array; 
    for(int i=0;i<indicies.length;i++) { 
     value = Array.get(value, indicies[i]); 
    } 

    return value; 
} 

Heres ein bisschen Beispielcode

int numberOfDimmensions = 2; 

Object array = constructArray(new Object[numberOfDimmensions], numberOfDimmensions); 

int [] indices = new int [] { 0, 1 }; 
setArrayUsingIndecies(array, indices, "Hello"); 
System.out.println(getArrayUsingIndecies(array, indices)); // Hello 
indices = new int [] { 0, 0 }; 
System.out.println(getArrayUsingIndecies(array, indices)); // null 

Answer 4

Ist es einfacher, als wir denken? Wie über diesen Ansatz:

int [] indices = new int { 2, 7, 3, ... , 4}; // indices of some element 
int X = indices.length; // number of dimensions 
Object array = new Object[X].... // multidimensional array with number of dimensions X 

und dann:

Object myObject = array[indices[1]] // myObject references the 7th element of array 

Sie haben allerdings sicherstellen, dass Ihre Indizes Array keine Zahl größer als die Größe der Indizes enthält - 1. Zum Beispiel

indices = new int [5,4,3,2,1] // ok 
indices = new int [6,4,3,2,1] // not ok, because you would access the 6th Element in an arry with length 5