stringhe

Il problema

Capita spesso che si debba analizzare il contenuto di alcuni testi (frasi o parole). A volte può servire di prendere in considerazione un carattere alla volta, altre volte si vorrebbe sostituire un carattere con un altro; in certe occasioni si dovrebbe poter verificare se è presente un certo carattere (oppure una sequenza di caratteri) oppure, in fine, estrarre una sottostringa. Non c'è bisogno di dire che di frequente bisogna confrontare 2 stringhe per sapere se sono uguali oppure no.

La soluzione

Per aiutarci a risolvere tutti questi piccoli problemi Java ci mette a disposizione una ricca quantità di metodi, qui ne riportiamo un piccolo elenco:

length()

Restituisce il numero di caratteri che fanno parte della stringa. Si dice che restituisce la lunghezza della stringa.

equals(stringaDaConfrontare)

Restituisce true se le 2 stringhe sono uguali, altrimenti restituisce false
Non si può (purtroppo) usare l'operatore == per confrontare le stringhe perché tale operatore andrebbe a vedere se la posizione delle 2 stringhe in memoria coincide quindi se sono esattamente la stessa stringa, non la stessa sequenza di caratteri.

compareTo(stringaDaConfrontare)

Per capire questo metodo bisogna far riferimento all'ordinamento alfabetico, quello che troviamo nei vocabolari. Diciamo che la parola "casa" segue la parola "cara" perché la prima lettera è una "c" per entrambe quindi analizza la seconda lettera: la "a" che è anch'essa uguale per entrambe. Passa quindi alla terza lettera che in "casa" è una "s" e in "cara" è una "r". Dato che nell'alfabeto la "r" viene prima di "s", diciamo che la parola "cara" precede la parola "casa" o, equivalentemente, la parola "casa" segue la parola "cara".
Questo metodo restituisce un numero negativo (<0) se la stringa che le viene passata come argomento segue quella su cui si è invocato compareTo() mentre restituisce un numero positivo (>0) se la stringa passata come argomento precede la stringa dell'invocazione. Nel caso in cui le 2 stringhe fossero uguali restituisce 0.
Attenzione: le maiuscole e le minuscole fanno differenza: tutte le maiuscole precedono sempre le minuscole. In realtà per confrontare le 2 stringhe il metodo utilizza la tabella UTF-8.

compareToIgnoreCase(stringaDaConfrontare)

Valgono le stesse considerazioni di compareTo() con la differenza che qui non vengono tenuto in considerazione il fatto che il carattere sia maiuscolo o minuscolo

charAt(posizioneDaLeggere)

Restituisce il carattere (quindi di tipo char) che si trova nella posizione indicata. Le posizioni, come nei vettori, partono da 0 e quindi 0 è la prima posizione, segue la posizione 1 e così via. Chiaramente partendo 0 significa che l'ultima posizione valida è la lunghezza della stringa -1.

substring(posizioneDaCuiEstrarre)

Fornisce una nuova stringa che contiene esattamente i caratteri della stringa su cui è stato invocato il metodo a partire dalla posizione indicata fino alla fine. Esempio: data String s = "sosta"; il metodo s.substring(2) restituisce la stringa "sta".
Attenzione: la stringa sulla quale viene applicato il metodo non viene in alcun modo modificata.

substring(posizioneDaCuiEstrarre, posizioneACuiFermarsi)

Valgono le stesse considerazioni fatte per substring(posizioneDaCuiEstrarre) con in più il fatto che non arriva fino alla fine ma si ferma alla posizione indicata. Il carattere alla posizione a cui fermarsi non farà parte della stringa risultato.

indexOf(carattere)

Restituisce la posizione del carattere indicato all'interno della stringa a partire da 0. Se tale carattere è presente più volte, viene restiruita la posizione del primo carattere. Se il carattere cercato non è presente, restituisce -1.

indexOf(sottostringa)

Simile al metodo precedente. Se sottostringa è presente nella stringa da cui è invocato il metodo, restituisce la posizione del primo carattere di sottostringa a partire da 0. Se sottostringa fosse presente più volte, restituisce la posizione del primo carattere della prima volta in cui compare. Se invece non è presente, restituisce -1.

