Wie kann ich ein Array in zwei Hälften aufteilen?

[mathilda712]

Ich frage mich, wie ich ein Array "in zwei Hälften aufteilen" kann, so dass die erste Hälfte meines Arrays eine Eigenschaft zu geteilt bekommt und die andere Hälfte erhält eine andere Eigenschaft. Also so dass zum Beispiel die Blickrichtung der ersten Hälfte der Objekte meines Arrays nach unten guckt, während die andere Hälfte meines Arrays nach oben guckt.

Meine Idee wäre folgende:

}
    Robot[] allRobots = new Robot[amountRobots];
    for(int i = 0; i < allRobots.length; i++) {
    allRobots[i] = new Robot(i, i, Direction.DOWN, 200);
        allRobots[i] = new Robot (i,i,Direction.UP, 200);
    }

Nur vermute ich, dass das mit nach beiden allRobots nicht funktionieren würde. Wäre [1] und [2] als Zahlen in den Klammern eine Idee?
Was ich noch erwähnen sollte ist, dass die Größe des Arrays variiert je nach Größe der Welt, in welcher die Objekte sich befinden.

MfG

 

[Jw456]

Wenn es nicht klar ist wie gross das Array ist gebaucht wird.
Solltest du eine Liste benutzen kein Array.

 

[mihe7]

    Robot[] allRobots = new Robot[amountRobots];
    for(int i = 0; i < allRobots.length; i++) {
        allRobots[i] = new Robot(i, i, Direction.DOWN, 200);
        allRobots[i] = new Robot (i,i,Direction.UP, 200);
    }

Das funktioniert natürlich nicht. In Zeile 4 überschreibst Du einfach das Element, das Du in Zeile 3 ins Array gelegt hast.

Am einfachsten sind zwei Schleifen. Die erste geht von 0 bis allRobots.length/2 und die zweite von allRobots.length/2 bis allRobots.length.

Natürlich kann man das auch in einer lösen:

    Robot[] allRobots = new Robot[amountRobots];
    for(int i = 0; i < allRobots.length; i++) {
        Direction dir = i < allRobots.length / 2 ? Direction.DOWN : Direction.UP;
        allRobots[i] = new Robot(i, i, dir, 200);
    }

Aber ich denke mal, dass zwei Schleifen einfacher zu verstehen sein dürften.

 

[Jw456]

Zeile 4 und 5
Du kannst nicht zwei verschiedene Objekt auf den selben Array Platz setzen.

PS mihe7 war schneller

 

[Blut1Bart]

Hallo @mathilda712 , das ist nicht ganz trivial, deshalb zeige ich dir das jetzt einmal:

    public static Object[][] splitAt(Object[] oa, Class<?> c, int at) {
        if (at < 0 || at > oa.length) {
            throw new IllegalArgumentException("bounds");
        }
        Object[][] resultArray = new Object[2][];
        resultArray[0] = (Object[]) Array.newInstance(c, at);
        resultArray[1] = (Object[]) Array.newInstance(c, oa.length - at);
        System.arraycopy(oa, 0, resultArray[0], 0, at);
        System.arraycopy(oa, at, resultArray[1], 0, resultArray[1].length);
        return resultArray;
    }

    public static void main(String[] args) {
        String[] a = {"eins", "zwei", "drei", "vier", "fünf"};
        Object[][] objects = splitAt(a, a.getClass().componentType(), 4);
        String[] split1 = (String[]) objects[0];
        String[] split2 = (String[]) objects[1];
        System.out.println(Arrays.toString(split1));
        System.out.println(Arrays.toString(split2));
    }

 

[mathilda712]

Hallo @mathilda712 , das ist nicht ganz trivial, deshalb zeige ich dir das jetzt einmal:

    public static Object[][] splitAt(Object[] oa, Class<?> c, int at) {
        if (at < 0 || at > oa.length) {
            throw new IllegalArgumentException("bounds");
        }
        Object[][] resultArray = new Object[2][];
        resultArray[0] = (Object[]) Array.newInstance(c, at);
        resultArray[1] = (Object[]) Array.newInstance(c, oa.length - at);
        System.arraycopy(oa, 0, resultArray[0], 0, at);
        System.arraycopy(oa, at, resultArray[1], 0, resultArray[1].length);
        return resultArray;
    }

    public static void main(String[] args) {
        String[] a = {"eins", "zwei", "drei", "vier", "fünf"};
        Object[][] objects = splitAt(a, a.getClass().componentType(), 4);
        String[] split1 = (String[]) objects[0];
        String[] split2 = (String[]) objects[1];
        System.out.println(Arrays.toString(split1));
        System.out.println(Arrays.toString(split2));
    }

Oh wow! Danke

 

[Blut1Bart]

Oh wow! Danke

Kleiner Fehler noch enthalten, meiner Schludrigkeit geschuldet:

    public static Object[][] splitAt(Object[] oa, int at) {
        if (at < 0 || at > oa.length) {
            throw new IllegalArgumentException("bounds");
        }
        Object[][] resultArray = new Object[2][];
        resultArray[0] = (Object[]) Array.newInstance(oa.getClass().componentType(), at);
        resultArray[1] = (Object[]) Array.newInstance(oa.getClass().componentType(), oa.length - at);
        System.arraycopy(oa, 0, resultArray[0], 0, at);
        System.arraycopy(oa, at, resultArray[1], 0, resultArray[1].length);
        return resultArray;
    }

    public static void main(String[] args) {
        String[] a = {"eins", "zwei", "drei", "vier", "fünf"};
        Object[][] objects = splitAt(a, 4);
        String[] split1 = (String[]) objects[0];
        String[] split2 = (String[]) objects[1];
        System.out.println(Arrays.toString(split1));
        System.out.println(Arrays.toString(split2));
    }

 

