Datentypen Wie kann ich die Längen der unterschiedlichen Ebenen aus einem Objekt lesen von dem ich weiß, dass es ein mehrdimensionaler Array ist?

E

eclipseworker

Bekanntes Mitglied
Ich weiß, dass die Dimensionen von eines mehrdimensionalen Arrays mit entsprechend geschachtelten Schleifen ausgelesen werden können und ich habe sogar einen Code gefunden mit ich die Anzahl der Array-Dimensionen aus einem Objekt raus lesen kann, aber wie finde ich die einzelnen Größen der Einzelnen Layers?

Was ich bisher habe:
Java:
import java.util.*;

public class Test {
    public static HashMap<String, List<Integer>> getNumberOfDimensions(Object array) {
        Class<?> type=array.getClass();
        HashMap<String, List<Integer>> ret=new HashMap<>();
        int dim=0;
        List<Integer> addDim=new ArrayList<>();
        Object temp=array;
        Object temp2;
        while (null!=type.getComponentType()) {
            for(int i=0; i<((Object[])temp).length; i++){
                temp2=((Object[])temp)[i];
                if(null!=temp2.getClass().getComponentType()){
                    addDim.add(((Object[])temp2).length);
                }
            }
            ret.put(""+dim, addDim);
            addDim=new ArrayList<>();
            type=type.getComponentType();
            dim++;
        }
        List<Integer> dimL=new ArrayList<>();
        dimL.add(dim);
        ret.put("dim", dimL);
        return ret;
    }

    public static void main(String[] args) {
        Integer[][][] arr3={{{1, 2}, {3}}, {{4, 5, 6}, {7, 8}}};
        Integer[][] arr2={{1, 2, 3}, {1, 2, 3}};
        Integer[][][][] arr4={{{{1}, {2}}, {{3}}}, {{{1}, {2}}}};
        Integer arr0=1;
        System.out.println(getNumberOfDimensions(arr3));
        System.out.println(getNumberOfDimensions(arr2));
        System.out.println(getNumberOfDimensions(arr4));
        System.out.println(getNumberOfDimensions(arr0));
    }
}
Ok was genau ich mir da erwarte weiß ich selbst noch nicht so, vermutlich für arr3 etwas wie so:
dim=[3], 0=[2, 2], 1=[2, 1, 3, 2]
Also einfach, dass die Liste bei 0 alle Längen raus bekomme welche welche ich bekommen würde durch
array[0].length, array[1].length usw.
unter 1
alle Werte die wir mit array[0][0].length, array[0][1].length, ..., array[0][n].length, ...., array[m][n].length
unter 2 alle Werte von
array[0][0][0].length, array[0][0][1].length, ..., array[0][0][n].length,array[0][1][0].length, ...., array[m][n][o].length
usw.
Meine Momentane Ausgabe ist etwas buckig, nur die Dimesionszahl stimmt:
Code:
{0=[2, 2], 1=[2, 2], 2=[2, 2], dim=[3]}
{0=[3, 3], 1=[3, 3], dim=[2]}
{0=[2, 1], 1=[2, 1], 2=[2, 1], 3=[2, 1], dim=[4]}
{dim=[0]}
Außerdem scheint der Code primitiven Datentypen Probleme zu haben, eine Ahnung warum?
 
mihe7

mihe7

Top Contributor
Du sprichst in Rätseln. Meinst Du etwas in der Richtung?

Java:
import java.lang.reflect.Array;
import java.util.Stack;

public class Test {
    public static void printLengths(String varName, Object arr) {
        class Helper { int depth; Object value;
               Helper(int d, Object v) { depth= d; value = v; } };

        Stack<Helper> todo = new Stack<>();
        todo.push(new Helper(0, arr));

        while (!todo.isEmpty()) {
            Helper h = todo.pop();
            Object cur = h.value;
            if (cur != null && cur.getClass().isArray()) {
                int len = Array.getLength(cur);
                System.out.println(varName + "[]".repeat(h.depth) +
                                   ".length == " +len);
                for (int i = 0; i < len; i++) {
                    todo.push(new Helper(h.depth+1, Array.get(cur, i)));
                }
            }
        }
    }

    public static void main(String[] args) {
        Integer[][][] arr3={{{1, 2}, {3}}, {{4, 5, 6}, {7, 8}}};
        printLengths("arr3", arr3);
    }
}
 
E

eclipseworker

Bekanntes Mitglied
Du sprichst in Rätseln. Meinst Du etwas in der Richtung?

