Rollierendes Array

[Anfänger1]

Hi,

ich stehe zur Zeit etwas auf dem Schlauch was folgende Fragestellung angeht:

Ich möchte ein Array (oder vielleicht besser eine Liste?) erstellen, welches zunächst immer genau 3 Werte (double) enthält. Dann kommt ein neuer Wert dazu, welcher an der letzten Position angefügt wird und der erste Wert entfällt.

Beispiel:

Start: 1,2,3
dann: 2,3,4
dann: 3,4,5

Die Werte sind natürlich nicht fortlaufend und es können auch doppelte Werte vorkommen.

Kann mir einer einen Gedankenanstoss geben, wie ich das am besten machen könnte?

Viele Grüße

mark

 

[hüteüberhüte]

ArrayDeque (Java Platform SE 6)

[EDIT]

    public static <T> void addLast(ArrayDeque<T> deque, T t) {
        deque.removeFirst();
        deque.addLast(t);
    }

    public static void main(String[] args) {
        ArrayDeque<String> d = new ArrayDeque<String>(Arrays.asList(new String[]{"1", "2", "3"}));
        System.out.println(d);
        addLast(d, "4");
        System.out.println(d);
        addLast(d, "5");
        System.out.println(d);
        addLast(d, "6");
        System.out.println(d);
    }

[/EDIT]

[EDIT]Oder ArrayList, wäre vielleicht noch besser. Die Klassen merken sich die Anfangs- und Endpositionen/-Indices der Elemente, deshalb kann in O(1) eingefügt werden[/EDIT]

 

[poku17]

Ist doch ansich ganz einfach, ne liste brauchst du nicht zunehmen, da das Array nicht groeßer wird, also immer nur 3 werte hat.

Dann musst du dir ne Funktion schreiben, welche als Parameter einen double wert bekommt.
dann kopierst du in der Funktion erst einmal das was im array[1] ist zu array[0] und array[2] nach array[1] und den parameter nach array[2] kopieren...

 

[bone2]

wenn es immer 3 lang ist, tuts schon:

    public static void main(String[] args) {
        int[] array = {1 ,2, 3};
        System.out.println(Arrays.toString(array));
        array = add(array, 4);
        System.out.println(Arrays.toString(array));
        array = add(array, 5);
        System.out.println(Arrays.toString(array));
        array = add(array, 6);
        System.out.println(Arrays.toString(array));
    }


    private static int[] add(int[] array, int number) {
        int[] resultArray = {array[1], array[2], number};
        return resultArray;
    }

[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]

für beliebig große arrays halt:

    public static void main(String[] args) {
        int[] array = {1 ,2, 3, 7, 8};
        System.out.println(Arrays.toString(array));
        array = add(array, 4);
        System.out.println(Arrays.toString(array));
        array = add(array, 5);
        System.out.println(Arrays.toString(array));
        array = add(array, 6);
        System.out.println(Arrays.toString(array));
    }


    private static int[] add(int[] array, int number) {
        int[] resultArray = new int[array.length];

        for (int i = 1; i < array.length; i++) {
            resultArray[i-1] = array[i];
        }

        resultArray[array.length - 1] = number;
        return resultArray;
    }

 

[hüteüberhüte]

wenn es immer 3 lang ist, tuts schon:
für beliebig große arrays halt:

Das Problem dabei ist, dass, wenn das Array n Element enthält, das Einfügen n Operationen benötigt. Zu aufwändig, denn das erste Element (bzw. das als letztes eingefügte) kann immer mit dem neuen überschrieben werden

 

[bone2]

jo, array ist da wohl nicht gerade geeignet. listen lösungen wurden ja schon gepostet.

 

[hüteüberhüte]

So:

public class RArray<E> {

    private final int size;
    private final Object[] array;
    private int first = 0;

    public RArray(int size) {
        this.size = size;
        array = new Object[size];
    }

    public E get(int index) {
        return (E) array[(first + index) % size];
    }

    public void add(E e) {
        array[first] = e;
        first = (first + 1) % size;
    }
}

    public static void main(String[] args) {
        RArray<Integer> ra = new RArray<Integer>(3);
        ra.add(1);
        ra.add(2);
        ra.add(3);
        ra.add(4);
        ra.add(5);
        ra.add(6);
        System.out.println(ra.get(0)); // = 4
        System.out.println(ra.get(1)); // = 5
        System.out.println(ra.get(2)); // = 6
    }

Aber ArrayList bzw. ArrayDeque werden bereits genauso (nur noch etwas aufwändiger) implementiert, von daher braucht man da nicht extra etwas neues erfinden

 

[Landei]

Das Problem dabei ist, dass, wenn das Array n Element enthält, das Einfügen n Operationen benötigt. Zu aufwändig, denn das erste Element (bzw. das als letztes eingefügte) kann immer mit dem neuen überschrieben werden

Das stimmt nicht ganz: [c]System.arraycopy[/c] lässt das Betriebssystem den Speicherbereich kopieren, das geht fix. Die Methode sollte auch beim "auf sich selbst kopieren" klappen.

 

[hüteüberhüte]

Wenn das Kopieren so einfach wäre, würde es ja z.B. bei ArrayDeque auch so gemacht werden. Wird es aber nicht, weil die Umrechnung der Indices einfach viel einfacher ist

 

[hüteüberhüte]

[EDIT]Aber soll lieber der TO entscheiden, was er nimmt. Wurden jetzt ja bereits verschiedene Möglichkeiten genannt. Bis jetzt hat dieser auch noch nicht wieder geschrieben[/EDIT]