# größte eingelesene Zahl ausgeben lassen



## Joptionpane (13. Jan 2012)

Abend an alle, 
bin wiedermal am üben: 
Es sollen n Zahlen eingelesen werden(bis 0 eingegeben wird). Die größte soll ausgegeben werden.
Mein Ansatz war es, die eingelesenen Zahlen in einem array zu speichern und in einer Methode wird dann jede Zahl im Array miteinander verglichen und der größte zu schluss zurückgegeben.
Komm aber nicht weiter... Außerdem wird mir der S.o.p  beim maximum angemeckert(hab ich extra kommentiert).

Ich hoffe mal, dass das Programm soweit einigermaßen gut aussieht(bis auf das was mir fehlt)^^ 

lg


```
package uebung1;



	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		boolean flag = true;

		do {
			System.out.println("Bitte eine Zahl eingeben und ENTER drücken(bei 0 wird aufgehört):");
			int x = sc.nextInt();
			int[] Zahl = new int[x];

			if (x == 0) {
				flag = false;
			}
		} while (flag);

		System.out.println(maximum));(//fehlt etwas

	}

	public static int maximum(int[] feld) {

		int z = feld[0];

		for (int i = 0; i < feld.length; i++) {
			for (int j = 0; j < feld.length; j++) {

				if (feld[i] > feld[j]) {
					z = feld[i];
				} else {

					z = feld[j];
				}
			}

		}

		return z;
	}

}
```


----------



## HimBromBeere (13. Jan 2012)

Du überschreibst dein int-Array andauernd, mit jedem Schleifendurchlauf erstellst du es neu (in der Größe der eingegebenen Zahl). Du musst dein Feld also außerhalb der Schleife definieren und es dann an die Max-Funktion übergeben... 
Die Zuweisung zum Feld machst du mit sowas wie 
	
	
	
	





```
Zahl[i++] = x;
```
 wobei du i noch außerhalb als int definieren musst.
Die Übergabe an die Funktion sieht so aus: 
	
	
	
	





```
maximum(Zahl);
```

Das blöde am Feld ist allerdings, du musst eine Größe angeben, also trag am Anfang eine feste Größe (z.B. 100) ein (oder definiere eine Liste, da ist das Hinzufügen dann einfacher)...


Hoffe, das reicht dir erstmal an Anstoß


----------



## Fab1 (13. Jan 2012)

Hi,

Statt einem Array würde ich auf eine ArrayList zurück greifen. Wie HimBromBeere bereits gesagt hat musst du einem Array immer eine entsprechende Größe mitgeben. Das ist natürlich sehr unflexibel. Man kann natürlich jedes mal ein neues Array erstellen wie du es gemacht hast, aber das ist nicht sehr performant.
Hier ist eine ArrayList ) sehr hilfreich. Diese ist ähnlich wie ein Array allerdings kann man dynamisch Elemente hinzufügen add()  und entfernen remove()

Diese musst du natürlich dann als Übergabe Parameter in der Methode maximum definieren. Und beim Aufruf dann einfach übergeben.

Ich hab deine Version jetzt mal aufgegriffen und etwas abgeändert. Sollte so funktionieren, zumindest bei mir.

Ich vergleiche die erste Zahl mit dem Rest, ist eine Zahl größer wie die Erste, dann wird die neue Größere Zahl mit dem Rest verglichen (nicht wieder von Anfang an)



```
public static void main(String[] args) {

		ArrayList<Integer> zahlenListe = new ArrayList<Integer>();

		Scanner sc = new Scanner(System.in);
		boolean flag = true;

		do {
			System.out
					.println("Bitte eine Zahl eingeben und ENTER drücken(bei 0 wird aufgehört):");
			int x = sc.nextInt();
			zahlenListe.add(x);

			if (x == 0) {
				flag = false;
			}
		} while (flag);

		System.out.println(maximum(zahlenListe)); // fehlt etwas

	}

	public static int maximum(ArrayList<Integer> feld) {

		int z = feld.get(0);

		for (int i = 0; i < feld.size(); i++) {
			if (z < feld.get(i)) {
				z = feld.get(i);
			}
		}

		return z;
	}

}
```


----------



## Xeonkryptos (13. Jan 2012)

Außerdem würde ich nach jeder Eingabe prüfen, ob die Zahl größer ist. So ersparst du dir ein Array und benötigst nur 2 Variablen, die du vergleichst und wenn die alte kleiner als die neu eingegebene ist, dann einfach ersetzen, ansonsten behalten und weiterprüfen mit der nächsten Eingabe. Ist einfacher.


----------



## Joptionpane (13. Jan 2012)

ich schaus mal genauer an


----------



## HoaX (13. Jan 2012)

Ich würde die Listen/Array weg lassen und gleich in der Schleife prüfen ob die eingegebene Zahl größer ist als das bislang gemerkte Maximum und dann ggf. die neue Zahl merken.

```
int max = Integer.MIN_VALUE;
while(true) {
    int i = holeNächsteZahl();
    if (i == 0) break;
    if (i > max)
        max = i;
}
System.out.println("Maximum: " + max);
```


