edutecnica

Stringhe  

     

Una stringa formata da una lista lineare di caratteri racchiusa fra due coppie di doppi apici; in Java gestita dalla classe String. Data l'importanza di questo tipo di dato, si possono dichiarare nuovi oggetti stringa senza usare l'operatore new.

La dichiarazione pu avvenire una sintassi simile alle dichiarazione dei tipi di dati primitivi:

String str="ciao a tutti" ;
System.out.println(str);


o con una sintassi pi formale simile alla dichiarazione dei vettori:

String str=new String("ciao a tutti");

E' gi noto l'operatore '+' usato per concatenare pi stringhe; di seguito riportato un elenco di metodi per la classe String.

selezione char charAt(int i) Ritorna il carattere con indice i.
String substring(int start, int stop) Ritorna una sottostringa.
confronto int length() Restituisce la lunghezza della stringa.
int compareTo(String s) Compara due stringhe.
boolean isEmpty() verifica una stringa vuota
boolean equals(Object o) Confronta la stringa attuale con l'oggetto specificato.
concatenazione String concat(String s) Concatena la stringa argomento alla stringa attuale.
ricerca int indexOf(char ch) Ritorna l'indice della prima occorrenza del carattere indicato.
int indexOf(int ch, int i) Ritorna l'indice interno alla stringa della prima occorrenza del carattere
specificato, facendo partire la ricerca dall'indice i.
int indexOf(String s) Ritorna l'indice interno alla stringa corrente alla prima occorrenza della (eventuale) sottostringa s.
int indexOf(String s, int i) Ritorna l'indice interno alla stringa corrente alla prima occorrenza della (eventuale) sottostringa s, a partire dall'indice i specificato.
conversione char[] toCharArray() Converte la stringa in un vettore di caratteri.
String toLowerCase() Converte tutti i caratteri della stringa in minuscolo.
String toUpperCase() Converte tutti i caratteri della stringa in maiuscolo.
String trim() elimina gli spazi iniziali e finali.
sostituzione String replace(char oldCh, char newCh) Ritorna una nuova stringa dove tutte le occorrenze di vCh sono sostituite con nCh.
String replaceAll(String regExp, String s) Sostituisce ogni sottostringa di questa stringa corrispondente all'espressione regolare data.
String replaceFirst(String regExp, String s) Sostituisce la prima sottostringa di questa stringa che corrisponde all'espressione regolare data.

Conversione da stringa a numero
Byte.parseByte(s.trim())
Short.parseShort(s.trim())
Integer.parseInt(s.trim())
Long.parseLong(s.trim())
Short.parseShort(s.trim())
Float.parseFloat(s.trim())
Double.parseDouble(s.trim())

Conversione da numero a stringa
modo 1 modo 2
Byte.toString(b) String.valueOf(b)
Short.toString(s) String.valueOf(s)
Integer.toString(i) String.valueOf(i)
Long.toString(l) String.valueOf(l)
Float.toString(f) String.valueOf(f)
Double.toString(d) String.valueOf(d)

char charAt(int i)
Questo metodo ritorna il carattere alla posizione specificata dall'indice.

public class prova {
public static void main(String args[]) {
     String s = "innumerevoli stringhe";
     char ch = s.charAt(8); System.out.println(ch);
     }
}

String substring(int start) o String substring(int start, int stop)
Ritorna una sottostringa che parte dall'indice start incluso all'indice stop escluso
class prova {
public static void main (String args []) {
String Str = new String("alpha beta gamma");
System.out.print("valore di ritorno:" );
System.out.println(Str.substring(6) );
System.out.print("valore di ritorno:" );
System.out.println(Str.substring(6, 10));
}//fine main
}// fine classe


int length()
Restituisce la lunghezza di una stringa
class prova {
public static void main (String args []) {
String Str1 = new String("alpha beta gamma delta");
String Str2 = new String("alpha omega" );
System.out.print("lunghezza stringa :" );
System.out.println(Str1.length());
System.out.print("lunghezza stringa :" );
System.out.println(Str2.length());
}//fine main
}// fine classe


int compareTo(Object o) o int compareTo(String s)
Compara la corrente stringa oggetto (this) con quella argomento s.
Restituisce 0 se sono uguali.
Restituisce un int < 0 se this < s.
Restituisce un int > 0 se this > s.

class prova {
public static void main (String args []) {
String str1 = "alpha omega";
String str2 = "alpha omega";
String str3 = "alpha beta gamma delta";
int risultato = str1.compareTo( str2 );
System.out.println(risultato);
risultato = str2.compareTo( str3 );
System.out.println(risultato);
risultato = str3.compareTo( str1 );
System.out.println(risultato);
}//fine main
}// fine classe



