La classe Scanner rappresenta la soluzione più semplice per realizzare in Java un input da uno stream di caratteri. La classe Scanner appartiene al package java.util e i suoi oggetti sono in grado di individuare e interpretare i tipi primitivi e le stringhe presenti all’interno di uno stream di caratteri. Essa presenta diversi costruttori che permettono di ottenere un oggetto di tipo Scanner a partire da oggetti di altri tipi, quali ad esempio:
- InputStream, utile in quei casi in cui, per esempio, si debba leggere da tastiera (l’oggetto System.in, si ricorda, è di tipo InputStream).
- String, utile in quei casi in cui sia necessario procurarsi degli input da una stringa.
- File, utile in quei casi in cui l’input proviene da un file di testo.
Per approfondimenti al solito si rimanda alla documentazione ufficiale del linguaggio Java (link), di seguito vediamo solo alcuni esempi di utilizzo per i primi due casi: lettura da tastiera e da stringhe, per il terzo caso della lettura da un file di testo, invece, si rimanda al seguente link. Prima però accenniamo a quali sono alcuni dei metodi più utilizzati di questa classe.
(Si tenga presente che la classe Scanner suddivide lo stream dei caratteri in token, cioè in spezzoni di stringhe separate dai caratteri delimitatori. I caratteri delimitatori di default sono: gli spazi, i caratteri di tabulazione e i caratteri di newline).
- int nextInt(): legge il token successivo interpretandolo come un numero intero e lo restituisce al chiamante, o lancia un eccezione di tipo InputMismatchException se il token non è un intero.
- double nextDouble(): legge il token successivo interpretandolo come un numero reale e lo restituisce al chiamante, o lancia un eccezione di tipo InputMismatchException se il token non è un reale.
- String nextLine(): legge la riga di testo (successiva) e la restituisce al chiamante.
- String next(): legge il successivo token senza delimitatori e lo restituisce al chiamante.
- boolean hasNextInt(): restituisce vero se il prossimo token può essere interpretato come un numero intero, falso altrimenti.
- boolean hasNextDouble(): restituisce vero se il prossimo token può essere interpretato come un numero reale, falso altrimenti.
- boolean hasNextLine(): restituisce vero se in input è disponibile una ulteriore riga, falso altrimenti.
- boolean hasNext(): restituisce vero se in input è disponibile un ulteriore token, falso altrimenti.
- Scanner useDelimiter(String): modifica il delimitatore dei token, dove la stringa passata come parametro può essere una espressione regolare (vedi esempio più avanti).
Il caso più tipico di utilizzo di un oggetto di classe Scanner è quello che utilizza il metodo nextLine() per leggere una riga intera.
|
1 2 3 4 5 6 7 8 |
import java.util.Scanner; public class ProvaScanner { public static void main(String[] args) { Scanner in = new Scanner(System.in); //istanzia un oggetto lettore di tipo Scanner String s = in.nextLine(); //legge una riga di testo e la memorizza nella variabile s System.out.println("Ho letto la riga: " + s); } } |
Vediamo anche alcuni esempi di utilizzo della classe Scanner con gli altri metodi:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
import java.util.Scanner; import java.util.InputMismatchException; public class Main { public static void main(String[] argv) { int i, j; Scanner scanner = new Scanner(System.in); try { System.out.print("Primo numero: "); i = scanner.nextInt(); System.out.print("Secondo numero: "); j = scanner.nextInt(); System.out.println(i + j); } catch(InputMismatchException ex) { System.out.println("Errore, input non valido.); } finally { scanner.close(); } } } |
Nell’esempio di sopra vengono prelevati da tastiera due numeri e vengono sommati. Il tutto è stato inserito in un blocco try-catch-finally poiché gli input forniti potrebbero non essere degli interi e in tal caso viene lanciata un’eccezione di classe InputMismatchException. In questo esempio viene utilizzato anche il metodo close() che permette di rilasciare le risorse occupate dall’oggetto di classe Scanner creato.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import java.util.Scanner; public class Main { public static void main(String[] argv) { String input = "aaa 1 xyz 56 78 .,- pp 1092 yasl 3.14 100"; Scanner scanner = new Scanner(input); while(scanner.hasNext()) { // se il prossimo token è un intero lo estrae e lo visualizza if(scanner.hasNextInt()) System.out.println(scanner.nextInt()); // altrimenti lo salta else scanner.next(); } scanner.close(); } } |
Nell’esempio di sopra si ha una stringa che utilizza un delimitatore di default (lo spazio), dalla quale vengono estratti solo gli interi saltando i restanti token. L’output ottenuto è il seguente:
1
56
78
1092
100
Il delimitatore di default può essere modificato tramite il metodo useDelimiter(), come nell’esempio seguente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import java.util.Scanner; public class InputConScanner { public static void main(String[] argv) { String input = "100;120;300;80"; Scanner scanner = new Scanner(input); scanner.useDelimiter(";"); while(scanner.hasNext()) { // se il prossimo token è un intero lo estrae e lo visualizza if(scanner.hasNextInt()) System.out.println(scanner.nextInt()); // altrimenti lo salta else scanner.next(); } scanner.close(); } } |
L’esempio precedente produce l’output seguente:
100
120
300
80
NOTA BENE. Attenzione, l’esempio precedente funziona solo se i numeri interi sono separati esattamente da un solo carattere di punto e virgola. Se si vuole che funzioni anche nel caso in cui a separarli ci siano più caratteri diversi, compreso gli spazi, bisogna passare al metodo un’espressione regolare, argomento questo complesso per il quale si rimanda alla documentazione del linguaggio. Qui si fornisce solo la soluzione nel caso tra i numeri interi, oltre al punto e virgola, ci siano anche degli spazi. In questo caso la stringa da passare al metodo è : “\s*;\s*”. Il primo backslash nell’espressione indica che quello che segue è un carattere speciale, ossia l’espressione s* che vuol dire “da 0 a un numero a piacere di spazi“.
P.S. Per risolvere un problema di estrazione di token da una stringa come il precedente, può essere più conveniente o sfruttare direttamente i metodi della classe String, come ad esempio i metodi split() e trim(), o riccorre alla classe StringTokenizer sftuttando i metodi hasMoreToken() e nextToken(), per i quali si rimanda alla documentazione ufficiale del linguaggio Java (link). Si riporta qui sotto per comodità il codice di un semplice esempio di utilizzo per entrambe le soluzioni citate prima:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
public class Test { public static void main(String[] args) { String s = "3; A; 4; A; 5; A"; //Prima soluzione: metodi split() e trim() della classe String String[] vs = s.split(";"); for(int i=0; i<vs.length; i+=2){ System.out.print(vs[i].trim()); System.out.println(vs[i+1].trim()); } System.out.println(""); //Seconda soluzione: oggetto di classe StringTokenizer StringTokenizer st = new StringTokenizer(s, ";"); while(st.hasMoreTokens()) { System.out.print(st.nextToken().trim()); System.out.println(st.nextToken().trim()); } } } */ |
3A
4A
5A
3A
4A
5A
