Warum funktioniert Programm mit einlesen von .next() aber nicht mit .nextLine()?

yxy

Lieutenant
Registriert
Juli 2014
Beiträge
552
Hallo,

wenn ich in Ziele 22 das userInput.nex() durch userInput.nextLine() ersetze, hängt sich das Programm im zweiten Durchlauf auf. (Java-Code)
Ich verstehe aber nicht, warum es bei .next() funktioniert, aber nicht bei .nextLine().
Hat jemand von euch eine Erklärung?


Code:
package Übung5_DatenInArraysManipulieren;

import java.util.Scanner;

public class Manipulieren {

    public static void main(String[] args) {
        Scanner userInput = new Scanner(System.in);

        while (true) {
            int[] puffer = new int[50];             
 
            System.out.println("--- numbers ---");
            System.out.println("Was möchten Sie mit der Datenreihe tun?");
            System.out.println("g \t Größtes Element des Array ermitteln");
            System.out.println("m \t Arithmetisches Mittel aller Elemente berechnen");
            System.out.println("p \t Bei allen negativen Elementen das Vorzeichen auf + ändern");
            System.out.println("l \t Löschen aller negativen Werte");
            System.out.println("t \t Trennen von Geraden und ungeraden Werten");
            System.out.println("e \t Ende");

            String input = userInput.next();                //Warum geht hier nicht: .nextLine????????????????????????????????? 

            if (input.charAt(0) == 'e') {
                System.exit(0);
            }

            System.out.println("Geben Sie eine Datenreihe ein. Trennen Sie dabei die Zahlen durch ein Enter. "
                    + "Beenden Sie die Dateneingabe mit: 0");

            int numbersTypedIn;          //Gibt Anzahl von eingegebenen Nummern an
                                       
            for (numbersTypedIn = 0;; numbersTypedIn++) {
                puffer[numbersTypedIn] = userInput.nextInt();
                if (puffer[numbersTypedIn] == 0) {
                    break;
                }
            }

            int[] numbers = new int[numbersTypedIn];

            for (int j = 0; j < numbersTypedIn; j++) {
                numbers[j] = puffer[j];
            }

            printIntArray(numbers); //Ausgabe der Array Werte durch Funtion(Methode) printIntArray (unten definiert)

            switch (input.charAt(0)) {
                case 'g':
                    maxElement(numbers);
                    break;
                case 'm':
                    arithmeticMiddle(numbers, numbersTypedIn);
                    break;
                case 'p':
                    changeNegative(numbers, numbersTypedIn);
                    break;
                case 'l':
                    removeNegative(numbers, numbersTypedIn);
                    break;
                case 't':
                    separateOddEven(numbers, numbersTypedIn);
                    break;
            }  

        }
    }
//------------------------------------------------------------------------------
    static void maxElement(int[] nums) {
        int highestValue = 0;
        for (int i = 0; i > (nums.length); i++) {
            if (nums[i] > highestValue) {
                highestValue = nums[i];
            }
            System.out.println(highestValue);
        }
    }
//------------------------------------------------------------------------------
    static void arithmeticMiddle(int[] nums, int numbersOfNumbers) {
        int sum = 0;
        int middle;

        for (int i = 0; i < nums.length; i++) {
            sum = sum + nums[i];
        }

        middle = sum / numbersOfNumbers;  

        System.out.println("Mittelwert:" + middle);
    }
//------------------------------------------------------------------------------
    static void changeNegative(int[] nums, int numbersOfNumbers) {
        for (int i = 0; i < numbersOfNumbers; i++) {
            if (nums[i] < 0) {
                nums[i] = nums[i] * -1;
            }
        }
        printIntArray(nums);
    }
//------------------------------------------------------------------------------
    static void removeNegative(int[] nums, int numbersOfNumbers) {
        //- durch 0 ersetzen
        for (int i = 0; i < numbersOfNumbers; i++) {    
            if (nums[i] < 0) {
                nums[i] = 0;
            }
        }
        printIntArray(nums);
        
        //0 ans Ende schieben
        for (int i = 0; i < numbersOfNumbers; i++) {                
            int stelleZuTauschen=i+1;  //Stelle, die mit der Stelle i vertauscht werdens soll
            while (nums[i] == 0 && stelleZuTauschen < numbersOfNumbers) {   
                    int puff = nums[i];
                    nums[i] = nums[stelleZuTauschen];
                    nums[stelleZuTauschen] = puff;
                    stelleZuTauschen++;
            }
        }
        printIntArray(nums);
    }
//------------------------------------------------------------------------------
    static void separateOddEven(int[] nums, int numbersOfNumbers) {
        int firstPlace=0;
        int lastPlace=numbersOfNumbers-1;
        
        while(firstPlace < lastPlace){
            if((nums[firstPlace]%2!=0 && nums[lastPlace]%2==0)){    //Vertauschen
                int puff=nums[firstPlace];
                nums[firstPlace]=nums[lastPlace];
                nums[lastPlace]=puff;
                
                firstPlace++;
                lastPlace--;
            }
            if(nums[firstPlace]%2==0){  //zum nächsten gehen
                firstPlace++;
            }    
            if (nums[lastPlace]%2!=0){  //zum nächsten gehen
                lastPlace--;
            }
        }
        printIntArray(nums);
    }
//------------------------------------------------------------------------------
    static void printIntArray(int[] nums) {
        System.out.print("Array: ");
        for (int i = 0; i < nums.length; i = i + 1) {
            System.out.print(nums[i] + ", ");
        }
        System.out.println();
    }

}
 
Ich habs nicht ausprobiert, aber wahrsch. ist es im Moment so:

egal ob du

1 2 3
4
5

oder

1
2
3
4
5

eingibst, müsste es im Moment mit next() funktionieren, weil vermutlich sowohl sowohl Space und Entertasten-Zeichencode im Moment als Tokentrennzeichen definiert ist.
d.h die Entertaste wird im Moment wahrschl. nur als Tokentrennzeichen, aber nicht als Zeilenende interpretiert.
nextLine() stürzt also nicht ab, sondern wartet einfach weiter auf mehr Input, bis endlich ein Zeilenende kommt, dass du aber mit der Entertaste nicht auslösen kannst.

du kannst ja mal .delimiter() nutzen, um dir die derzeit gültigen Tokentrennzeichen ausgeben zu lassen.
 
Danke erst mal für deine Antwort.

Ich weiß nicht, ob ich dich richtig verstanden habe.
Das Problem liegt nicht beim Einlesen der Zahlen, sondern beim Einlesen der Buchstaben in Zeile 22.

Die Zahlen werden erst in Zeile 33-35 eingelesen.
Ergänzung ()

Schließe hier ab, da der Code doch relativ lang ist und ich das Problem zwischenzeitlich weiter eingrenzen kann.
Öffne dazu ein neues Thema.
 
Zurück
Oben