Wie wandelt man zweidimensionale Arrays in eindimensionale und umgekehrt?

Der Artikel erläutert Verfahren, um die Inhalte eines zweidimensionalen Ausgangsarrays in ein eindimensionales Zielarray zu überführen und umgekehrt.

Überführung vom zweidimensionalen Array in ein eindimensionales mittels Zählvariablen

Als Ausgangs-Array dient in den Beispielen ein zweidimensionales String-Array, dessen Werte die jeweiligen Indexpositionen verdeutlichen.

String[][] twoDimArr = {
    new String[] { "00", "01", "02" },
    new String[] { "10", "11", "12", "13" },
    new String[] { "20", "21", "22", "23", "24" }
};

Um ein eindimensionales Zielarray zu deklarieren, muss zunächst dessen Länge ermittelt werden. Sie ergibt sich aus der Summe der Länge der im zweidimensionalen Array gespeicherten Arrays. Mit der ermittelten Länge kann dann das Zielarray erzeugt werden.

int size = 0;
for (String[] s : twoDimArr) {
    size += s.length;
}
String[] oneDimArr = new String[size];

Mit Hilfe einer kontinuierlich inkrementierten Zählvariablen kann man die Werte eines zweidimensionalen Arrays in ein eindimensionales einlesen. Hierzu deklariert man zunächst die Hilfsvariable und initialisiert sie mit 0. Man durchläuft anschließend das Ausgangsarray innerhalb zweier geschachtelten Schleifen und übergibt die ausgelesenen Werte dem eindimensionalen Array. Als Zählvariable verwendet man dabei die Hilfsvariable, die bei jedem Durchlauf der inneren Schleife inkrementiert wird.

int counter = 0;
for (int i = 0; i < twoDimArray.length; i++) {
    for (int j = 0; j < twoDimArray[i].length; j++) {
        oneDimArray[counter] = twoDimArray[i][j];
        counter++;
    }
}

Eine Variante dieses Vorgehens besteht darin, nach jedem abgeschlossenen äußeren Schleifendurchlauf, die Länge des soeben in der inneren Schleife durchlaufenen Arrays zu einer mit 0 initialisierten Variablen zu addieren. Sie wird dann mit der hinzuaddierten Zählvariablen der inneren Schleife als Index für die Positionen des eindimensionale Zielarrays verwendet.

int size = 0;
for (int i = 0; i < twoDimArray.length; i++) {
    for (int j = 0; j < twoDimArray[i].length; j++) {
        oneDimArr[size + j] = twoDimArray[i][j];
    }
    size += mArr[i].length;
}

Überführung eines zweidimensionalen Arrays in ein eindimensionales mittels ArrayList

Das Prinzip besteht darin, das zweidimensionale Array zu durchlaufen, die ausgelesenen Werte in einer ArrayList zwischenzuspeichern und diese nach Abschluss in ein Array zu konvertieren.

ArrayList<String> tmp = new ArrayList<String>();
for (int i = 0; i < twoDimArray.length; i++) {
    for (int j = 0; j < twoDimArray[i].length; j++) {
        tmp.add(s[i][j]);
    }
}
String[]<String> oneDimArray = (String[]) tmp.toArray(new String[tmp.size()]);

→ Lauffähiger Quelltext

Überführung eines eindimensionalen Arrays in ein zweidimensionales

Um das zweidimensionale Zielarray zu deklarieren, muss dessen Struktur festgelegt werden. Unterscheiden sich die Längen der gespeicherten Arrays, wird sinnvollerweise zunächst ein Hilfsarray mit deren Längen definiert. Es dient dazu, die im zweidimensionalen Array gespeicherten eindimensionalen Arrays innerhalb einer Schleife zu deklarieren und ins Hauptarray einzufügen.

int[] arrLengths = {3, 4, 5};
String[][] twoDimArr = new String[arrLengths.length][];
for(int i = 0; i < arrLengths.length ; i++) {
    twoDimArr[i] = newString[arrLengths[i]];
}

Als Ausgangsarray dient das oben verwendete eindimensionale String-Array.

String[] oneDimArr = new String[] {"00", "01", "02", "10", "11", "12", "13", "20", "21", "22", "23", "24"};