[thecain]

Nicht die Frage wegeditieren....

 

[Blender3D]

Ich frage mich, wie ich ein Array "in zwei Hälften aufteilen" kann, so dass die erste Hälfte meines Arrays eine Eigenschaft zu geteilt bekommt und die andere Hälfte erhält eine andere Eigenschaft.

Ich würde das mit einem Comparator<Robots> machen.
In dem Beispiel verwende ich 4 Richtungen. In deinem Fall reduzierst man halt auf 2 Richtungen.


[CODE lang="java" title="SortArray" highlight="5-9"]import java.util.Arrays;

public class SortArray {
public static void main(String[] args) {
Robot[] robots = createRobots(10);
System.out.println(Arrays.toString(robots));
Arrays.sort(robots, new RobotCompare());
System.out.println();
System.out.println(Arrays.toString(robots));
}

public static Robot[] createRobots(int num) {
Robot[] robots = new Robot[num];
for (int i = 0; i < robots.length; i++)
robots = new Robot();
return robots;
}
}[/CODE]
[CODE lang="java" title="Robot"]import java.util.Random;

public class Robot {
private static Random rnd = new Random(System.currentTimeMillis());

public static enum DIR {
UP, LEFT, RIGHT, DOWN
};

private DIR dir;

public Robot() {
dir = getRndDir();
}

public Robot(DIR dir) {
this.dir = dir;
}

public static int dirToId(DIR dir) {
DIR[] values = DIR.values();
for (int id = 0; id < values.length; id++) {
if (values[id].equals(dir))
return id;
}
throw new IllegalStateException();
}

public DIR getDir() {
return dir;
}

public static DIR getRndDir() {
return DIR.values()[rnd.nextInt(4)];
}

@Override
public String toString() {
return "Robot " + dir.name();
}
}
[/CODE]
[CODE lang="java" title="RobotCompare" highlight="6-12"]import java.util.Comparator;

public class RobotCompare implements Comparator<Robot> {
@Override
public int compare(Robot r1, Robot r2) {
int val1 = Robot.dirToId(r1.getDir());
int val2 = Robot.dirToId(r2.getDir());
if (val1 == val2)
return 0;
if (val1 < val2)
return -1;
return 1;
}
}[/CODE]

 

[Oneixee5]

Kleiner Fehler noch enthalten, meiner Schludrigkeit geschuldet:

    public static Object[][] splitAt(Object[] oa, int at) {
        if (at < 0 || at > oa.length) {
            throw new IllegalArgumentException("bounds");
        }
        Object[][] resultArray = new Object[2][];
        resultArray[0] = (Object[]) Array.newInstance(oa.getClass().componentType(), at);
        resultArray[1] = (Object[]) Array.newInstance(oa.getClass().componentType(), oa.length - at);
        System.arraycopy(oa, 0, resultArray[0], 0, at);
        System.arraycopy(oa, at, resultArray[1], 0, resultArray[1].length);
        return resultArray;
    }

    public static void main(String[] args) {
        String[] a = {"eins", "zwei", "drei", "vier", "fünf"};
        Object[][] objects = splitAt(a, 4);
        String[] split1 = (String[]) objects[0];
        String[] split2 = (String[]) objects[1];
        System.out.println(Arrays.toString(split1));
        System.out.println(Arrays.toString(split2));
    }

Mir ist nicht klar warum man das so umständlich machen sollte!?

        final String[] b = {"eins", "zwei", "drei", "vier", "fünf"};
        final int splitPos = 4;
        final String[] s1 = Arrays.copyOfRange(b, 0, splitPos);
        final String[] s2 = Arrays.copyOfRange(b, splitPos, b.length);
        System.out.println(Arrays.toString(s1));
        System.out.println(Arrays.toString(s2));

Das hat auch eigentlich gar nichts mit dem eigentlichen Problem zu tun.

 

[Blut1Bart]

Mir ist nicht klar warum man das so umständlich machen sollte!?

Das funktioniert jetzt für Strings. Was ist mit beliebigen Arrays bzw. dem "Roboter" Array, das wir ja nicht kennen? Dein Snippet erfüllt schlicht die Anforderungen nicht.

 

[Oneixee5]

Das funktioniert jetzt für Strings. Was ist mit beliebigen Arrays bzw. dem "Roboter" Array, das wir ja nicht kennen? Dein Snippet erfüllt schlicht die Anforderungen nicht.

Arrays.copyOfRange - ist eine generische Methode, funktioniert also mit allen Objekten, nicht nur mit Strings. Deine Implementierung arbeitet mit Object und macht wilde Cast's. So etwas möchte man ja gerade vermeiden. Aber noch mal, es hat nichts mit der Anforderung zu tun. Die Anforderung besagt, dass für die eine Hälfte der Objekte im Array ein bestimmter Wert für eine Eigenschaft gesetzt wird und für die andere Hälfte ein anderer Wert.

 

[Blender3D]

Dein Snippet erfüllt schlicht die Anforderungen nicht.

Die Anforderung ist, ein Feld zu sortieren, und nicht in 2 Felder aufzuteilen.

Ich frage mich, wie ich ein Array "in zwei Hälften aufteilen" kann, so dass die erste Hälfte meines Arrays eine Eigenschaft zu geteilt bekommt und die andere Hälfte erhält eine andere Eigenschaft. Also so dass zum Beispiel die Blickrichtung der ersten Hälfte der Objekte meines Arrays nach unten guckt, während die andere Hälfte meines Arrays nach oben guckt.