mp 07 03

Classe String

Cos’è

• E’ un package che non richiede import
• E’ una classe fondamentale perché è relativo al un tipo di dato i cui letterali sono parte della sintassi del linguaggio e per il quale il significato dell’operatore ”+” è ridefinito
• Non serve chiamare il costruttore per inizializzare una stringa

Ottenere la lunghezza della stringa

• La classe String è dotata del metodo lenght()

String s="ciao";
System.out.println(s.lenght());

• Stamperà il valore 4, che è pari al numero di caratteri di cui è composta la sringa

Stringa tutta in maiuscolo o in minuscolo

• Con i metodi toLowerCase() e toUpperCase() si ottiene un’altra stringa tutta in maiuscolo o minuscolo
• La stringa su chi viene invocato il metodo non viene modificata

String min="Ciao".toLowerCase(); //"ciao"
String max="Ciao".toUpperCase(); //"CIAO"
String ariMin= max.toLowerCase(); //"ciao", max è la variabile usata in precedenza

Ottenere i singoli caratteri

E’ possibile ottenere il k-esimo carattere di una stringa con il metodo charAt

Importante

• Il primo carattere è in posizione 0
• l’ultimo carattere è in posizione stringa.lenght()-1

String.out.println(s.charAt(2)); //stmpa il carattere "a"

Ottenere una sottotringa

E’ possibile ottenere una sottostringa di una stringa con il metodo substing(startIndex, endIndex)

Info

• startIndex è l’indice di partenza della sottostringa
• endIndex è l’indice successivo all’ultimo carattere della sottostringa

String s = “ciao”;
System.out.println(s.substring(1, 3)); //stmpa "ia"

Concatenare le stringhe

• La concatenazione tra due stringhe può essere effettuata con l’operatore “speciale” + oppure mediante il metodo concat(s)

String s3 = s1+s2;
String s4 = s1.concat(s2);

• Tuttavia, se si devono concatenare parecchie stringhe, è bene utilizzare la classe StringBuilder, dotata dei metodi append(String s) e insert(int posizione, String s)

StringBuilder sb = new StringBuilder();
sb.append(s1).append(s2);
String s5 = sb.toString();

Cercare una stringa

• Si può cercare la (prima) posizione di un carattere c con indexOf(c)
  • restituisce -1 se il carattere non è presente
• E’ possibile anche cercare la prima posizione di una sottostringa con indexOf(s) sove s è di tipo String

int k = “happy happy birthday”.indexOf(‘a’);
int j = “din din don don”.indexOf(“don”);
int h = “abcd”.indexOf(‘e’);

• k varrà 1, j varrà 8 e h varrà -1
• Con i metodi startsWith e endsWith è possibile verificare prefissi o suffissi della stringa

Sostituire caratteri e sottostringhe

• Con il metodo replace è possibile sostituire tutte le occorrenze di un carattere o di una stringa all’interno di una stringa

// s1 vale “uno due tre”
String s1 = “uno_due_tre”.replace(‘_’, ‘ ’);
// s2 vale “uno two tre”
String s2 = “uno due tre”.replace(“due”, “two”);
// s3 vale “aano daae tre”
String s3 = “uno due tre”.replace(“u”, “aa”);

Confrontare stringhe

Tutti gli oggetti vanno SEMPRE confrontati con il metodo equals()

Differenza tra equals e ==

• L’operatore == confronta il riferimento (diciamo, l’indirizzo in memoria), quindi è true se e solo se si confrontano gli stessi oggetti fisici

• L’operatore equals confronta la stringa carattere per carattere e restituisce true se le stringhe contengono la stessa sequenza di caratteri

String s1 = “ciao”, s2 = “ci”+”ao”, s3 = “hello”;
System.out.println(s1 == s2); // potrebbe restituire false
System.out.println(s1.equals(s2)); // restituisce true
System.out.println(s1.equals(s3)); // restituisce false

Spezzare le stringhe

• Il metodo split() prende in input un’espressone regolare s (senza entrare in dettagli, è sufficiente pensarla come una semplice stringa) e restituisce un array di sottostringhe separate da s

String[] parole = "uno due tre".split(" ");
	// parole contiende l'array new String[] { "uno", "due", "tre"}

Valori primitivi e oggetti

• E’ importante tenere a mente la differenza tra

  • Valori di tipo primitivo (int, char, booleani, float, double)
  • Oggetti (istanze delle classi)

• La loro rappresentazione in memoria è differente:

  • Valori primitivi: memoria allocata automaticamente a tempo di compilazione
  • Oggetti: memoria allocata durante l’esecuzione del programma (operatore new)

Inizializzazione implicite per i campi della classe

• Al momento della creazione dell’oggetto i campi di una classe sono inizializzati automaticamente

Attenzione

Le inizializzazioni sono automatiche per i campi di una classe, ma NON per le variabili locali dei metodi

Notazioni letterali

• Si può dichiarare un intero in decimale

int val = 42;

• Un intero in esadecimale

int val = 0x2A

• Un intero in bianario

int val = 0b101010;

• Il valore di quei 4 byte sarà sempre lo stesso: 42

Esempio

public class Room
{
	private int numberOfPeople;
 
	private Counter acessCounter;
 
 
	public static void main (String[] args)
	{
		int n;
		Counter myCounter;
 
		System.out.println (n+ ", "+ myCounter);
		Room room = new Room(); //Crea un nuovo oggetto in memoria contenente i campi numberOfPeople e accessCounter inizializzati
 
		System.out.println (room.numerOfPeople); //stampa 0
		System.out.println (room.acessCounter); //stmpa Null
	}
}

Riferimenti e oggetti

• i riferimenti sono ciò che ne è rimasto in Java
• Un riferimento è un indirizzo di memoria
  • Tuttavia non conosciamo il valore numerico dell’indirizzo
• Quindi gli oggetti non sono mai memorizzati direttamente nelle variabili, ma solo mediante il loro riferimento

Variabili di tipi primitivi e variabili “riferimento”

• Le variabili contengono:
  • valori di tipi di dati primitivi
  • oppure riferimenti a oggetti

Oggetti: i tre passi della dichiarazione, creazione e assegnazione

Dichiarazione

• Menu menu = new Menu() (Menu menu)

Creazione

• Menu menu = new Menu() (new Menu())

Assegnazione:

• Menu menu = new Menu() (=)

Anatomia della memoria

Esistono due tipo di memoria: lo heap e lo stack

• Sullo stack vanno variabili locali
• Sullo heap vanno le aree di memoria allocate per la creazione dinamica

Campi di classe: la parola chiave static

• I campi di una classe possono essere dichiarati static
• Un campo static è relativo all’intera classe, non al singolo oggetto istanziato
• Un campo static esiste in una sola istanza di memoria, allocata prima di qualsiasi oggetto della classe in una zona speciale di memoria nativa chiamata MetaSpace
• Viceversa, per ogni campo non static esiste una locazione di memoria per ogni oggetto, allocata a seguito dell’instrzuione new

public class Tornello
{
	static private int passaggi;
	
	public void passa() {passaggi++;}
	public static int getPassaggi() { return passaggi;}
 
	public static void main (String[] args)
	{
		Tornello t1 = new Tornello();
		t1.passa();
		Tornello t2 = new Tornello();
		for (int k=0; k<10; k++) t2.passa();
		int g;
		String s=null;
		//fotografa lo stato della memoria
		}
}