Java:
import java.lang.reflect.Array;
import java.util.Stack;

public class Test {
    public static void printLengths(String varName, Object arr) {
        class Helper { int depth; Object value;
               Helper(int d, Object v) { depth= d; value = v; } };

        Stack<Helper> todo = new Stack<>();
        todo.push(new Helper(0, arr));

        while (!todo.isEmpty()) {
            Helper h = todo.pop();
            Object cur = h.value;
            if (cur != null && cur.getClass().isArray()) {
                int len = Array.getLength(cur);
                System.out.println(varName + "[]".repeat(h.depth) +
                                   ".length == " +len);
                for (int i = 0; i < len; i++) {
                    todo.push(new Helper(h.depth+1, Array.get(cur, i)));
                }
            }
        }
    }

    public static void main(String[] args) {
        Integer[][][] arr3={{{1, 2}, {3}}, {{4, 5, 6}, {7, 8}}};
        printLengths("arr3", arr3);
    }
}
Ja, super danke dieser Code scheint genau das zu machen was ich will, danke! Ich muss mich dann ein bisschen in diese Stack-Klasse einlesen.
Ähm da ich den Code zu erst auf einen Online-Compiler ausprobiert habe, der offenbar etwas älteres Java hat, habe ich
"[]".repeat(h.depth) mit new String(new char[h.depth]).replace("\0", "[]") ersetzt ist aber gut gegangen und sogar mit einem primitiven int-Array. Das einzige was jetzt noch cool wäre, wären Zähler, so, dass es nicht heißt arr3[][].length == 2, sondern arr3[0][1].length == 2 für maximale Klarheit.
 
mihe7

mihe7

Top Contributor
Den Stack habe ich einfach statt rekursiven Aufrufen verwendet. Geht rekursiv schöner.

Können wir ja schnell machen. Wenn das übergebene Objekt kein Array ist, soll nichts ausgegeben werden und die Rekursion ist beendet. Ansonsten wird der übergebene Präfix, gefolgt von ".length" und der Länge des Arrays ausgegeben. Für jedes Element im Array muss lediglich der Präfix entsprechend angepasst werden.

Java:
    public static void printLengths(String prefix, Object arr) {
        if (arr != null && arr.getClass().isArray()) {
            int len = Array.getLength(arr);
            System.out.println(prefix + ".length == " + len);
            for (int i = 0; i < len; i++) {
                printLengths(String.format("%s[%d]", prefix, i),
                             Array.get(arr, i));
            }
        }
    }
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
M 2D Array mit unterschiedlichen Längen erstellen und befüllen Allgemeine Java-Themen 11
C Kombinationen von ArrayListen mit unterschiedlichen Längen Allgemeine Java-Themen 7
J Best Practice Umgang mit unterschiedlichen Tasks Allgemeine Java-Themen 2
Z Array mit unterschiedlichen Werten Allgemeine Java-Themen 1
S Probleme mit unterschiedlichen Java-Versionen (Mac OS X 10.11) Allgemeine Java-Themen 0
Viktim Threads Liste In unterschiedlichen Threads bearbeiten Allgemeine Java-Themen 23
C Deserialisieren von unterschiedlichen Klasseninstanzen Allgemeine Java-Themen 13
Y inhalte aus 2 unterschiedlichen Arrays miteinander vergleichen Allgemeine Java-Themen 12
D Problem mit unterschiedlichen FontMetrics Allgemeine Java-Themen 1
K JNI: Methoden aus unterschiedlichen Threads aufrufen Allgemeine Java-Themen 3
Gossi Threads mit unterschiedlichen Aufgaben in einer Klasse? Allgemeine Java-Themen 9
J Jars in unterschiedlichen Versionen Allgemeine Java-Themen 14
A Unterschiedlicher Objektgebrauch in unterschiedlichen ActionListenern Allgemeine Java-Themen 7
H2SO3- csv Datei mit unterschiedlichen Formatierungen einlesen Allgemeine Java-Themen 15
A Probleme mit der unterschiedlichen Bildschirmeinstellungen Allgemeine Java-Themen 4
S Methoden aus Interfaces mit unterschiedlichen Parametertypen Allgemeine Java-Themen 7
P Java 3D parallele Ebenen Allgemeine Java-Themen 4
P Java3D mehrere Ebenen parallel zu yz-Ebene Allgemeine Java-Themen 9
T Klassendesign - Hierarchie Ebenen Allgemeine Java-Themen 15

Ähnliche Java Themen

Anzeige

Neue Themen


Oben