För att kunna använda skannerklassen måste den importeras först. Därefter måste ett objekt instanseras från det. Efter att du har använt skannerobjektet måste det stängas. Inmatningsströmobjektet som representerar tangentbordet är System.in. Skannern har många metoder. Endast de vanliga kommer att förklaras i denna artikel.
Artikelinnehåll
- Enkel användning av skannerklassen
- Spotta inmatningslinjen i värden
- Läsa och validera primitiva datatyper
- Tilldela inmatningstoken till en variabel
- Slutsats
Enkel användning av skannerklassen
Följande kod uppmanar användaren att skriva in en mening och sedan visar den meningen:
importera java.util.Scanner;
offentlig klassKlassen{
offentlig statisk tomhethuvud( Sträng []args) {
Scanner scanObj= nyScanner( Systemet .i);
Systemet .ut.println('Skriv en mening och tryck på Enter:');
Sträng mening=scanObj.nextLine();
Systemet .ut.println(mening);
scanObj.stänga();
}
}
Den första raden importerar skannerklassen. I huvudfunktionen skapar den första raden ett skannerobjekt som använder System.in -objektet för tangentbordet. Så snart skannerobjektet skapas börjar det vänta på inmatning. Nästa rad skriver ut ett uttalande och ber användaren att skriva in en mening. Raden som följer i koden använder metoden nextLine () för skannerobjektet för att läsa användarens mening efter att han tryckt på Enter. Raden efter, i koden, skriver om meningen igen vid terminalfönstret. Den sista raden stänger skannerobjektet.
Spotta inmatningslinjen i värden
Följande kod delar in inmatningsraden i ord (tokens), med mellanslag som avgränsare:
importera java.util.Scanner;offentlig klassKlassen{
offentlig statisk tomhethuvud( Sträng []args) {
Scanner scanObj= nyScanner( Systemet .i);
Systemet .ut.println('Skriv en rad tokens och tryck på Enter:');
medan(scanObj.harNästa()){
Systemet .ut.println(scanObj.Nästa());
}
scanObj.stänga();
}
}
hasNext () och nästa () är två andra metoder för skannerobjektet. När skannerobjektet läser en rad behåller den den. nästa () öppnar nästa token (word). hasNext () returnerar true om det finns någon annan token som ännu inte är åtkomlig.
Tyvärr förväntas användaren fortfarande skriva in ingång för delning och återvisning med denna kod. För att avsluta allt detta, tryck på Ctrl+z, och du borde vara tillbaka vid kommandotolken.
I koden ovan separerar avgränsaren tokens i utrymmet. En annan karaktär kan användas. Följande kod använder kommatecknet. Glöm inte att trycka på Ctrl+z för att avsluta slingan om du testar koden.
importera java.util.Scanner;offentlig klassKlassen{
offentlig statisk tomhethuvud( Sträng []args) {
Scanner scanObj= nyScanner( Systemet .i);
Systemet .ut.println('Skriv en rad tokens och tryck på Enter:');
scanObj.useDelimiter(',');
medan(scanObj.harNästa()){
Systemet .ut.println(scanObj.Nästa());
}
scanObj.stänga();
}
}
Om du testade koden skulle du ha märkt att mellanslag i tokens har inkluderats som en del av tokens (output). Uttrycket, scanObj.useDelimiter (,); skrivs in efter att inmatningsraden har lästs; det är det som gör komma, avgränsaren.
Läsa och validera primitiva datatyper
nextBoolean () metod
I följande kod förväntas användaren skriva antingen sant eller falskt utan citattecken och sedan trycka på Enter -tangenten om användaren skriver något annat, till exempel ja eller nej, visas ett felmeddelande.
importera java.util.Scanner;offentlig klassKlassen{
offentlig statisk tomhethuvud( Sträng []args) {
Systemet .ut.skriva ut('Är du över 24? ');
Scanner scanObj= nyScanner( Systemet .i);
boolesktbl=scanObj.nästa booleska();
om (bl== Sann) {
Systemet .ut.println('Du är över 24');
}
annan om (bl== falsk) {
Systemet .ut.println('Du är under 24');
}
scanObj.stänga();
}
}
Eftersom java kommer att utfärda ett felmeddelande så länge ingången inte är sann eller falsk exakt, har annars om använts istället för annat.
Skillnaden mellan metoderna, print och println, är att print förväntar sig inmatning på den aktuella raden, medan println förväntar sig input på nästa rad.
nextByte () -metod
Med ASCII -teckenuppsättningen är ett tecken en byte. Men med vissa östra teckenuppsättningar kan ett tecken bestå av mer än en byte. Oberoende av teckenuppsättningen läser och validerar nextByte -metoden nästa byte för ingången. Följande kod kan användas för detta ändamål:
importera java.util.Scanner;offentlig klassKlassen{
offentlig statisk tomhethuvud( Sträng []args) {
Systemet .ut.skriva ut('Typnummer<128, press Enter: ');
Scanner scanObj= nyScanner( Systemet .i);
bytebt=scanObj.nästaByte();
Systemet .ut.println(bt);
scanObj.stänga();
}
}
Om ett tal som är större än 127 eller ett alfabetiskt tecken matas in för denna kod skickas ett felmeddelande.
nextInt () Metod
Nästa heltalstoken som en ingång kan också valideras och accepteras. Följande kod kan användas:
importera java.util.Scanner;offentlig klassKlassen{
offentlig statisk tomhethuvud( Sträng []args) {
Systemet .ut.skriva ut('Ange ett heltal:');
Scanner scanObj= nyScanner( Systemet .i);
intpå ett=scanObj.nextInt();
Systemet .ut.println(på ett);
scanObj.stänga();
}
}
Ledande eller bakre utrymmen har tagits bort. För den här koden accepteras alla heltal, inklusive värden större än 127. Med dessa nextXXX () -metoder skickas ett felmeddelande när valideringen misslyckas.
nextBigInteger () Metod
Det verkar som att mjukvaruutvecklare aldrig kommer att sluta komma med nya saker. Ett stort heltal är ett heltal vars värde är mycket större än ett heltal. Men med Java kan det läsas på samma sätt som heltalet. Följande kod illustrerar detta:
importera java.util.Scanner;importera java.math.BigInteger;
offentlig klassKlassen{
offentlig statisk tomhethuvud( Sträng []args) {
Systemet .ut.println('Ange ett heltal för stort heltal:');
Scanner scanObj= nyScanner( Systemet .i);
BigInteger på ett=scanObj.nästaBigInteger();
Systemet .ut.println(på ett);
scanObj.stänga();
}
}
Observera importutdraget, importera java.math.BigInteger ;. Observera också att den stora heltalstypen börjar med en versal B och inte en liten b.
nextFloat () -metod
Nästa float -token som en ingång kan också valideras och accepteras. Följande kod kan användas:
importera java.util.Scanner;offentlig klassKlassen{
offentlig statisk tomhethuvud( Sträng []args) {
Systemet .ut.skriva ut('Ange en flottör:');
Scanner scanObj= nyScanner( Systemet .i);
flytapå ett=scanObj.nextFloat();
Systemet .ut.println(på ett);
scanObj.stänga();
}
}
Ett exempel på ett flottörtal är 23.456. Ledande eller bakre utrymmen har tagits bort.
nästaDubbel ()
Nästa dubbla token som ingång kan också valideras och accepteras. Följande kod kan användas:
importera java.util.Scanner;offentlig klassKlassen{
offentlig statisk tomhethuvud( Sträng []args) {
Systemet .ut.skriva ut('Ange valfri dubbel:');
Scanner scanObj= nyScanner( Systemet .i);
dubbelpå ett=scanObj.nästaDubbel();
Systemet .ut.println(på ett);
scanObj.stänga();
}
}
Ett exempel på ett dubbeltal är 23.456. Ett dubbeltal skiljer sig från en float eftersom det har mindre felmarginal. Ledande eller bakre utrymmen har tagits bort.
nextLine () -metod
NextLine () -metoden är för en sträng. Om strängen är inmatningsraden från tangentbordet efter att du har tryckt på Enter kan den ha nyradstecknet ‘ n’. Följande kod kan användas:
importera java.util.Scanner;offentlig klassKlassen{
offentlig statisk tomhethuvud( Sträng []args) {
Systemet .ut.println('Ange en rad med\n: ');
Scanner scanObj= nyScanner( Systemet .i);
Sträng sid=scanObj.nextLine();
Systemet .ut.println(sid);
scanObj.stänga();
}
}
Lägg märke till att strängtypen börjar med versalerna S och inte de små.
NextLine (), hasNext () och next () metoder har använts tidigare i denna artikel. Skannern har andra metoder och andra primitiva datametoder - se senare.
Tilldela inmatning till en variabel
Inmatning kan tilldelas en variabel, som följande kod visar:
importera java.util.Scanner;offentlig klassKlassen{
offentlig statisk tomhethuvud( Sträng []args) {
Scanner scanObj= nyScanner( Systemet .i);
Systemet .ut.skriva ut('Skriv namn: ');
Sträng namn=scanObj.nextLine();
Systemet .ut.skriva ut('Ange ålder:');
intålder=scanObj.nextInt();
Systemet .ut.skriva ut('Ange lön:');
dubbellön=scanObj.nästaDubbel();
Systemet .ut.println('Namn: ' +namn+ ', Ålder: ' +ålder+ ', Lön:' +lön);
scanObj.stänga();
}
}
Slutsats
Skannern i Java är en klass i java.util -paketet. Denna klass syftar till att läsa inmatning från en sträng, tangentbordet, filen eller nätverksuttaget. Denna artikel har huvudsakligen koncentrerat sig på att läsa ingång från tangentbordet och visa resultatet i terminalfönstret. Liknande idéer kan användas för att läsa inmatning från strängen, filen eller nätverkskanalen.
Om du vill läsa hela raden med tangentbordsinmatning använder du metoden nextLine (). Raden som en sträng kan delas upp i tokens med hasNext () och next () metoderna och while loop. Standardavgränsaren för delning är utrymmet, men programmeraren kan välja någon annan avgränsare. Glöm inte att göra Ctrl+z för att stoppa medan loop, om det behövs. Ta bort ledande och bakre mellanslag kan göras med andra system som inte behandlas i den här artikeln. Validering av tokens kan också göras med andra system som inte behandlas i denna artikel.
Primitiva värden kan läsas med nextBoolean (), nextByte (), nextInt (), etc. Dessa nextXXX () metoder gör validering och tar också bort ledande och efterföljande mellanslag.
Java -skannern har många fler metoder. Den grundläggande användningen av skannern har dock förklarats i denna artikel. Valet av en token görs faktiskt med hjälp av reguljära uttryckstekniker. Användningen av reguljära uttryckstekniker är diskussion, någon annan gång.