# Nach Beendigung aller Schleifen von vorn anfangen,



## florilu (24. Nov 2012)

Hallo, ich habe ein kleines Problem, bzw. eine kleine Frage,
da ich ja aktuell mein Wissen auffrische und aktuell noch mit der Konsole arbeite würde ich gerne wissen wie man eine Option einfügt, ob man das Programm schließen will, oder noch mal was eingeben will, denn ich finde es ist relativ nervig die ganze Zeit die Batch-Datei immer und immer wieder neu auszuführen.
Also, ich stelle es mir so vor, man macht seine Eingaben, und irgendwann kommt das Ergebnis, danach sagt die Konsole "Drücken sie eine beliebige Taste..." aber ich will, das das Programm fragt "Weitere Eingabe ja/nein" und wenn man "ja" eingibt, dann kehrt er wieder nach oben zurück, und wenn man "nein" eingibt, schließt sich das Programm. Ich hoffe ihr könnt meine Frage verstehen  , wenn nicht dann sagt es mir.

Hier mein Code:


```
import java.io.*;
import java.util.*;

public class Main
{	
	static void leer(int par1)
	{
		for(int a = 1; a <= par1; a++)
		{
			println("");
		}
	}
	
	static void random()
	{
		for(int a = 0; a <= 1; a++)
		{
			a = (a - 1);
			int b;
			String c;
			String d;
			b = (int) (Math.random()*1000000);
			c =  (Integer.toBinaryString(b));
			d = (Integer.toHexString(b));
			println("Dezimal: "+a);
			println("Binaer: "+c);
			println("Hex: "+d);
			leer(1);
			sleep(2);
		}
	}
	
	static void print(String a)
	{
		System.out.print(a);
	}
	
	static void println(String a)
	{
		System.out.println(a);
	}
	
	static void sleep(int par1)
	{
		par1 = (par1 * 1000);
		try
		{
			Thread.sleep(par1);
		}catch(InterruptedException e){
			
		}
	}
	
	static void header()
	{
		println("===========");
		println("==Eingabe==");
		println("===========");
		println("");
	}
	
	static void hex() throws Exception
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		print("Hexadezimalzahl: ");
		String hex = br.readLine();
		println("Die Dezimalzahl ist: "+Integer.parseInt(hex, 16));
	}
	
	static void decimal()
	{
		@SuppressWarnings("resource")
		Scanner scanner = new Scanner(System.in);

		int a;
		
		print("Dezimalzahl: ");
		a = scanner.nextInt();
		println("Bitte warten sie auf das Ergebnis!");
		sleep(5);
		leer(1);
		println("Die Binaerzahl ist: "+Integer.toBinaryString(a));
	}
	
	static void binary() throws Exception
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		print("Binearzahl: ");
		String s = br.readLine();
		sleep(1);
		println("Die Dezimalzahl ist: "+Integer.parseInt(s, 2));
	}
	
	public static void main(String[] args) throws Exception
	{
		@SuppressWarnings("resource")
		Scanner scanner = new Scanner(System.in);
		
		header();
		println("Bitte geben sie die gewuenschte Option ein.");
		println("1 = Dezimal zu Binaer; 2 = Binaer zu Dezimal.");
		println("3 = Hexadezimal zu Dezimal.");
		print("Option: ");
		int b = scanner.nextInt();
		if(b == 1){
			decimal();
		}else if(b == 2){
			binary();
		}else if(b == 3){
			hex();
		}else if(b == 4){
			random();
		}else{
			println("Ungueltige Eingabe!");
		}
	}
}
```

MfG:
Florilu


----------



## AmunRa (24. Nov 2012)

Bau dir doch einfach eine weitere Schleife um die Main und am Ende eine Abfrage ob er noch einmal starten moechte.

z.B so:


```
public static void main(String[] args) throws Exception
    {
        boolean repeat = true;
        do{
        @SuppressWarnings("resource")
        Scanner scanner = new Scanner(System.in);
        
        header();
        println("Bitte geben sie die gewuenschte Option ein.");
        println("1 = Dezimal zu Binaer; 2 = Binaer zu Dezimal.");
        println("3 = Hexadezimal zu Dezimal.");
        print("Option: ");
        int b = scanner.nextInt();
        if(b == 1){
            decimal();
        }else if(b == 2){
            binary();
        }else if(b == 3){
            hex();
        }else if(b == 4){
            random();
        }else{
            println("Ungueltige Eingabe!");
        }
        System.out.println("Wollen Sie nocheinmal starten? J für Ja");
        
        String doRepeat = scanner.nextLine();
        repeat = doRepeat.equals("J");
        }while(repeat);
    }
```


----------



## Fab1 (24. Nov 2012)

Die Abfrage mit
	
	
	
	





