Page History

...

Når en lager enkle, interaktive programmer har en ofte behov for å lese inn linjer med tekst og konvertere deler av teksten til ulike typer tall, logiske verdier osv. Dette er et eksempel på det som kalles parsing, dvs. oppstykking av tekst i deler og tolkning av delene. For enkel input er Scanner-klassen (i java.util-pakken) veldig hendig, siden den håndterer både oppstykking av teksten i deler og konvertering til de vanligste datatypene.

...

Når Scanner'n er instansiert kan du gjøre essensielt to ting:

1. Spørre En kan spørre om det venter er gitt inn input av en bestemt type som venter på å bli lest, f.eks. linje, tall eller logisk verdi, . Dette gjøres med en av mange hasNext-metoder, f.eks. hasNextLine(), hasNextInt(), hasNextBoolean(), osv. Disse metodene returnerer alle true, dersom input'en som venter på å bli lest passer til typen verdi.
2. LeseEn kan lese/konsumere input av en bestemt type., med tilsvarende next-metoder, f.eks. nextLine(), nextInt(), nextBoolean(), osv. Disse returnerer en verdi av angitt type, f.eks. vil nextInt() returnere int og nextLine() returnere String osv.

Innlesing av tekst-linjer

Det enkleste er å lese inn én og én linje, med nextLine()-metoden. Dette gjøres typisk i en løkke som går inntil datakilden er tom, dvs. så lenge hasNextLine() returnerer true:

// fortsett så lenge det er linjer i input-køen
while (scanner.hasNextLine()) {
	String line = scanner.nextLine();
	// vi hopper ut av løkka hvis linja er tom
	if (line == null || line.length() == 0) {
		break;
	}
	// gjør noe med line her
}

Siden en får en hel linje om gangen, så må en selv tolke innholdet, f.eks. sjekk om formatet er riktig og dele det opp i mindre biter. Dette er nødvendig hvis innholdet i teksten er litt uforutsigbar, f.eks. tillater ulike kombinasjoner av ord, tall, skille tegn osv. Hvis formatet imidlertid er regulært, så en vet hva en kan forvente, så er det nyttig å bruke next-metodene som leser og returnerer spesifikke datatyper.

Innlesing av spesifikke datatyper

Anta f.eks. at du ønsker å lese inn et koordinat-par (int) og en logisk verdi (boolean). Da kan du typisk skrive bruke følgende kode:

// antar at scanner-variablen allerede er instansiert som over og at en har skrevet ut ledetekst til brukeren
int x = scanner.nextInt();
int y = scanner.nextInt();
boolean b = scanner.nextBoolean();

Dersom brukeren så skriver inn en linje med tekst, f.eks. "0 42 true" (uten anførselstegnene), så vil x bli satt til 0, y bli satt til 42 og b til true. Hvis en derimot skriver inn "true 0 42" så vil programmet kræsje, fordi true ikke kan leses som en int. Det er derfor avgjørende at brukeren vet hva som forventes som input og gir det inn på riktig format.

NB! Scanner-en baserer seg på konvensjoner i din locale (altså lokaliteten din, dvs. den regionen du befinner deg i) når den tolker input. Det betyr bl.a. at hvis Java tror du er i Norge så vil den forvente ',' og ikke '.' som desimalkomma i desimaltall (typenedouble og float, som leses med nextDouble() og nextFloat()), og utløse InputMismatchException hvis du skriver inn noe annet. Hvis du vil tvinge Scanner-en til å bruke amerikanske konvensjoner, bl.a. '.' som desimalkomma, så må du si fra om det ved å kalle useLocale-metoden: scanner.useLocale(java.util.Locale.US).

Sjekk av type input

I noen tilfeller er det praktisk at koden som leser input er litt fleksibel, dvs. kan tillate og tolke input av med litt varierende type innhold. Da bruker en hasNext-metodene til å sjekke typen input, før en faktisk leser og tilordner. Anta f.eks. at en skal lese inn en blanding av tall og matematiske operatorer som +, -, * og /. Da kan en bruke følgende kode for sjekk og innlesing:

// fortsett så lenge det er tokens i input-køen (les om tokens i Oppstykking og tolkning av input, nedenfor)
while (scanner.hasNext()) {
	// sjekk om input'en faktisk følger double-syntaksen
	if (scanner.hasNextDouble()) {
		double operand = scanner.nextDouble();
		// gjør noe med operand her
		// ...
 	} else {
		// hvis input'en ikke er en double, er det ihvertfall et ord/token
		String operator = scanner.next();
		// gjør noe med operator-verdien her
		if ("+".equals(operator)) { // husk å sjekke String med equals!
			// +-operasjonen implementeres her ...
		} else if ...
		...
	}
}

Anta at brukeren har skrevet inn "1.0 + 2" (uten anførselstegn). I den første runden i while-løkka vil den første grenen av if'en bli kjørt og operand bli tilordnet 1.0, fordi "1.0" jo følger double-syntaks og hasNextDouble()-metoden derfor returnerer true. I den andre runden vil den andre grenen av if'en bli kjørt og operator blir tilordnet "+" fordi "+" ikke er gyldig iht. double-syntaks. I den tredje runden blir den første grenen kjørt igjen fordi "2" kan leses som en double. Merk imidlertid at det går galt dersom brukeren skriver inn "1.0+2", fordi reglene for oppstykking gjør at dette regnes som ett stykke input og ikke tre.

...