Wat is het belangrijkste verschil tussen next()en nextLine()?
Mijn belangrijkste doel is om alle tekst te lezen met behulp van een Scannerdie kan worden “verbonden” met elke bron(bestand bijvoorbeeld).
Welke moet ik kiezen en waarom?
Antwoord 1, autoriteit 100%
Ik geef er altijd de voorkeur aan om invoer te lezen met nextLine()en dan de string te ontleden.
Het gebruik van next()geeft alleen terug wat voor het scheidingsteken komt (standaard witruimte). nextLine()verplaatst de scanner automatisch naar beneden nadat de huidige regel is teruggekeerd.
Een handig hulpmiddel voor het ontleden van gegevens van nextLine()is str.split("\\s+").
String data = scanner.nextLine();
String[] pieces = data.split("\\s+");
// Parse the pieces
Raadpleeg de volgende links voor meer informatie over de Scanner-klasse of String-klasse.
Scanner: http://docs.oracle. com/javase/7/docs/api/java/util/Scanner.html
String: http://docs.oracle. com/javase/7/docs/api/java/lang/String.html
Antwoord 2, autoriteit 59%
next()kan de invoer alleen lezen tot aan de spatie. Het kan geen twee woorden lezen, gescheiden door een spatie. Ook plaatst next()de cursor in dezelfde regel na het lezen van de invoer.
nextLine()leest invoer inclusief spatie tussen de woorden (dat wil zeggen, het leest tot het einde van regel \n). Zodra de invoer is gelezen, plaatst nextLine()de cursor op de volgende regel.
Voor het lezen van de hele regel kunt u nextLine()gebruiken.
Antwoord 3, autoriteit 22%
Van JavaDoc:
- Een
Scannerverdeelt zijn invoer in tokens met een scheidingstekenpatroon, dat standaard overeenkomt met witruimte.next(): vindt en retourneert het volgende volledige token van deze scanner.nextLine(): brengt deze scanner voorbij de huidige regel en retourneert de invoer die werd overgeslagen.
Dus in het geval van "small example<eol>text"next()zou “small” moeten retourneren en nextLine()zou moeten retourneren “klein voorbeeld”
Antwoord 4, autoriteit 15%
Het belangrijkste punt is om te vinden waar de methode zal stoppen en waar de cursor zal zijn na het aanroepen van de methoden.
Alle methoden lezen informatie die geen witruimte bevat tussen de cursorpositie en de volgende standaardscheidingstekens (witruimte, tab, \n–gemaakt door op Enter te drukken). De cursor stopt voor de scheidingstekens, behalve voor nextLine(), die informatie leest (inclusief witruimte gecreëerd door scheidingstekens) tussen de cursorpositie en \n, en de cursor stopt achter \n.
Beschouw bijvoorbeeld de volgende illustratie:
|23_24_25_26_27\n
|-> de huidige cursorpositie
_-> witruimte
streamen-> Vet (de informatie verkregen door de aanroepmethode)
Kijk wat er gebeurt als je deze methoden aanroept:
nextInt()
lees 23|_24_25_26_27\n
nextDouble()
lees 23_24|_25_26_27\n
next()
lees 23_24_25|_26_27\n
nextLine()
lees 23_24_25_26_27\n|
Hierna moet de methode worden aangeroepen, afhankelijk van uw vereisten.
Antwoord 5, autoriteit 12%
Wat ik heb gemerkt, behalve dat next() alleen scant tot in de ruimte waar nextLine() de hele regel scant, is dat next wacht tot het een compleet token krijgtwaar als nextLine() wacht niet op volledige token, wanneer ooit ‘\n’ wordt verkregen (dwz wanneer u op enter drukt), gaat de scannercursor naar de volgende regel en geeft de vorige regel overgeslagen terug.Er wordt niet gecontroleerd of u volledige invoer hebben gegeven of niet, zelfs als er een lege tekenreeks voor nodig is, is als next() geen lege tekenreeks nodig
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();
}
}
}
Probeer dit programma door de next() en nextLine() in de for-lus te veranderen, blijf op ‘\n’ drukken, dat is de enter-toets zonder enige invoer, je kunt zien dat het met de nextLine()-methode wordt beëindigdna het indrukken van een bepaald aantal gevallen waarbij als next() niet eindigttotdat u het opgeeft en invoert voor het opgegeven aantal gevallen.
Antwoord 6, autoriteit 4%
Kortom: als u een string-array met de lengte t invoert, verwacht Scanner#nextLine() t-regels, elk item in de string-array wordt van de andere onderscheiden door de enter-toets. En Scanner#next() behoudt invoer nemen totdat u op enter drukt, maar string (woord) opslaat in de array, die wordt gescheiden door witruimte.
Laten we eens kijken naar het volgende codefragment
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();
}
wanneer ik een bovenstaand codefragment in mijn IDE uitvoer (laten we zeggen voor stringlengte 2), maakt het niet uit of ik mijn string invoer als
Invoer als:- abcd abcd of
Invoer als:-
abcd
abcd
Uitvoer zal zijn als
abcd
abcd
Maar als we in dezelfde code de methode next() vervangen door nextLine()
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();
}
Als u vervolgens invoer invoert als –
abcd abcd
Uitvoer is:-
abcd abcd
en als u de invoer op prompt invoert als
abcd (en als u op enter drukt om de volgende abcd in een andere regel in te voeren, wordt de invoerprompt gewoon afgesloten en krijgt u de uitvoer)
Uitgang is: –
ABCD
Antwoord 7, Autoriteit 3%
van Javadocs
Volgende () Retourneert het volgende token als deze overeenkomt met het patroon dat is geconstrueerd in de opgegeven reeks.
Sluitlijn () gaat verder met deze scanner langs de huidige regel en retourneert de ingang die werd overgeslagen.
Welke u kiest, hangt af van het beste bij uw behoeften. Als ik me een heel bestand leest, zou ik voor de voorname gaan totdat ik al het bestand had.
Antwoord 8, Autoriteit 2%
Vanaf de documentatie voor Scanner :
Een scanner breekt zijn ingang in tokens met behulp van een scheidingspatroon, die standaard overeenkomt met WhiteSpace.
Vanaf de documentatie voor volgende () :
Een volledig token wordt voorafgegaan en gevolgd door input die overeenkomt met het scheidingspatroon.
Antwoord 9
Volgende () en de methoden van de volgende lijn () worden geassocieerd met scanner en worden gebruikt voor het krijgen van stringingangen. Hun verschillen zijn …
Volgende () kan de invoer alleen lezen tot de ruimte. Het kan niet lezen twee woorden gescheiden door de ruimte. Ook plaatst () de cursor in dezelfde lijn na het lezen van de invoer.
NEUSTLANDLEIDING () Leest ingang inclusief ruimte tussen de woorden (dat wil zeggen, het leest tot het einde van de lijn \ N). Zodra de invoer wordt gelezen, positioneert de NEUSTLINE () de cursor in de volgende regel.
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);
}
}
Uitvoer:
voer string in voor c
abc def
c is abc
voer een tekenreeks in voor d
d is zeker
Als je nextLine() gebruikt in plaats van next() dan
Uitvoer:
voer een tekenreeks in voor c
ABC DEF
c is ABC DEF
voer string in voor d
GHI
d is GHI
Antwoord 10
-
Alleen voor een ander voorbeeld van Scanner.next() en nextLine() is dat zoals hieronder :
nextLine() laat de gebruiker niet typen terwijl next() de scanner laat wachten en de invoer leest.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"));
Antwoord 11
Beide functies worden gebruikt om naar het volgende Scanner-token te gaan.
Het verschil ligt in de manier waarop het scannertoken wordt gegenereerd
next() genereert scannertokens met scheidingsteken als Witte ruimte
nextLine() genereert scannertokens met scheidingsteken als ‘\n’(d.w.z. Enter
toetsaanslagen)
Antwoord 12
Een scannerverdeelt zijn invoer in tokens met behulp van een scheidingstekenpatroon, dat standaard bekend staat als de Witruimten.
Next()wordt gebruikt om een enkel woord te lezen en wanneer er een spatie wordt weergegeven, stopt het met lezen en keert de cursor terug naar zijn oorspronkelijke positie.
NextLine()terwijl deze een heel woord voorleest, zelfs als het een spatie tegenkomt. De cursor stopt wanneer hij klaar is met lezen en de cursor gaat terug naar het einde van de regel.
dus u hoeft geen scheidingstekente gebruiken wanneer u een volledig woord als een zin wilt lezen. U hoeft alleen NextLine() te gebruiken.
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);
}
Antwoord 13
Ik heb ook een probleem met een scheidingsteken.
de vraag ging helemaal over de input van
- voer je naam in.
- voer je leeftijd in.
- voer je e-mailadres in.
- voer je adres in.
Het probleem
- Ik ben geslaagd met naam, leeftijd en e-mailadres.
- Toen ik het adres bedacht van twee woorden met een spatie(Harnet straat), kreeg ik net de eerste “harnet”.
De oplossing
Ik heb het scheidingsteken voor mijn scanner gebruikt en ben geslaagd.
Voorbeeld
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);
}
Antwoord 14
Het basisverschil is de volgende () wordt gebruikt voor het gouwen van de invoer totdat de scheidingsteken wordt aangetroffen (standaard is het witruimte, maar u kunt het ook wijzigen) en retourneren het token dat u hebt ingevoerd. De cursor blijft dan op de Same Line.Whereas in NEUSTLANDS () Het scant de invoer totdat we op de knop Enter treffen en het geheel retourneren en plaatst de cursor in de volgende regel.
**
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]);
}
**
Probeer deze code uit te voeren door input te geven als “Hallo World”. De scanner leest de invoer tot ‘O’ en vervolgens een scheidingsteken vindt plaats. Dus is “Hallo” en de cursor zal naar de volgende positie zijn ” Na scheidingsteken (dat is ‘w’ in ons geval), en wanneer S [1] wordt gelezen, scant het de “World” en breng het terug naar S [1] als het volgende volledige token (per definitie van scanner). Als we gebruiken NESTSLINE () In plaats daarvan zal het de “Hallo World” volledig en ook meer lezen totdat we op de knop Enter raken en opslaan in S [0].
We kunnen ook een andere reeks geven door de next () te gebruiken. Ik raad je aan om dit voorbeeld en meer te gebruiken en om een verduidelijking te vragen.
Antwoord 15
Het verschil kan heel duidelijk zijn met de onderstaande code en de uitvoer ervan.
public static void main(String[] args) {
List<String> arrayList = new ArrayList<>();
List<String> arrayList2 = new ArrayList<>();
Scanner input = new Scanner(System.in);
String product = input.next();
while(!product.equalsIgnoreCase("q")) {
arrayList.add(product);
product = input.next();
}
System.out.println("You wrote the following products \n");
for (String naam : arrayList) {
System.out.println(naam);
}
product = input.nextLine();
System.out.println("Enter a product");
while (!product.equalsIgnoreCase("q")) {
arrayList2.add(product);
System.out.println("Enter a product");
product = input.nextLine();
}
System.out.println();
System.out.println();
System.out.println();
System.out.println();
System.out.println("You wrote the following products \n");
for (String naam : arrayList2) {
System.out.println(naam);
}
}
Uitvoer:
Enter a product
aaa aaa
Enter a product
Enter a product
bb
Enter a product
ccc cccc ccccc
Enter a product
Enter a product
Enter a product
q
You wrote the following products
aaa
aaa
bb
ccc
cccc
ccccc
Enter a product
Enter a product
aaaa aaaa aaaa
Enter a product
bb
Enter a product
q
You wrote the following products
aaaa aaaa aaaa
bb
Het is duidelijk dat het standaard scheidingsteken de door spatie gescheiden producten toevoegt aan de lijst wanneer de volgende wordt gebruikt, dus elke keer dat door spaties gescheiden tekenreeksen op een regel worden ingevoerd, zijn het verschillende tekenreeksen.
Met nextLine heeft spatie geen betekenis en is de hele regel één string.