# [Array] - Zahlenreihenfolge umkehren.



## Java-Wichtel (16. Jan 2013)

Ich muss eine Methode schreiben, in dem ich eine Zahlenreihenfolge von einem Array umkehren soll.

Habe folgendes geschrieben:


```
private double[] zahlen;  

// Mein double-Array ist zahlen.                                          
// Die Länge wird durch einem Konstruktor festgelegt.
...

public void reihenfolgeUmkehren()
{
  int j= zahlen.length-1;
  for (int i = 0; i > zahlen.length; i++)
  {
  zahlen[i] = zahlen[j];
  }
  while (j >= 0)
  {
     j--;
  }
}
```

Trotzdem habe ich es nicht so hingekriegt, wie ich es gerne wollte.
Musste jemand im Forum diese Aufgabe auch mal machen?


----------



## njans (16. Jan 2013)

Soll der Thread denn überhaupt noch offen bleiben?


----------



## SlaterB (16. Jan 2013)

eine Stunde kann man doch editieren, 
mehr als 6 Min. abwarten schadet auch nicht (edit: jetzt 17:13 fertig)


----------



## Java-Wichtel (16. Jan 2013)

njans hat gesagt.:


> Soll der Thread denn überhaupt noch offen bleiben?



Jetzt schon. Ich hätte ihn löschen können, wenn ich die Lösch-Funktion gefunden hätte.


----------



## njans (16. Jan 2013)

Um eine Array umudrehen gehst du einfach von hinten nach vorne durch und speicherst den jeweiligen Eintrag in ein neues array.
Das kann man sich doch leicht vorstellen:
[5,4,3,2,1,] 
[1,2,3,4,5]


----------



## bone2 (16. Jan 2013)

njans hat gesagt.:


> Um eine Array umudrehen gehst du einfach von hinten nach vorne durch und speicherst den jeweiligen Eintrag in ein neues array.
> Das kann man sich doch leicht vorstellen:
> [5,4,3,2,1,]
> [1,2,3,4,5]



mäh

schleife über array.length/2
vorderste hinterste tauschen
+1 -1 tauschen
mitte lassen

so brauch man kein zweites array, und nur halb soviele schleifendurchgänge


----------



## DrZoidberg (16. Jan 2013)

Also zwei Indexvariablen(i und j) zu verwenden ist schon mal ein guter Ansatz. Aber i > zahlen.length macht keinen Sinn. Das müsste i < j heissen. Ausserdem brauchst du nur eine Schleife und nicht zwei.
Und wie man Zahlen tauscht, weisst du ja schon aus diesem Thread
http://www.java-forum.org/java-basics-anfaenger-themen/146518-array-aufgabe-nachbarn-tauschen.html


----------



## SlaterB (16. Jan 2013)

eine Variable, nur i, könnte auch genügen, die zweite Position errechnet sich aus i und der Gesamtlänge

Probleme wie das verunglückte mehrfache Reduzieren von j im ersten Posting fallen dann schon weg

> for (int i = 0; i > zahlen.length; i++)
diese Schleife wird gar nicht erst gestartet, zum Glück, sonst liefe sie ewig, bis vielleicht zu Integer-Überlauf,
wäre die Bedingung i > zahlen.length einmal erfüllt, dann für alle größeren i umso mehr

genau achten was programmiert wird, Beispiele anschauen


----------



## Java-Wichtel (18. Jan 2013)

Danke euch, ich hab's jetzt hinbekommen.

Die Lösung ist:


```
public void reihenfolgeUmkehren ()
    {      
        int j = zahlen.length-1;
        for (int i=0; i < zahlen.length/2; i++)
        {
            double test = zahlen[i];
            zahlen[i] = zahlen[j];
            zahlen[j] = test;
            j--;         
        }
    }
```


Frage: Ist es normal, dass ein Array eine Reihe nur bis zur Hälfte umkehren kann? 
Ich verstehe jetzt, wieso in der Schleife der Array durch 2 geteilt sein muss.


----------



## SlaterB (18. Jan 2013)

wie gesagt könnte man auf j noch verzichten, j ist immer  zahlen.length-1-i oder so,
schadet aber auch nicht, man sollte auch nicht versuchen, mit kryptischen Code zu schlau zu sein

> Ich verstehe jetzt, wieso in der Schleife der Array durch 2 geteilt sein muss. 

schau dir das ganze doch an, ein Beispiel auf Papier oder Ausgabe mit Arrays.toString() in jedem Schleifendurchlauf,
dann siehst du was sich nach ersten Durchläufen ändert, wie der Stand genau zur Hälfte ist,
und was vielleicht passiert wenn du noch weiter tauschst

Fragen schafft Lösungen, noch schöner wäre aber doch, selber Antworten zu kennen/ zu finden


----------



## hüteüberhüte (18. Jan 2013)

Such dir einen Weg aus:


```
public static void reihenfolgeUmkehren1(Object[] arr) {
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            Object tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    }

    public static void reihenfolgeUmkehren2(Object[] arr) {
        List<Object> lo = Arrays.asList(arr);
        Collections.reverse(lo);
        lo.toArray(arr);
    }

    public static void main(String[] args) {
        Object[] oa = {1, 2, 3};
        System.out.println("oa = " + Arrays.toString(oa));
        reihenfolgeUmkehren1(oa);
        System.out.println("oa = " + Arrays.toString(oa));
        reihenfolgeUmkehren2(oa);
        System.out.println("oa = " + Arrays.toString(oa));
    }
```

Das sind die, die mir spontan einfallen.

Benötigt: 
	
	
	
	





```
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
```

https://www.google.de/search?q=Java+SE+6+API

Grüßle


----------



## bone2 (18. Jan 2013)

hüteüberhüte hat gesagt.:


> Such dir einen Weg aus:
> 
> ```
> public static void reihenfolgeUmkehren1(Object[] arr) {
> ...


die lösung ist deutlich schlechter lesbar als length/2 und j ist unnötig.

[OT]hüte warum machst du sowas... immer wieder, in fertige, erledigte threads mittelmäßige lösungen nachposten[/OT]


----------



## hüteüberhüte (18. Jan 2013)

Also 1) nicht schlechter, sondern, betrachtet man die Anzahl der Operationen, besser, und 2) nicht mittelmäßig, denn etwas wie reihenfolgeUmkehren2 wurde noch gar nicht genannt. Bist du auf Stunk aus?


----------



## bone2 (18. Jan 2013)

hüteüberhüte hat gesagt.:


> Also 1) nicht schlechter, sondern, betrachtet man die Anzahl der Operationen, besser


ich finde des schlechter *lesbar*.
der code ist in ordnung, ist die gleiche idee wie oben in den lösungen nur anders geschrieben.


----------

