Om de Scanner-klasse te gebruiken, moet deze eerst worden geïmporteerd. Daarna moet er een object van worden geïnstantieerd. Na gebruik van het Scanner-object moet het worden gesloten. Het invoerstroomobject dat het toetsenbord vertegenwoordigt, is System.in. De scanner heeft vele methoden. Alleen de meest gebruikte worden in dit artikel uitgelegd.
Artikel Inhoud
- Eenvoudig gebruik van de scannerklasse
- Invoerregel in waarden spugen
- Primitieve gegevenstypen lezen en valideren
- Invoertoken toewijzen aan een variabele
- Conclusie
Eenvoudig gebruik van de scannerklasse
De volgende code vraagt de gebruiker om een zin in te typen, waarna de zin wordt weergegeven:
importeren java.util.Scanner;
openbaar klasDe klas{
openbaar statisch leegtehoofd( Snaar []argumenten) {
Scanner scanObj= nieuweScanner( Systeem .in);
Systeem .uit.println('Typ een zin en druk op Enter:');
Snaar zin=scanObj.nextLine();
Systeem .uit.println(zin);
scanObj.dichtbij();
}
}
De eerste regel importeert de klasse Scanner. In de hoofdfunctie maakt de eerste regel een scannerobject met behulp van het System.in-object voor het toetsenbord. Zodra het scannerobject is gemaakt, begint het te wachten op invoer. De volgende regel drukt een verklaring af, waarin de gebruiker wordt gevraagd een zin in te typen. De regel die volgt in de code gebruikt de methode nextLine() van het scannerobject om de zin van de gebruiker te lezen nadat hij op Enter heeft gedrukt. De regel erna, in de code, drukt de zin opnieuw af in het terminalvenster. De laatste regel sluit het scannerobject.
Invoerregel in waarden spugen
De volgende code splitst de invoerregel in woorden (tokens), waarbij de spatie als scheidingsteken wordt gebruikt:
importeren java.util.Scanner;openbaar klasDe klas{
openbaar statisch leegtehoofd( Snaar []argumenten) {
Scanner scanObj= nieuweScanner( Systeem .in);
Systeem .uit.println('Typ een rij tokens en druk op Enter:');
terwijl(scanObj.hasNext()){
Systeem .uit.println(scanObj.De volgende());
}
scanObj.dichtbij();
}
}
hasNext() en next() zijn twee andere methoden van het scannerobject. Wanneer het scannerobject een regel leest, houdt het deze vast. next() geeft toegang tot het volgende token (woord). hasNext() retourneert waar als er een ander token is dat nog niet is gebruikt.
Helaas wordt van de gebruiker nog steeds verwacht dat hij invoer invoert voor splitsen en opnieuw weergeven met deze code. Om dat allemaal te beëindigen, drukt u op Ctrl+z, en u zou terug moeten zijn bij de opdrachtprompt.
In de bovenstaande code scheidt het scheidingsteken tokens in de ruimte. Er kan een ander teken worden gebruikt. De volgende code gebruikt de komma. Vergeet niet op Ctrl+z te drukken om de lus te beëindigen als u de code test.
importeren java.util.Scanner;openbaar klasDe klas{
openbaar statisch leegtehoofd( Snaar []argumenten) {
Scanner scanObj= nieuweScanner( Systeem .in);
Systeem .uit.println('Typ een rij tokens en druk op Enter:');
scanObj.gebruik delimiter(',');
terwijl(scanObj.hasNext()){
Systeem .uit.println(scanObj.De volgende());
}
scanObj.dichtbij();
}
}
Als je de code hebt getest, zou je hebben gemerkt dat spaties in tokens zijn opgenomen als onderdeel van tokens (uitvoer). De expressie, scanObj.useDelimiter(,); getypt nadat de invoerregel is gelezen; het is wat de komma het scheidingsteken maakt.
Primitieve gegevenstypen lezen en valideren
nextBoolean() methode
In de volgende code wordt van de gebruiker verwacht dat hij of waar of onwaar typt zonder de aanhalingstekens en vervolgens op Enter drukt. Als de gebruiker iets anders typt, zoals ja of nee, wordt een foutmelding weergegeven.
importeren java.util.Scanner;openbaar klasDe klas{
openbaar statisch leegtehoofd( Snaar []argumenten) {
Systeem .uit.afdrukken('Ben je boven de 24? ');
Scanner scanObj= nieuweScanner( Systeem .in);
booleaansblauw=scanObj.volgendeBoolean();
indien (blauw== waar) {
Systeem .uit.println('Je bent ouder dan 24');
}
anders indien (blauw== vals) {
Systeem .uit.println('Je bent jonger dan 24');
}
scanObj.dichtbij();
}
}
Aangezien java een foutmelding geeft zolang de invoer niet exact waar of onwaar is, is de else if gebruikt in plaats van else.
Het verschil tussen de methoden, print en println, is dat print de invoer op de huidige regel verwacht, terwijl println de invoer op de volgende regel verwacht.
nextByte() methode
Met de ASCII-tekenset is een teken één byte. Bij sommige Oosterse tekensets kan een teken echter uit meer dan één byte bestaan. Onafhankelijk van de tekenset leest en valideert de nextByte-methode de volgende byte van de invoer. Hiervoor kan de volgende code worden gebruikt:
importeren java.util.Scanner;openbaar klasDe klas{
openbaar statisch leegtehoofd( Snaar []argumenten) {
Systeem .uit.afdrukken('Typenummer'<128, press Enter: ');
Scanner scanObj= nieuweScanner( Systeem .in);
bytebt=scanObj.volgendeByte();
Systeem .uit.println(bt);
scanObj.dichtbij();
}
}
Als voor deze code een getal groter dan 127 of een alfabetteken wordt ingevoerd, wordt een foutmelding gegeven.
nextInt() Methode
Het volgende integer-token als invoer kan ook worden gevalideerd en geaccepteerd. De volgende code kan worden gebruikt:
importeren java.util.Scanner;openbaar klasDe klas{
openbaar statisch leegtehoofd( Snaar []argumenten) {
Systeem .uit.afdrukken('Voer een geheel getal in: ');
Scanner scanObj= nieuweScanner( Systeem .in);
intop een=scanObj.volgendeInt();
Systeem .uit.println(op een);
scanObj.dichtbij();
}
}
Voorloop- of volgspaties zijn verwijderd. Voor deze code wordt elke integerwaarde, inclusief waarden groter dan 127, geaccepteerd. Met deze nextXXX()-methoden wordt er een foutmelding gegeven zodra de validatie mislukt.
nextBigInteger() Methode
Het lijkt erop dat software-ingenieurs nooit zullen stoppen met het bedenken van nieuwe dingen. Een groot geheel getal is een geheel getal waarvan de waarde veel groter is dan die van een geheel getal. Met Java kan het echter op dezelfde manier worden gelezen als het gehele getal. De volgende code illustreert dit:
importeren java.util.Scanner;importeren java.math.BigInteger;
openbaar klasDe klas{
openbaar statisch leegtehoofd( Snaar []argumenten) {
Systeem .uit.println('Voer een geheel getal in voor Big Integer: ');
Scanner scanObj= nieuweScanner( Systeem .in);
Groot Integer op een=scanObj.volgendeBigInteger();
Systeem .uit.println(op een);
scanObj.dichtbij();
}
}
Let op de importinstructie, import java.math.BigInteger;. Merk ook op dat het type groot geheel getal begint met een hoofdletter B en niet een kleine letter b.
nextFloat() Methode
Het volgende float-token als invoer kan ook worden gevalideerd en geaccepteerd. De volgende code kan worden gebruikt:
importeren java.util.Scanner;openbaar klasDe klas{
openbaar statisch leegtehoofd( Snaar []argumenten) {
Systeem .uit.afdrukken('Voer een willekeurige float in: ');
Scanner scanObj= nieuweScanner( Systeem .in);
vlotop een=scanObj.volgendeFloat();
Systeem .uit.println(op een);
scanObj.dichtbij();
}
}
Een voorbeeld van een float-getal is 23.456. Voorloop- of volgspaties zijn verwijderd.
volgendeDouble()
De volgende dubbele token als invoer kan ook worden gevalideerd en geaccepteerd. De volgende code kan worden gebruikt:
importeren java.util.Scanner;openbaar klasDe klas{
openbaar statisch leegtehoofd( Snaar []argumenten) {
Systeem .uit.afdrukken('Voer een willekeurig dubbel in: ');
Scanner scanObj= nieuweScanner( Systeem .in);
dubbeleop een=scanObj.volgendeDouble();
Systeem .uit.println(op een);
scanObj.dichtbij();
}
}
Een voorbeeld van een dubbel getal is 23.456. Een dubbel getal is anders dan een float omdat het minder foutenmarge heeft. Voorloop- of volgspaties zijn verwijderd.
nextLine() methode
De methode nextLine() is voor een string. Als de tekenreeks de invoerregel van het toetsenbord is nadat u op Enter hebt gedrukt, kan deze het nieuwe regelteken ' ' hebben. De volgende code kan worden gebruikt:
importeren java.util.Scanner;openbaar klasDe klas{
openbaar statisch leegtehoofd( Snaar []argumenten) {
Systeem .uit.println('Voer een regel in met\N : ');
Scanner scanObj= nieuweScanner( Systeem .in);
Snaar P=scanObj.nextLine();
Systeem .uit.println(P);
scanObj.dichtbij();
}
}
Merk op dat het stringtype begint met de hoofdletter S en niet met de kleine s.
De methoden nextLine(), hasNext() en next() zijn eerder in dit artikel gebruikt. De scanner heeft andere methoden en andere primitieve gegevensmethoden - zie later.
Invoer toewijzen aan een variabele
Invoer kan worden toegewezen aan een variabele, zoals de volgende code laat zien:
importeren java.util.Scanner;openbaar klasDe klas{
openbaar statisch leegtehoofd( Snaar []argumenten) {
Scanner scanObj= nieuweScanner( Systeem .in);
Systeem .uit.afdrukken('Voer naam in: ');
Snaar naam=scanObj.nextLine();
Systeem .uit.afdrukken('Voer Leeftijd in: ');
intleeftijd=scanObj.volgendeInt();
Systeem .uit.afdrukken('Voer Salaris in: ');
dubbelesalaris=scanObj.volgendeDouble();
Systeem .uit.println('Naam: ' +naam+ ', Leeftijd: ' +leeftijd+ ', Salaris: ' +salaris);
scanObj.dichtbij();
}
}
Conclusie
De Scanner in Java is een klasse in het pakket java.util. Deze klasse is bedoeld om invoer te lezen van een string, het toetsenbord, bestand of netwerkaansluiting. Dit artikel heeft zich voornamelijk geconcentreerd op het lezen van invoer vanaf het toetsenbord en het weergeven van het resultaat in het terminalvenster. Soortgelijke ideeën kunnen worden gebruikt om invoer van de tekenreeks, het bestand of het netwerkkanaal te lezen.
Gebruik de methode nextLine() om de hele regel met toetsenbordinvoer te lezen. De regel als een tekenreeks kan worden opgesplitst in tokens met behulp van de methoden hasNext() en next() en de while-lus. Het standaard scheidingsteken voor splitsen is de spatie, maar de programmeur kan een ander scheidingsteken kiezen. Vergeet niet om Ctrl+z te gebruiken om de while-lus te stoppen, indien nodig. Het verwijderen van voorloop- en volgspaties kan worden gedaan met behulp van andere schema's die niet in dit artikel worden behandeld. Validatie van de tokens kan ook worden gedaan met behulp van andere schema's die niet in dit artikel worden behandeld.
Primitieve waarden kunnen worden gelezen met nextBoolean(), nextByte(), nextInt(), enz. Deze nextXXX()-methoden valideren en verwijderen ook voorloop- en volgspaties.
De Java Scanner heeft nog veel meer methoden. Het basisgebruik van de Scanner is echter in dit artikel uitgelegd. De selectie van een token gebeurt eigenlijk met behulp van reguliere expressietechnieken. Het gebruik van reguliere expressietechnieken is een discussie, voor een andere keer.