indexOf(carattere, posizioneDiPartenza)

Simile al metodo indexOf(carattere), l'unica differenza è che non parte da 0 ma dalla posizione indicata.

indexOf(sottostringa, posizioneDiPartenza)

Simile al metodo indexOf(sottostringa), l'unica differenza è che non parte da 0 ma dalla posizione indicata.

replace(sottostringaAttuale, nuovaSottostringa)

Restituisce una nuova stringa in cui ogni volta che viene incontrata unaa sequenza di caratteri come quella indicata in sottostringaAttuale questa viene rimossa e al suo posto viene inserita una sequenza di caratteri come quella indicata in nuovaSottostringa.

split(stringaSeparatrice)

Dà come risultato un vettore di stringhe ottenuto analizzando la stringa sulla quale si è invocato il metodo: partendo dalla posizione 0, ogni volta che si incontra la stringaSeparatrice tutti i caratteri a partire dall'ultimo separatore incontrato (escluso) o dall'inizio se questo non è stato mai incontrato, formeranno una stringa in una cella del vettore. La successiva seuqenza andrà nella cella successiva e così via fino alla fine.
Esempio: data String elenco = "Aldo,Giovanni,Giacomo"; il codice String nomi[] = elenco.split(","); fa sì che si crei un vettore di 3 stringhe così fatto:
in nomi[0] c'è "Aldo"
in nomi[1] c'è "Giovanni"
in nomi[2] c'è "Giacomo"
Se si mette la stringa vuota (""), ogni carattere della stringa a cui è stato applicato il metodo diverrà una stringa a sé stante in una cella del vettore.

toCharArray()

Costruisce e restituisce un vettore di caratteri (char) costituito dai singoli componenti della stringa.

toLowerCase()

Restituisce una stringa in cui tutti i caratteri sono minuscoli.

toUpperCase()

Restituisce una stringa in cui tutti i caratteri sono maiuscoli.

trim()

Restituisce una stringa in cui sono stati eliminati tutti gli spazi iniziali e finali ma non quelli intermedi.

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.layout.GridPane;
import javafx.stage.Stage;

public class Caratteri extends Application{
  TextField c_uno = new TextField();
  TextField c_due = new TextField();
  Label risposta = new Label();
	
  @Override
  public void start(Stage s){
    Label e_uno = new Label("primo parametro:");
    Label e_due = new Label("secondo parametro:");
    Label e_risposta = new Label("risposta:");
    Button carattere = new Button("n_esimo carattere");
    Button prima = new Button("confronta prima");
		
    GridPane gp = new GridPane();
    gp.add(e_uno,0,0);
    gp.add(c_uno,1,0);
    gp.add(e_due,0,1);
    gp.add(c_due,1,1);
    gp.add(carattere,1,2);
    gp.add(prima,1,3);
    gp.add(e_risposta,0,4);
    gp.add(risposta,1,4);
		
    Scene scena = new Scene(gp);
    s.setScene(scena);
    s.setTitle("Caratteri");
    s.show();
		
    carattere.setOnAction(evento->prendiEnnesimoCarattere());
    prima.setOnAction(evento->confrontaPrimaLettera());
  }
	
  /* qui uso il metodo toCharArray per recuperare un intero array di caratteri */
  private void prendiEnnesimoCarattere(){
    String f = c_uno.getText();
    int n = Integer.parseInt(c_due.getText());
    char v[];
    v = f.toCharArray();
    risposta.setText(""+v[n]);
  }
	
  /* qui uso anche charAt per recuperare un singolo carattere */
  private void confrontaPrimaLettera(){
    String f = c_uno.getText();
    String s = c_due.getText();
    char v[];
    v = f.toCharArray();
    char primoSotto;
    primoSotto = s.charAt(0);
		
    if(v[0]==primoSotto){
      risposta.setText("sono uguali");
    }else{
      risposta.setText("non sono uguali");
    }
  }
	
  public static void main(String x[]){
    launch(x);
  }
}

Un'altra cosa utile potrebbe essere quella di costruire una stringa a partire da un vettore di caratteri, questo è facile: String testo = new String(vettoreDiCaratteri).