```
ja/nein
```
 bekommst du ja sicherlich hin. Mit equals() bzw. equalsignorecase() kannst du zwei Strings auf Gleichheit prüfen.

So könntest du also schon mal überprüfen ob 
	
	
	
	





```
ja
```
oder 
	
	
	
	





```
nein
```
eingegeben wurde.

Und wenn er 
	
	
	
	





```
ja
```
eingibt, dann rufst du die entsprechenden Methode halt wieder auf.


----------



## florilu (24. Nov 2012)

Danke, beides hat geholfen.

Damit hätte sich das Problem erledigt.


----------



## Hansebas (3. Mrz 2019)

Moin,

ich hatte eine ähnliche Idee. Habe es zwischenzeitlich auch hinbekommen. Bin dabei auf die hier beschriebene Variante gestoßen.

Ursprünglich nutze ich diese Variante:

```
String wiederholung1 = "ja";
            
        do
        {
        System.out.println("1. Variante");
        System.out.println("Soll das Programm neu ausgeführt werden?");
        System.out.println("ja");
        System.out.println("nein");
        Scanner wiederholung1neu = new Scanner(System.in);
        wiederholung1 = wiederholung1neu.next();
        }
        while (wiederholung1.equalsIgnoreCase ("ja"));
```

Die hier beschriebene Variante würde so aussehen:

```
boolean wiederholung2 = true;
Scanner scanner = new Scanner(System.in);

        do
        {
         System.out.println("2. Variante");
         System.out.println("Soll das Programm neu ausgeführt werden?");
         System.out.println("ja");
         System.out.println("nein");
        String dowiederholung2 = scanner.nextLine();
        wiederholung2 = dowiederholung2.equalsIgnoreCase("ja");
        }
        while(wiederholung2);
```

Mich würde mal interessieren, welche Variante als "eleganter" angesehen wird. Die erste ist zwar kürzer, damit mit weniger Aufwand verbunden. Die zweite Variante arbeitet mit einer booleschen Variablen, was mir wiederum bei einer DO-WHILE-Schleife sauberer definiert erscheint. Auch scheint die zweite Variante schneller zu gehen. Was ich wiederum nicht verstehe.

*1. Messung*
Die erste Variante dauert 0.34424299999999997ms.
Die zweite Variante dauert 0.07499299999999999ms.

*2. Messung*
Die erste Variante dauert 0.18191ms.
Die zweite Variante dauert 0.101195ms.

Ich hoffe, ich habe beim Zeit messen keinen Fehler gemacht.


```
import java.util.Scanner;

public class GewollteNeuausfuehrung {
 
    public static void main (String[] args) {
        // Anfang erste Variante
        String wiederholung1 = "ja";
      
        long startTime1 = System.nanoTime();     
        do
        {
        System.out.println("1. Variante"); 
        System.out.println("Soll das Programm neu ausgeführt werden?");
        System.out.println("ja");
        System.out.println("nein");
        wiederholung1 = "nein";
        }
        while (wiederholung1.equalsIgnoreCase ("ja")); 
        long stopTime1 = System.nanoTime();
        System.out.println("Die erste Variante dauert " + (stopTime1-startTime1)*1e-6 + "ms.");     
        System.out.println("Die erste Variante wird beendet.");
        // Ende erste Variante
     
        // Anfang zweite Variante
        boolean wiederholung2 = true;
        Scanner scanner = new Scanner(System.in);
     
        long startTime2 = System.nanoTime();
        do
        {
            System.out.println("2. Variante");
            System.out.println("Soll das Programm neu ausgeführt werden?");
            System.out.println("ja");
            System.out.println("nein");
            wiederholung2 = false;
        }
        while(wiederholung2);
        long stopTime2 = System.nanoTime();
        System.out.println("Die zweite Variante dauert " + (stopTime2-startTime2)*1e-6 + "ms.");     
        System.out.println("Die zweite Variante wird beendet.");
        // Ende zweite Variante
    }

}
```


----------



## mihe7 (3. Mrz 2019)

Hansebas hat gesagt.:


> Mich würde mal interessieren, welche Variante als "eleganter" angesehen wird.


Das kommt darauf an, welchen Punkt man betrachtet. In der ersten Variante ist es z. B. nicht besonders klug, in jeder Iteration ein neues Scanner-Objekt zu erzeugen. Ansonsten würde ich in diesem konkreten Fall die unmittelbare Prüfung in while bevorzugen. Das kann sich aber schlagartig mit den Anforderungen ändern.



Hansebas hat gesagt.:


> Ich hoffe, ich habe beim Zeit messen keinen Fehler gemacht.


Beim Messen per se vielleicht nicht aber beim "Benchmarken". Du versuchst Dich an etwas, was man als Microbenchmark bezeichnet. Die funktionieren aber nicht mit ein bisschen Zeit messen, sondern sind nur relativ kompliziert durchzuführen.


----------

