/* *************************************************************************
 * In java le stringhe sono degli oggetti, a differenza del C.
 * I caratteri in Java sono in formato UNICODE a 16 bit, non ASCII a 8bit.
 * Per dichiarare una stringa si fa in questo modo:
 *
 *    String stringhetta = "Bau Bau";
 *
 * Le stringhe non possono essere cambiate dopo la loro creazione.
 * La classe String ha molti metodi, vediamone alcuni:
 *
 *    charAt(int)       ; Restituisce il carattere all'indice specificato.
 *                      ; 0 = primo carattere, lenght()-1 = ultimo.
 *    equals(String)    ; Confronta questa stringa con un'altra. E' case
 *                      ; sensitive, ossia Pippo e PiPpO sono diversi.
 *    length()          ; Restituisce la lunghezza della stringa.
 *    toLowerCase()     ; Converte la stringa in soli caratteri minuscoli.
 *    toUpperCase()     ;     ""           ""           ""      maiuscoli
 *
 * Inoltre ci sono classi riguardanti le stringhe. Una interessante e'
 * java.util.StringTokenizer, che ha dei metodi per separare i token
 * (alla lettera segni,simboli) un testo: le singole parole di una frase,
 * ad esempio. Senza parametri addizionali, i caratteri riconosciuti come
 * separatori sono gli spazi, i tab, e gli "a capo" (return e newline).
 * Avendo la stringa "Ho 21 anni e sono alto 1.84", si ottengono i token
 * "Ho","21","anni","e","sono","alto","1.84".
 * Per poter usare StringTokenizer, occorre istanziarlo:
 *
 *   import java.util.StringTokenizer;
 *
 *   String prova1 = "Ho 21 anni e sono alto 1.84";
 *   StringTokenizer miostoke = new StringTokenizer(prova1);
 *
 * Il costruttore vuole in entrata la stringa su cui operare.
 * Si puo' anche aggiungere un'altra stringa ai parametri del costruttore,
 * con i caratteri da considerare delimitatori di token, se si vuole.
 * A questo punto, ecco i metodi che ci interessano:
 *
 *   nextToken()        ; Restituisce il prossimo token della stringa.
 *                      ; Se viene chiamato quando non ci sono piu' token,
 *                      ; genera l'eccezione NoSuchElementException.
 *   countTokens()      ; Restituisce il numero di token ancora disponibili
 *                      ; prima che nextToken generi un'eccezione per fine
 *                      ; tokens.
 *   hasMoreTokens()    ; Restituisce true (vero) se ci sono ancora token
 *
 * Vediamo un esempio.
 ************************************************************************* */

import java.io.*;                // Include le funzioni I/O standard di base.
import java.util.StringTokenizer; // Per usare i metodi sui Token.


class Jlez3e {            // Da qua inizia la classe Jlez3e

 public static void main(String args[])  // Definiamo il metodo Main.
 {                                       // Inizio del main()

   System.out.println("Scrivi una stringa di testo:");

   String stringhina1 = leggiStr();       // Leggo una stinga da tastiera.

   System.out.println("Scrivine un'altra:");

   String stringhina2 = leggiStr();       // Leggo una stinga da tastiera.

// Stampiamo le stringhe normalmente

   System.out.println("\nLa prima stringa e' " + stringhina1);
   System.out.println("La seconda stringa e' " + stringhina2);

// Diamo altre informazioni usando length() e charAt(int).

   System.out.print("La stringa 1 inizia con " + stringhina1.charAt(0));
   System.out.println(", ed e' lunga " + stringhina1.length() + " caratteri");
   System.out.print("La stringa 2 inizia con " + stringhina2.charAt(0));
   System.out.println(", ed e' lunga " + stringhina2.length() + " caratteri");

// Controlliamo se le due stringhe sono uguali con equals(String).

   if (stringhina1.equals(stringhina2))
      System.out.println("Le stringhe sono uguali");
   else System.out.println("Le stringhe sono diverse");

// Stampiamo le stringhe con i caratteri convertiti tutti in maiuscolo, con
// toUpperCase(), e tutti in minuscolo, con toLowerCase()

   System.out.println("Stringa 1 uppercase: " + stringhina1.toUpperCase());
   System.out.println("Stringa 2 lowercase: " + stringhina2.toLowerCase());

// Scopriamo il numero di token della stringa 1 usando countTokens()

   StringTokenizer miostoke = new StringTokenizer(stringhina2);
   System.out.println("La stringa 1 ha " + miostoke.countTokens() + " token:");

// Dividiamo in token la stringa 1 usando hasMoreTokens() e nextToken().
// Finche' (while) la stringa ha ancora token, stampa il prossimo.

   while (miostoke.hasMoreTokens()) {
     System.out.println(miostoke.nextToken());
   }

 }               // Fine del metodo principale Main()


/* -------------------------------------------------------------------------
 * Definiamo un metodo chiamato leggiStr(), che in entrata non ha
 * parametri, e in uscita restituisce una stringa immessa da tastiera.
 *    String leggiInt()
 * ----------------------------------------------------------------------- */

 public static String leggiStr()
 {
    try {
      DataInputStream leggilo = new DataInputStream(System.in);
      String stringa = leggilo.readLine();     // dichiaro e leggo stringa.
      return stringa;
    }
    catch (Exception e) {
      System.out.println("Errore: " + e + " nella lettura da tastiera");
      System.exit(0);
      return("errore");  // Questo return serve solo perche' il metodo
                         // abbia un int di ritorno anche in caso di errore
    }
 }               // Fine di "String leggiStr()"


}            // Fine della classe Jlez3e