# Minimum von 5 Werten



## sh33p (13. Mai 2010)

Ich habe einen Code geschrieben,der das Minimum von 5 eingelesen Werten berechnet:


```
import java.util.*;
public class Minimum2 {

  public static void main(String[] args) {
  
  Scanner scan = new Scanner(System.in);
  int e1 = scan.nextInt();
  int e2 = scan.nextInt();
  int e3 = scan.nextInt();
  int e4  = scan.nextInt();
  int e5  = scan.nextInt();
  System.out.println("Das Minimum ist: " + Mini(e1,e2,e3,e4,e5));

  }
  public static int Mini(int a,int b,int c,int d,int e){
    int wert = 0;
    if(a <b&& a<c && a < d && a <e ){
    int min = a;
    wert = a;

    }
    if( b<a && b<c && b<d && b<e){
    
    int min = b;
    wert = b;

    }
    if( c<a && c<b && c<d && c<e){
      int min = c;
      wert = c;
    }
    if( d<a && d<b && d<c && d<e){
      int min = d;
      wert = d;
    }
    if(e<a && e<b && e<c && e<d){
      int min = e;
      wert = e;
    }

    return wert;
  }
```

Dies denke ich geht bestimmt einfacher. Mir wurde der Tipp gegeben die Java.lang. Math min methode zu verwenden. diese errechnet aber nur das min von 2 werten. wie kann ich es erreichen,das mehrere werte verglichen werden?


----------



## nrg (13. Mai 2010)

Ich würds wahrscheinlich direkt in eine Liste packen und mit Collections.min machen aber in deinem fall würde ich dir erstmal ein array als parameter empfehlen und eine schleife. dann kannst du nämlich nicht nur 5 werte reinstecken sondern soviel du willst und der code wird auch deutlich kürzer 

edit: methodennamen schreibt man klein

edit2: bzw geht ja auch mit Arrays.sort. Mein Vorschlag wäre:


```
Scanner scan = new Scanner(System.in);
  int[] array = new int[5];
  for ( int i = 0; i < array.length; i++ ) 
	  array[i] = scan.nextInt();
  System.out.println("Das Minimum ist: " + mini( array ));
 
  }
  public static int mini( int[] array ){
	  Arrays.sort( array );
	  return array[0];
  }
```

edit3: oder ohne hilfe von Arrays oder Collections:

```
public static int mini( int[] array ){
		if ( array.length == 0 ) {
			System.out.println( "Das Array ist leer!" );
			return 0;
		}
		int min = array[0];
		for ( int i = 1; i < array.length; i++ )
			if ( array[i] < min )
				min = array[i];
		return min;
	}
```


----------



## faetzminator (13. Mai 2010)

```
Scanner scanner = new Scanner(System.in);
final int count = 5;
int value = Integer.MAX_VALUE;
for (int i = 0; i < count; i++) {
    value = Math.min(value, scanner.nextInt());
}
System.out.println("Das Minimum ist: " + value);
```


----------



## JohannisderKaeufer (13. Mai 2010)

Und mit args.

```
int value = Integer.MAX_VALUE;
for (String arg : args) {
    value = Math.min(value, Integer.valueOf(arg));
}
System.out.printf("Das Minimum ist: %03d\n", value);
```


----------



## xZise (15. Mai 2010)

Moin,
es gibt ja schon _Math.min()_ für zwei Werte. Gibt es denn nichts direkt entsprechendes für n Werte? Ich meine der Unterschied ist ja nicht so riesig, und mit arrays oder mehreren Parametern geht das doch relativ einfach (und auch teilweise ohne das die Anwendung davon was merkt).

Ich denke da an sowas:

```
public static int min(int a, int... b) {
    int min = a;
    for (int i = 0; i < b.length; i++) {
        if (b[i] < min) {
            min = b[i];
        }
    }
    return min;
}
```
So kann man sogar die Anwendung ohne Probleme weiterverwenden ohne die alte Methode weiter zu nutzen, da die Signatur identisch ist.

MfG
xZise


----------



## agentone (16. Mai 2010)

xZise hat gesagt.:
			
		

> da die Signatur identisch ist.


Naja, identisch ist was anderes, "ähnlich" trifft es besser.
Zumindest müssten alte Programme trotzdem noch funktionieren...
Aber nur, wenn es die VM nicht ganz so genau nimmt.

Es ist sowieso schade, dass die neuen Sprachelemente noch nicht mal in der API verwendet werden:
-enum (kaum)
-var-args (selten)
-generic (fehlt an manchen stellen)


----------



## xZise (16. Mai 2010)

Moin,
ich meine mit „identischer“ Signatur, dass sie abwärtskompatibel und bedingt aufwärtskompatibel (solange zwei Werte benutzt) ist.

MfG
Fabian


----------