boolean equals(Object o)
Il metodo compara la stringa attuale con l'oggetto specificato. Ritorna true se e solo se l'argomento non nullo ed una stringa che rappresenta la stessa sequenza di quella corrente.

class prova {
public static void main (String args []) {
String Str1 = new String("alpha beta");
String Str2 = Str1;
String Str3 = new String("alpha beta omega");
boolean risultato; risultato = Str1.equals( Str2 );
System.out.println("valore di ritorno = " + risultato );
risultato = Str1.equals( Str3 );
System.out.println("valore di ritorno = " + risultato);
}//fine main
}// fine classe


int indexOf(char ch)
Ritorna l'indice della prima occorrenza del carattere indicato, oppure, ritorna -1 se il carattere non viene trovato.
int indexOf(int ch, int i)
Ritorna l'indice interno alla stringa della prima occorrenza del carattere specificato, facendo partire la ricerca dall'indice i o da -1 se il carattere non viene individuato.
int indexOf(String s)
Ritorna l'indice interno alla stringa corrente alla prima occorrenza della (eventuale) sottostringa s. Se non viene individuta s, il metodo restituisce -1.
int indexOf(String s)
Ritorna l'indice interno alla stringa corrente alla prima occorrenza della (eventuale) sottostringa s, a partire dall'indice i specificato. Se non vi occorrenza di s, viene restitituito -1.
class prova {
public static void main (String args []) {
String s = new String("Benvenuto ad edutecnica");
String s1 = new String("edu");
String s2 = new String("tecnica");
System.out.print("index :" );
System.out.println(s.indexOf( 'e' ));
System.out.print("index :" );
System.out.println(s.indexOf( 'e', 10 ));
System.out.print("index :" );
System.out.println( s.indexOf( s1 ));
System.out.print("index :" );
System.out.println( s.indexOf( s1, 15 ));
System.out.print("index :" );
System.out.println(s.indexOf( s2 ));
}//fine main
}// fine classe


char[] toCharArray()
Converte la stringa in un vettore di caratteri
class prova {
public static void main (String args []) {
String s = new String("Benvenuto ad edutecnica");
System.out.print("risultato :" );
System.out.println(s.toCharArray() );
}//fine main
}// fine classe


String toLowerCase()
Converte tutti i caratteri della stringa in minuscolo
class prova {
public static void main (String args []) {
String s = new String("Benvenuto Ad Edutecnica");
System.out.print("risultato :");
System.out.println(s.toLowerCase());
}//fine main
}// fine classe


String toUpperCase()

Converte tutti i caratteri della stringa in maiuscolo.
class prova {
public static void main (String args []) {
String s = new String("Benvenuto Ad Edutecnica");
System.out.print("risultato :");
System.out.println(s.toUpperCase());
}//fine main
}// fine classe


String replace(char oldCh, char newCh)
Ritorna una nuova stringa dove tutte le occorrenze di oldCh sono sostituite con newCh.
class prova {
public static void main (String args []) {
String s = new String("Benvenuto ad edutecnica");
System.out.print("risultato :" );
System.out.println(s.replace('e', 'X'));
System.out.print("risultato :" );
System.out.println(s.replace('t', 'T'));
}//fine main
}// fine classe


String replaceAll(String regExp, String s)
Sostituisce ogni sottostringa della stringa attuale corrispondente all'espressione regolare data.

Le epressioni regolari (regEx) sono una sintassi per descrivere la morfologia di una stringa .
Se il testo contenuto testo semplice verr ricercata esattamente quella sequenza di caratteri (con distinzione fra maiuscole e minuscole). Esistono caratteri particolari che se inseriti all'interno della regEx hanno un significato particolare:

[ ] "parentesi quadre" tutti gli eventuali caratteri all'interno delle [ ].

String s = new String("benvenuto ad Edutecnica");
System.out.println(s.replaceAll("[ea]","_" ));
//restituisce: bXnvXnuto Xd EdutXcnicX


si possono definire intervalli:
[a-z] tutti i caratteri minuscoli
[0-9] tutte le cifre
[a-zA-Z] tutti i caratteri minuscoli o maiuscoli

String s = new String("benvenuto ad Edutecnica");
System.out.println(s.replaceAll("[A-Z]","X" ));
//restituisce: benvenuto ad Xdutecnica


^ "accento circonflesso" : nelle parentesi quadre definisce delle esclusioni:
[^o] qualsiasi carattere diverso da 'o'
[^a-z] qualsiasi carattere diverso da una minuscola
[^ea] qualsiasi carattere diverso da 'a' e da 'e'