Das leer gebildete zweidimensionale Array wird auf die übliche Weise in einer doppelten Schleife durchlaufen und die aus dem eindimensinalen Ausgangsarray ausgelesenen Werte werden der Reihe nach übernommen. Der Einfachheit halber wird als Zählvariable des eindimensionalen Arrays eine Hilfsvariable verwendet. Sie wird durch die jeweilige Länge der Unterarrays und die Zählvariable der inneren Schleife inkrementiert.

int index = 0;
for (int i = 0; i < twoDimArr.length; i++) {
    for (int j = 0; j < twoDimArr[i].length; j++) {
        twoDimArr[i][j] = oneDimArr[index + j];
    }
    index += twoDimArr[i].length;
}

→ Lauffähiger Quelltext

Lauffähiger Quelltext: zweidimensionales Array zu eindimensionalem Array

import java.util.ArrayList;

public class TwoDimToOneDimArray {

    public static void main(String[] args) {

        String[][] twoDimArr = { new String[] { "00", "01", "02" }, new String[] { "10", "11", "12", "13" },
                new String[] { "20", "21", "22", "23", "24" } };

        int size = 0;
        for (String[] s : twoDimArr) {
            size += s.length;
        }

        String[] oneDimArr = new String[size];

        print(convertArrayByArraList(twoDimArr));
        System.out.println();
        print(convertArrayByCounter(oneDimArr, twoDimArr));
        System.out.println();
        print(convertArrayBySize(oneDimArr, twoDimArr));
    }

    private static String[] convertArrayByArraList(String[][] twoDimArray) {
        if(twoDimArray == null) return null;
        ArrayList<String> tmp = new ArrayList<String>();
        for (int i = 0; i < twoDimArray.length; i++) {
            for (int j = 0; j < twoDimArray[i].length; j++) {
                tmp.add(twoDimArray[i][j]);
            }
        }
        return (String[]) tmp.toArray(new String[tmp.size()]);
    }

    private static String[] convertArrayByCounter(String[] oneDimArray, String[][] twoDimArray) {
        if(oneDimArray == null || twoDimArray == null) return null;
        int counter = 0;
        for (int i = 0; i < twoDimArray.length; i++) {
            for (int j = 0; j < twoDimArray[i].length; j++) {
                oneDimArray[counter] = twoDimArray[i][j];
                counter++;
            }
        }
        return oneDimArray;
    }

    private static String[] convertArrayBySize(String[] oneDimArray, String[][] twoDimArray) {
        if(oneDimArray == null || twoDimArray == null) return null;
        int size = 0;
        for (int i = 0; i < twoDimArray.length; i++) {
            for (int j = 0; j < twoDimArray[i].length; j++) {
                oneDimArray[size + j] = twoDimArray[i][j];
            }
            size += twoDimArray[i].length;
        }
        return oneDimArray;
    }

    private static void print(String[] arr) {
        if( arr == null) return;
        for (String str : arr) {
            System.out.println(str);
        }
    }
}

Lauffähiger Quelltext: eindimensionales Array zu zweidimensionalem Array

public class OneDimToTwoDimArray {

    public static void main(String[] args) {
        
        String[] oneDimArr = new String[] { "00", "01", "02", "10", "11", "12", "13", "20", "21", "22", "23", "24" };
        int[] arrLengths = { 3, 4, 5 };
        String[][] twoDimArr = new String[arrLengths.length][];
        for (int i = 0; i < arrLengths.length; i++) {
            twoDimArr[i] = new String[arrLengths[i]];
        }

        int index = 0;
        for (int i = 0; i < twoDimArr.length; i++) {
            for (int j = 0; j < twoDimArr[i].length; j++) {
                twoDimArr[i][j] = oneDimArr[index + j];
            }
            index += twoDimArr[i].length;
        }
        print(twoDimArr);
    }

    private static void print(String[][] twoDimArr) {
        if(twoDimArr == null) return;
        for (int i = 0; i < twoDimArr.length; i++) {
            System.out.println("Array " + i);
            for (int j = 0; j < twoDimArr[i].length; j++) {
                System.out.println(twoDimArr[i][j]);
            }
        }
    }
}