----------



## HimBromBeere (13. Jan 2012)

Das beudeutet allerdings, dass du die ganzen anderen Zahlen im Feld verlierst... sofern du nur das Maximum brauchst, ist das aber eine schlaue Alternative; brauchst du die ursprünglcieh Zahlen noch, wirst du um eine Liste nicht drumrum kommen.


----------



## HoaX (13. Jan 2012)

-- (gelöscht, da HimBromBere seinen Post komplett nachträglich geändert hat ... schäm dich!) --


----------



## Joptionpane (13. Jan 2012)

Bei der Aufgabenstellung ging es halt darum, eine Methode zu benutzen. Ob Array oder nicht war uns überlassen (wollt es mit Arrays probieren).  ArrayList hatten wir leider noch nicht in der Vorlesung, sprich würde mir nicht viel bringen, dennoch siehts gut aus. 
Meine jetztige Version läuft, jedoch gibt er mir IMMER den vorletzten Wert raus, egal was ich eingebe...


```
package uebung1;

import java.util.Scanner;

public class GrößteZahl {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
	//	boolean flag = true;
		
		int[] Zahl = new int[6];
		for (int i = 0; i<=Zahl.length-1;i++){
			
			System.out.println("Bitte " + (i+1) + "  Zahl eingeben und ENTER drücken:");
			int x = sc.nextInt();
			Zahl[i] = x;
		/*
			
			if (x == 0) {
				flag = false;
			
		} while (flag);
		*/
		}
		System.out.println(maximum(Zahl));

	}

	public static int maximum(int[] feld) {

		int z = feld[0];

		for (int i = 0; i < feld.length-1; i++) {
			for (int j = 0; j < feld.length-1; j++) {

				if (feld[i] > feld[j]) {
					z = feld[i];
				} else {

					z = feld[j];
				}
			}

		}

		return z;
	}

}
```


----------



## HimBromBeere (13. Jan 2012)

du brauchst nur eine Schleife in deiner max-Funktion: darin prüfst du, ob das aktuelle (das i-te) Element größer als das bisherige Maximum ist. Sollte dem so sein, ersetzt du das aktuelle Maximum mit dem neuen Wert, ansonsten fahre einfach fort mit dem nächsten Schleifendurchlauf (was auch im Fall der Ersetzung gemacht werden muss, natürlich...).


Etwas derart:


```
public static int maximum(int[] feld) {
 
int max = 0;        
    for (int i = 0; i < feld.length-1; i++) {
        if (feld[i] > max) max = feld[i]; 
    }
    return max;
}
```


----------



## Joptionpane (13. Jan 2012)

Jop, hab zu kompliziert nachgedacht^^ 
Funzt einwandfrei jetzt.
Würde es jetzt noch gehen solange Zahlen einzulesen bis man 0 eingibt ohne, dass die Arraylänge zuvor bekannt ist? Oder "muss" man den festlegen(ohne arraylist jetzt)?



```
package uebung1;

import java.util.Scanner;

public class GrößteZahl {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
	//	boolean flag = true;
		
		int[] Zahl = new int[6];
		for (int i = 0; i<=Zahl.length-1;i++){
			
			System.out.println("Bitte " + (i+1) + "  Zahl eingeben und ENTER drücken:");
			int x = sc.nextInt();
			Zahl[i] = x;
		/*
			
			if (x == 0) {
				flag = false;
			
		} while (flag);
		*/
		}
		System.out.println(maximum(Zahl));

	}

	public static int maximum(int[] feld) {

		int max = feld[0];

		for (int i = 0; i < feld.length; i++) {
		
				if (feld[i]> max) {
					max = feld[i];
				
			}

		}

		return max;
	}

}
```


----------



## HimBromBeere (13. Jan 2012)

Für ein Array MUSST du eine konstante Größe angeben, also wenn du das erreichen willst, musst du schon eine grpße Zahl als Anfangsgröße angeben, in der Hoffnung, dass niemand mehr als 1000Zahlen eingeben will


----------



## Joptionpane (13. Jan 2012)

jop jetzt gehts wie ich es mir gewünscht habe   (bis auf die länge des arrays^^)

danke an alle ) 


```
package uebung1;

import java.util.Scanner;

public class GrößteZahl {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		boolean flag = true;
		
		int[] Zahl = new int[100];
		
	//	for (int i = 0; i<=Zahl.length-1;i++){
			
			
			int i = 0; 
		do{
			System.out.println("Bitte Zahl eingeben und ENTER drücken:(bei 0 wird gestoppt)");
			int x = sc.nextInt();
			Zahl[i++] = x;
			
			
			if (x == 0) {
				flag = false;
			}
		} while (flag);
		
		
		System.out.println(maximum(Zahl));

}

	public static int maximum(int[] feld) {

		int max = feld[0];

		for (int i = 0; i < feld.length; i++) {
		
				if (feld[i]> max) {
					max = feld[i];
				
			}

		}

		return max;
	}

}
```


----------