String s = new String("benvenuto ad Edutecnica");
System.out.println(s.replaceAll("[^aeiouAEIOU]","X" ));
//restituisce: XeXXeXuXoXaXXEXuXeXXiXa


| operatore OR di alternativa

String s = new String("benvenuto ad Edutecnica");
System.out.println(s.replaceAll("ben|E","X" ));
//restituisce: Xvenuto ad Xdutecnica


Cio intercetta la lettera 'E' o la stringa 'ben'. Qui non possono essere usate le [] altrimenti verrebbero intercettate le lettere 'b','e','n' ed 'E'.

? "punto di domanda" il carattere precedente a ? opzionale (ricorre 0 o 1 volta)

String s = new String("nafta nata Nafta");
System.out.println(s.replaceAll("naf?ta","X" ));
\\restituisce:X X Nafta


* "asterisco" accetta 0 o n ripetizioni del carattere precedente a *
Ad es. il carattere '1' seguito da 0 o n '2'

String s = new String("cifre 1 1222 3122245 cifre");
System.out.println(s.replaceAll("12*","X" ));
//restituisce: cifre X X 3X45 cifre


+ "pi" pi accetta 1 o n ripetizioni del carattere precedente al +
Ad es. il carattere '1' seguito da 1 o n '2'.

String s = new String("cifre 1 1222 3122245 cifre");
System.out.println(s.replaceAll("12+","X" ));
//restituisce: cifre 1 X 3X45 cifre


Ovviamente nel caso di replaceAll, l'operazione pi remunerativa, la ricerca e la sostituzione di una stringa in una frase.

class prova{
public static void main (String[] args) {
String s = new String("tanto va la gatta al lardo che il lardo zampina");
System.out.println(s.replaceAll("lardo", "gatto" ));
}//fine main
}//fine class


pi in generale, con input output da tastiera:

import java.io.*;
class prova{
public static void main (String args []) throws IOException {
InputStreamReader input=new InputStreamReader(System.in);
BufferedReader h= new BufferedReader(input);
String st,s1,s2;
System.out.print("frase:");
st=h.readLine();
System.out.print("sottostringa da cercare:");
s1=h.readLine();
System.out.print("sottostringa sostitutiva:");
s2=h.readLine();
st=st.replaceAll(s1,s2);
System.out.println(st);
}//fine main
}// fine classe

String replaceFirst(String regExp, String s)
Sostituisce la prima sottostringa della stringa attuale che corrisponde all'espressione regolare data.

class prova {
public static void main (String args []) {
String s = new String("Benvenuto ad edutecnica");
System.out.print("risultato:" );
System.out.println(s.replaceFirst("(.*)edu","Fisio" ));
System.out.print("risultato:" );
System.out.println(s.replaceFirst("tecnica", "Fisio" ));
}//fine main
}// fine classe


StringBuffer

     

E', inoltre, a disposizione il tipo StringBuffer che attraverso i suoi metodi consente di considerare la stringa alla stessa maniera di un vettore di caratteri. La sintassi della sua dichiarazione :

StringBuffer s = new StringBuffer("star");

Per tale oggetto a disposizione un'utile famiglia di metodi:

append(tipo d) aggiunge in coda una rappresentazione a stringa del dato d.
insert(int i, tipo d) inserisce all'indice i una rappresentazione a stringa del dato d.
delete(int i,int f) cancella i dati a partire da i fino a f.
deleteCharAt(int i) cancella il carattere in posizione i
replace(int i,int f, String s) cancella i dati a partire da i fino a f e poi inserisce s da i.
reverse() inverte la stringa.
setCharAt(int i, char ch) sovrascrive il carattere in posizione i con c
setLength(int lg) imposta la dimensione della stringa a lg

La differenza concettuale fra String e StringBuffer che la prima una classe per oggetti immutabili (una volta creati, non possono pi essere modificati) mentre un oggetto di tipo StringBuffer una stringa variabile nel contenuto e nella dimensione.

import java.io.*;
class provaBuffer {
public static void main (String args []) throws IOException {
InputStreamReader input=new InputStreamReader(System.in);
BufferedReader h= new BufferedReader(input);
String st;
StringBuffer sb=new StringBuffer();
System.out.print("vai:");
st=h.readLine();
sb.append("info= ");
sb.append(st);
sb.append(" inserito da tastiera");
st=sb.toString();
System.out.println(st);
}//fine main
}// fine classe


Viene qui usato il metodo toString() appartenente alla classe Object (da cui sono derivati tutti gli altri oggetti comprese le stringhe) per descrivere un oggetto come stringa.