Arrays kombinieren (länge eines Arrays kann 0 sein)

[Alucardd]

Hi,

ich zerbreche mir seit einiger Zeit den Kopf darüber wie ich 4 Arrays (nicht primitiver Datentyp) zu einem kombiniere. Das Problem ist, dass jedes der 4 Arrays eine länge von 0 - 8 haben kann. Für den Fall dass eines der Arrays 0 ist kann ich sie nicht in einer einfachen for schleife addieren da dann auf ein Array mit länge 0 zugegriffen wird was zu einer java.lang.NullPointerException führt.

ich kann auch nicht vor jede for schleife ein if(array.length>0) setzen,da ich ja immer genau wissen muss bei welchem Index ich weitermachen muss mit Werte addieren. gleich mit array.copy() da muss ich ja auch immer den Index im Parameter angeben.

Gibt es ne möglichkeit arrays zu kombinieren wo man nicht wissen muss bei welchem index man ansetzen muss?

 

[MisterBu]

Was genau meinst du mit kombinieren?

 

[kneitzel]

Also erst einmal verstehe ich das Problem mit der NullPointerException nicht. Ein leeres Array ist ein Array der Länge 0 und da kommt natürlich keine NullPointerException:

        int test[] = new int[0];
        for (int i=0; i<test.length; i++) {
            // Hier läuft er ja nie durch ...
        }

Somit kann es nur Probleme geben, wenn eben kein Array sondern null übergeben wird (Was dann kein Array der Länge 0 ist!).

Und bezüglich des Index: Den kannst Du doch separat hochzählen. Also sowas wie:

        int source1[] = {2, 3};
        int source2[] = { 4, 5, 6};

        int target[]= new int[source1.length + source2.length];

        int insertIndex = 0;

        for (int i=0; i<source1.length; i++, insertIndex++) {
            target[insertIndex] = source1[i];
        }

        for (int i=0; i<source2.length; i++, insertIndex++) {
            target[insertIndex] = source2[i];
        }

(Wobei die for schleife halt in eine Funktion gegeben werden kann, und als Parameter kommt target, source und insertIndex und zurück gegeben würde der insertIndex - dann hätte man den doppelten Code nicht mehr)

Bleibt also nur ggf. das Problem, dass ein Parameter null ist. Da wäre dann tatsächlich eine Validierung notwendig. Diese könnte aber z.B. wie folgt aussehen:

int checkedSource1[] = source1 != null ? source1 : new int[0];

Sprich: Die Parameter werden erst entsprechend validiert und ein null Wert würde mit einem leeren Array ersetzt. Und der ganze Code würde dann mit checkedSource1 statt source1 arbeiten (für alle Parameter).

Edit: Ich habe hier als Typ int genommen, aber das funktioniert natürlich mit allen Typen!

 

[Ullenboom]

int[] ints1 = { 0 };
int[] ints2 = { 1,2 };
int[] ints3 = { };
int[] ints4 = { 3 };

int[] ints = Stream.of(ints1, ints2, ints3, ints4).flatMapToInt(IntStream::of).toArray();
System.out.println(Arrays.toString( ints )); // [0, 1, 2, 3]

Die Arrays dürften leer, aber nicht null sein.

 

[kneitzel]

Und wenn wir gerade dabei sind, Lösungen zu geben:
Wenn man keine Streams möchte und eine generische Lösung wünscht, dann kann man das auch gerne mit Generics schreiben:

import java.util.Arrays;

public class Main {

    public static <T> T[] combineArrays( T[]... args) {
        T checkedArgs[][] = (T[][]) new Object[args.length][];
        int targetSize = 0;
        for (int i=0; i<args.length; i++) {
            checkedArgs[i] = args[i] != null ? args[i] : (T[]) new Object[0];
            targetSize += checkedArgs[i].length;
        }

        int insertIndex = 0;
        T[] result = (T[]) new Object[targetSize];
        for (int i=0; i<checkedArgs.length; i++) {
            for (int j=0; j<checkedArgs[i].length; j++, insertIndex++) {
                result[insertIndex] = checkedArgs[i][j];
            }
        }

        return result;
    }

    public static void main(String[] args) {

        Integer source1[] = {2, 3};
        Integer source2[] = { 4, 5, 6};

        System.out.println(Arrays.toString(combineArrays(source1, source2, null)));
    }
}

Hier hat man nun eine combineArrays Methode, die mit Arrays mit beliebigem Typ arbeiten kann und die auch null Arrays akzeptiert.

 

[Ullenboom]

@JustNobody Array.newInstance(...) finde ich noch etwas besser, weil es auch primitive Arrays unterstützt.

 

[Robat]

Geht natürlich auch mit `System.arraycopy` und `Arrays.copyOf`

public static <T> T[] mergeArrays(T[]... arrays) {
    final int size = Stream.of(arrays)
            .filter(Objects::nonNull)
            .mapToInt(e -> e.length)
            .sum();
    final Class<?> arrayType = arrays[0].getClass().getComponentType();

    T[] res = Arrays.copyOf(arrays[0], size);
    int offset = 0;

    for (T[] array : arrays) {
        if(array != null) {
            if (!array.getClass().getComponentType().isAssignableFrom(arrayType)) {
                throw new ArrayTypesDifferException("types musst be equal!");
            }
            System.arraycopy(array, 0, res, offset, array.length);
            offset += array.length;
        }
    }
    return res;
}