Was ist der Hauptunterschied zwischen next()und nextLine()?
Mein Hauptziel ist es, den gesamten Text mit einem zu lesen, der mit einer beliebigen Quelle (z. B. einer Datei) Scanner"verbunden" sein kann .
Welches soll ich wählen und warum?
Antworten:
Ich lese immer lieber Eingaben mit nextLine()und analysiere dann den String.
Mit using next()wird nur das zurückgegeben, was vor dem Trennzeichen steht (standardmäßig Leerzeichen). nextLine()Bewegt den Scanner automatisch nach unten, nachdem die aktuelle Zeile zurückgegeben wurde.
Ein nützliches Tool zum Parsen von Daten nextLine()wäre str.split("\\s+").
String data = scanner.nextLine();
String[] pieces = data.split("\\s+");
// Parse the pieces
Weitere Informationen zur Scanner- oder String-Klasse finden Sie unter den folgenden Links.
Scanner: http://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html
Zeichenfolge: http://docs.oracle.com/javase/7/docs/api/java/lang/String.html
BufferedReader, um Zeile für Zeile zu lesen? Ich verstehe nicht, warum Scannerdas so angesagt ist.
next()kann die Eingabe nur bis zum Leerzeichen lesen. Es kann keine zwei durch ein Leerzeichen getrennten Wörter lesen. Außerdem next()stellt den Cursor in der gleichen Zeile nach dem Eingang zu lesen.
nextLine()Liest die Eingabe einschließlich des Leerzeichens zwischen den Wörtern (dh sie liest bis zum Zeilenende \n). Sobald die Eingabe gelesen wurde, nextLine()positioniert sich der Cursor in der nächsten Zeile.
Zum Lesen der gesamten Zeile können Sie verwenden nextLine().
Von JavaDoc:
- A unterteilt
Scannerseine Eingabe in Token mithilfe eines Begrenzungsmusters, das standardmäßig mit Leerzeichen übereinstimmt.next(): Findet das nächste vollständige Token von diesem Scanner und gibt es zurück.nextLine(): Schiebt diesen Scanner über die aktuelle Zeile hinaus und gibt die übersprungene Eingabe zurück.
Also im Falle von "small example<eol>text" next()sollte "klein" und nextLine()sollte "kleines Beispiel" zurückgeben.
next()enthalten die \nin der zurückgegebenen Token ??
Was mir aufgefallen ist, abgesehen davon, dass next () nur bis zum Leerzeichen scannt, wo nextLine () die gesamte Zeile scannt, ist, dass next wartet, bis es ein vollständiges Token erhält, während nextLine () nicht auf das vollständige Token wartet, wenn jemals '\ n' wird erhalten (dh wenn Sie die Eingabetaste drücken), bewegt sich der Scannercursor zur nächsten Zeile und gibt die übersprungene vorherige Zeile zurück. Es wird nicht geprüft, ob Sie eine vollständige Eingabe gegeben haben oder nicht, auch wenn eine leere Zeichenfolge verwendet wird, während next () keine leere Zeichenfolge verwendet
public class ScannerTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int cases = sc.nextInt();
String []str = new String[cases];
for(int i=0;i<cases;i++){
str[i]=sc.next();
}
}
}
Probieren Sie dieses Programm aus, indem Sie die Schleife next () und nextLine () in for ändern. Drücken Sie dann '\ n', dh die Eingabetaste ohne Eingabe. Sie können feststellen, dass die Methode nextLine () nach Drücken einer bestimmten Anzahl von Fällen beendet wird, in denen as next () wird erst beendet, wenn Sie es für die angegebene Anzahl von Fällen angeben und eingeben .
next()in der Praxis funktioniert. Er ignoriert die Eingabetaste, nexLine()akzeptiert ihn jedoch als vollständige Eingabe und repliziert ihn in die Konsole, wenn Sie den Wert der erfassten Daten wiedergeben. Ich habe gerade System.out.println(str[i]);als neue Zeile unten hinzugefügt str[i]=sc.next();oderstr[i]=sc.nextLine();
Der entscheidende Punkt ist, herauszufinden, wo die Methode stoppt und wo sich der Cursor nach dem Aufrufen der Methoden befindet.
Alle Methoden lesen Informationen, die kein Leerzeichen zwischen der Cursorposition und den nächsten Standardtrennzeichen enthalten (Leerzeichen, Tabulator, \ n - erstellt durch Drücken der Eingabetaste). Der Cursor stoppt vor den Begrenzern, mit Ausnahme von nextLine()Informationen (einschließlich Leerzeichen, die durch Trennzeichen erstellt wurden) zwischen der Cursorposition und \ n, und der Cursor stoppt hinter \ n.
Betrachten Sie beispielsweise die folgende Abbildung:
|23_24_25_26_27\n
| -> die aktuelle Cursorposition
_ -> Leerzeichen
stream -> Bold (die Informationen, die von der aufrufenden Methode erhalten wurden)
Sehen Sie, was passiert, wenn Sie diese Methoden aufrufen:
nextInt()
Lesen Sie 23 | _24_25_26_27 \ n
nextDouble()
Lesen Sie 23_ 24 | _25_26_27 \ n
next()
Lesen Sie 23_24_ 25 | _26_27 \ n
nextLine()
Lesen Sie 23_24_25 _26_27 \ n |
Danach sollte die Methode je nach Ihren Anforderungen aufgerufen werden.
Kurz gesagt: Wenn Sie ein String-Array mit der Länge t eingeben, erwartet Scanner # nextLine () t Zeilen. Jeder Eintrag im String-Array wird durch die Eingabetaste vom anderen unterschieden. Und Scanner # next () nimmt weiterhin Eingaben bis vor Sie drücken die Eingabetaste, speichern jedoch die Zeichenfolge (das Wort) im Array, das durch Leerzeichen getrennt ist.
Schauen wir uns den folgenden Codeausschnitt an
Scanner in = new Scanner(System.in);
int t = in.nextInt();
String[] s = new String[t];
for (int i = 0; i < t; i++) {
s[i] = in.next();
}
Wenn ich in meiner IDE über dem Codeausschnitt laufe (sagen wir für Zeichenfolgenlänge 2), spielt es keine Rolle, ob ich meine Zeichenfolge als eingebe
Eingabe als: - abcd abcd oder
Eingabe als: -
A B C D
A B C D
Die Ausgabe erfolgt wie abcd
A B C D
Wenn wir jedoch im selben Code die next () -Methode durch nextLine () ersetzen
Scanner in = new Scanner(System.in);
int t = in.nextInt();
String[] s = new String[t];
for (int i = 0; i < t; i++) {
s[i] = in.nextLine();
}
Wenn Sie dann die Eingabeaufforderung als - abcd abcd eingeben
Ausgabe ist: -
abcd abcd
und wenn Sie die Eingabeaufforderung an der Eingabeaufforderung als abcd eingeben (und wenn Sie die Eingabetaste drücken, um die nächste abcd in einer anderen Zeile einzugeben, wird die Eingabeaufforderung einfach beendet und Sie erhalten die Ausgabe).
Ausgabe ist: -
A B C D
Von Javadocs
next () Gibt das nächste Token zurück, wenn es mit dem aus der angegebenen Zeichenfolge erstellten Muster übereinstimmt. nextLine () Schiebt diesen Scanner über die aktuelle Zeile hinaus und gibt die übersprungene Eingabe zurück.
Welches Sie wählen, hängt davon ab, welches Ihren Bedürfnissen am besten entspricht. Wenn ich eine ganze Datei lesen würde, würde ich mich für nextLine entscheiden, bis ich die gesamte Datei hätte.
Die Methoden next () und nextLine () sind dem Scanner zugeordnet und werden zum Abrufen von String-Eingaben verwendet. Ihre Unterschiede sind ...
next () kann die Eingabe nur bis zum Leerzeichen lesen. Es kann keine zwei durch Leerzeichen getrennten Wörter lesen. Außerdem setzt next () den Cursor nach dem Lesen der Eingabe in dieselbe Zeile.
nextLine () liest Eingaben einschließlich Leerzeichen zwischen den Wörtern (dh bis zum Zeilenende \ n). Sobald die Eingabe gelesen wurde, positioniert nextLine () den Cursor in der nächsten Zeile.
import java.util.Scanner;
public class temp
{
public static void main(String arg[])
{
Scanner sc=new Scanner(System.in);
System.out.println("enter string for c");
String c=sc.next();
System.out.println("c is "+c);
System.out.println("enter string for d");
String d=sc.next();
System.out.println("d is "+d);
}
}
Ausgabe:
Zeichenfolge für c abc eingeben def
c ist abc
Zeichenfolge für d eingeben
d ist def
Wenn Sie nextLine () anstelle von next () verwenden, dann
Ausgabe:
Zeichenfolge für c eingeben
ABC DEF
c ist ABC DEF Geben Sie
die Zeichenfolge für d ein
GHI
d ist GHI
Nur für ein weiteres Beispiel von Scanner.next () und nextLine () gilt Folgendes: nextLine () lässt den Benutzer nicht eingeben, während next () den Scanner warten lässt und die Eingabe liest.
Scanner sc = new Scanner(System.in);
do {
System.out.println("The values on dice are :");
for(int i = 0; i < n; i++) {
System.out.println(ran.nextInt(6) + 1);
}
System.out.println("Continue : yes or no");
} while(sc.next().equals("yes"));
// while(sc.nextLine().equals("yes"));
Ein Scanner unterteilt seine Eingabe mithilfe eines Begrenzungsmusters in Token, das standardmäßig als Whitespaces bezeichnet wird .
Next () liest ein einzelnes Wort und wenn es ein Leerzeichen erhält, hört es auf zu lesen und der Cursor kehrt an seine ursprüngliche Position zurück. NextLine (), während dieses ein ganzes Wort liest, auch wenn es auf ein Leerzeichen trifft. Der Cursor stoppt, wenn das Lesen beendet ist, und der Cursor springt zum Zeilenende zurück. Sie müssen also kein Delimeter verwenden, wenn Sie ein vollständiges Wort als Satz lesen möchten. Sie müssen nur NextLine () verwenden.
public static void main(String[] args) {
// TODO code application logic here
String str;
Scanner input = new Scanner( System.in );
str=input.nextLine();
System.out.println(str);
}
Beide Funktionen werden verwendet, um zum nächsten Scanner-Token zu wechseln.
Der Unterschied besteht darin, wie das Scannertoken generiert wird
next () generiert Scannertoken mit dem Trennzeichen als Leerraum
nextLine () generiert Scannertoken mit dem Trennzeichen '\ n' (dh Tastendruck eingeben)
Ich habe auch ein Problem mit einem Trennzeichen. Die Frage war alles über Eingaben von
Das Problem
Die Lösung
Ich habe das Trennzeichen für meinen Scanner verwendet und bin erfolgreich ausgegangen.
Beispiel
public static void main (String args[]){
//Initialize the Scanner this way so that it delimits input using a new line character.
Scanner s = new Scanner(System.in).useDelimiter("\n");
System.out.println("Enter Your Name: ");
String name = s.next();
System.out.println("Enter Your Age: ");
int age = s.nextInt();
System.out.println("Enter Your E-mail: ");
String email = s.next();
System.out.println("Enter Your Address: ");
String address = s.next();
System.out.println("Name: "+name);
System.out.println("Age: "+age);
System.out.println("E-mail: "+email);
System.out.println("Address: "+address);
}
Der grundlegende Unterschied besteht darin, dass next () verwendet wird, um die Eingabe abzurufen, bis das Trennzeichen gefunden wird (standardmäßig ist es ein Leerzeichen, aber Sie können es auch ändern) und das eingegebene Token zurückgibt. Der Cursor bleibt dann in derselben Zeile. Während in nextLine () die Eingabe gescannt wird, bis wir die Eingabetaste drücken, das Ganze zurückgeben und den Cursor in die nächste Zeile setzen. ** **.
Scanner sc=new Scanner(System.in);
String s[]=new String[2];
for(int i=0;i<2;i++){
s[i]=sc.next();
}
for(int j=0;j<2;j++)
{
System.out.println("The string at position "+j+ " is "+s[j]);
}
** **.
Versuchen Sie, diesen Code auszuführen, indem Sie die Eingabe als "Hallo Welt" angeben. Der Scanner liest die Eingabe bis 'o' und dann tritt ein Trennzeichen auf. S [0] ist also "Hallo" und der Cursor zeigt auf die nächste Position nach dem Trennzeichen ( das ist in unserem Fall 'W'), und wenn s [1] gelesen wird, scannt es die "Welt" und gibt sie als nächstes vollständiges Token (per Definition von Scanner) an s [1] zurück. Wenn wir nextLine () verwenden Stattdessen liest es die "Hallo Welt" vollständig und auch mehr, bis wir die Eingabetaste drücken und sie in s [0] speichern. Wir können auch eine andere Zeichenfolge angeben, indem wir nextLine () verwenden. Ich empfehle Ihnen, dieses und weitere Beispiele zu verwenden und um Klarstellung zu bitten.