Stringa Java

Tutorial
Java

La classe Java String è una delle classi più utilizzate. La classe Java String è definita nel pacchetto java.lang.

Java String

  • In sostanza, una stringa è una sequenza di caratteri ma non è un tipo primitivo.
  • Quando creiamo una stringa in Java, in realtà viene creato un oggetto di tipo String.
  • La stringa è un oggetto immutabile, il che significa che non può essere modificato una volta creato.
  • La stringa è l’unica classe in cui è supportato il sovraccarico degli operatori. Possiamo concatenare due stringhe usando l’operatore +. Ad esempio, "a"+"b"="ab".
  • Java fornisce due classi utili per la manipolazione delle stringhe: StringBuffer e StringBuilder.

Andiamo avanti e impariamo di più sulla classe Java String.

Diversi modi per creare una stringa

Ci sono molti modi per creare un oggetto stringa in Java, alcuni dei più popolari sono riportati di seguito.

  1. Utilizzando la stringa letterale

    Questo è il modo più comune per creare una stringa. In questo caso, una stringa letterale è racchiusa tra virgolette doppie.

    String str = "abc";

    Quando creiamo una stringa usando le virgolette doppie, la JVM cerca nel pool di stringhe per vedere se c’è già memorizzata un’altra stringa con lo stesso valore. Se trovata, restituisce semplicemente il riferimento a quell’oggetto String altrimenti ne crea uno nuovo con il valore dato e lo memorizza nel pool di stringhe.

  2. Usando la parola chiave new

    Possiamo creare un oggetto String utilizzando l’operatore new, proprio come qualsiasi normale classe Java. Ci sono diversi costruttori disponibili nella classe String per ottenere una Stringa da un array di caratteri, un array di byte, StringBuffer e StringBuilder.

    String str  =  new String("abc");
char[] a = {'a', 'b', 'c'};
String str2  =  new String(a);

Confronto delle stringhe in Java

La classe String fornisce i metodi equals() e equalsIgnoreCase() per confrontare due stringhe. Questi metodi confrontano il valore della stringa per verificare se due stringhe sono uguali o meno. Restituiscono true se due stringhe sono uguali e false se non lo sono.

package com.journaldev.string.examples;

/**
 * Java String Example
 * 
 * @author pankaj
 *
 */
public class StringEqualExample {

	public static void main(String[] args) {
		//creazione di due oggetti stringa
		String s1 = "abc";
		String s2 = "abc";
		String s3 = "def";
		String s4 = "ABC";
		
		System.out.println(s1.equals(s2));//true
		System.out.println(s2.equals(s3));//false
		
		System.out.println(s1.equals(s4));//false;
		System.out.println(s1.equalsIgnoreCase(s4));//true
	}

}

L’output del programma sopra è:

true
false
false
true

La classe String implementa l’interfaccia Comparable, che fornisce i metodi compareTo() e compareToIgnoreCase() e confronta due stringhe in ordine lessicografico. Entrambe le stringhe vengono convertite in valori Unicode per il confronto e restituiscono un valore intero che può essere maggiore di zero, minore di zero o uguale a zero. Se le stringhe sono uguali, restituisce zero, altrimenti restituisce un valore maggiore o minore di zero.

package com.journaldev.examples;

/**
 * Java String compareTo Example
 * 
 * @author pankaj
 *
 */
public class StringCompareToExample {

	public static void main(String[] args) {
		
		String a1 = "abc";
		String a2 = "abc";
		String a3 = "def";
		String a4 = "ABC";
		
		System.out.println(a1.compareTo(a2));//0
		System.out.println(a2.compareTo(a3));//less than 0
		System.out.println(a1.compareTo(a4));//greater than 0
		System.out.println(a1.compareToIgnoreCase(a4));//0
	}

}

L’output del programma precedente è:

0
-3
32
0

Per maggiori dettagli, si prega di consultare l’esempio di confronto di stringhe all’indirizzo String compareTo example.

Metodi della classe String di Java

Diamo uno sguardo a alcuni dei metodi più popolari della classe String con un programma di esempio.

  1. split()

    Il metodo split() di Java String viene utilizzato per dividere la stringa usando l’espressione data. Ci sono due varianti del metodo split().

    • split(String regex): Questo metodo divide la stringa utilizzando l’espressione regex data e restituisce un array di stringhe.
    • split(String regex, int limit): Questo metodo divide la stringa utilizzando l’espressione regex data e restituisce un array di stringhe, ma l’elemento dell’array è limitato dal limite specificato. Se il limite specificato è 2, il metodo restituisce un array di dimensione 2.
    package com.journaldev.examples;

/**
 * Esempio di split di Java String
 * 
 * @author pankaj
 *
 */
public class StringSplitExample {

	public static void main(String[] args) {
		
		String s = "a/b/c/d";
		String[] a1 = s.split("/");
		System.out.println("stringa divisa usando solo regex:");
		for (String string : a1) {
			System.out.println(string);
		}
		System.out.println("stringa divisa usando regex con limite:");
		String[] a2 = s.split("/", 2);
		for (String string : a2) {
			System.out.println(string);
		}
	}

}

    Output del programma sopra è:

    stringa divisa usando solo regex:
a
b
c
d
stringa divisa usando regex con limite:
a
b/c/d

  2. contains(CharSequence s)

    I metodi contains() di Java String verificano se la stringa contiene una sequenza specificata di caratteri o meno. Questo metodo restituisce true se la stringa contiene la sequenza specificata di caratteri, altrimenti restituisce false.

    package com.journaldev.examples;

/**
 * Esempio di utilizzo di Java String contains()
 * 
 * @author pankaj
 *
 */
public class StringContainsExample {

	public static void main(String[] args) {
		String s = "Hello World";
		
		System.out.println(s.contains("W"));//true
		System.out.println(s.contains("X"));//false
	}

}

    L’output del programma precedente è:

    true
false

  3. length()

    Il metodo length() di Java String restituisce la lunghezza della stringa.

    package com.journaldev.examples;

/**
 * Lunghezza della stringa Java
 * 
 * @author pankaj
 *
 */
public class StringLengthExample {

	public static void main(String[] args) {
		
		String s1 = "abc";
		String s2 = "abcdef";
		String s3 = "abcdefghi";
		
		System.out.println(s1.length());//3
		System.out.println(s2.length());//6
		System.out.println(s3.length());//9

	}

}

  4. replace()

    Il metodo replace() di Java String viene utilizzato per sostituire una parte specifica della stringa con un’altra stringa. Ci sono quattro varianti del metodo replace().

    • replace(char oldChar, char newChar): Questo metodo sostituisce tutte le occorrenze di oldChar con newChar nella stringa.
    • replace(CharSequence target, CharSequence replacement): Questo metodo sostituisce ciascuna sequenza di caratteri target con la sequenza di caratteri replacement nella stringa.
    • replaceAll(String regex, String replacement): Questo metodo sostituisce tutte le occorrenze delle sottostringhe che corrispondono all’espressione regolare specificata con la sostituzione specificata nella stringa.
    • replaceFirst(String regex, String replacement): Questo metodo sostituisce la prima occorrenza della sottostringa che corrisponde all’espressione regolare specificata con la sostituzione specificata nella stringa.
    package com.journaldev.examples;

/**
 * Java String replace
 * 
 * @author pankaj
 *
 */
public class StringReplaceExample {

	public static void main(String[] args) {
		
		//replace(char oldChar,  char newChar)
		String s = "Hello World";
		s = s.replace('l', 'm');
		System.out.println("Dopo aver sostituito l con m :");
		System.out.println(s);
		
		//replaceAll(String regex, String replacement)
		String s1 = "Hello journaldev, Hello pankaj";
		s1 = s1.replaceAll("Hello", "Ciao");
		System.out.println("Dopo la sostituzione :");
		System.out.println(s1);
		
		//replaceFirst(String regex, String replacement) 
		String s2 = "Hello ragazzi, Hello mondo";
		s2 = s2.replaceFirst("Hello", "Ciao");
		System.out.println("Dopo la sostituzione :");
		System.out.println(s2);

	}

}

    L’output del programma precedente è:

    Dopo aver sostituito l con m :
Hemmo Wormd
Dopo la sostituzione :
Ciao journaldev, Ciao pankaj
Dopo la sostituzione :
Ciao ragazzi, Hello mondo

  5. formato()

    Il metodo Java Sting format() viene utilizzato per formattare la stringa. Ci sono due varianti del metodo java String format().

    • formato(Locale l, String formato, Object… args): Questo metodo formatta la stringa utilizzando il locale specificato, il formato della stringa e gli argomenti.
    • formato(String formato, Object… args): Questo metodo formatta la stringa utilizzando il formato della stringa e gli argomenti specificati.
    pacchetto com.journaldev.examples;

import java.util.Locale;

/**
 * Formattazione della stringa Java
 * 
 * @author pankaj
 *
 */
public class EsempioFormatoStringa {

	public static void main(String[] args) {
		
		String s = "journaldev.com";
		// %s viene utilizzato per aggiungere la stringa
		System.out.println(String.format("Questo è %s", s));
		
		//usando il locale come Locale.US
		System.out.println(String.format(Locale.US, "%f", 3.14));
	}
}

    L’output del programma precedente è:

    Questo è journaldev.com
3.140000

  6. substring()

    Questo metodo restituisce una parte della stringa basata sugli indici specificati.

    pacchetto com.journaldev.esempi;

/**
 * Esempio di sottostringa Java String
 *
 */
public class StringSubStringExample {

	public static void main(String[] args) {
		
		String s = "Questo è journaldev.com";
		s = s.substring(8,18);
		System.out.println(s);
	}
}

Concatenazione di stringhe

La concatenazione di stringhe è un’operazione molto basilare in java. Le stringhe possono essere concatenate usando l’operatore “+” o usando il metodo concat().

package com.journaldev.examples;

/**
 * Java String concatenation
 * 
 * @author pankaj
 *
 */
public class StringConcatExample {

	public static void main(String[] args) {
		
		String s1 = "Hello";
		String s2 = "World";
		String s3 = s1 + s2;
		//usando l'operatore +
		System.out.println("Using + operator: ");
		System.out.println(s3);
		
		//usando il metodo concat
		System.out.println("Using concat method: ");
		System.out.println(s1.concat(s2));

	}

}

L’output del programma sopra è:

Using + operator: 
HelloWorld
Using concat method: 
HelloWorld

Controlla questo post per ulteriori informazioni sulla Concatenazione di stringhe in Java.

Java String Pool

Gestione della memoria è l’aspetto più importante di qualsiasi linguaggio di programmazione. La gestione della memoria nel caso delle stringhe in Java è un po’ diversa rispetto alle altre classi. Per rendere Java più efficiente in termini di memoria, la JVM ha introdotto una speciale area di memoria per le stringhe chiamata String Constant Pool. Quando creiamo una stringa letterale, controlla se esiste già una stringa identica nel pool delle stringhe. Se presente, restituirà il riferimento della stringa esistente nel pool delle stringhe. Dai un’occhiata al programma di esempio di seguito.

package com.journaldev.examples;

/**
 * Java String Pool Example
 * 
 */
public class StringPoolExample {

	public static void main(String[] args) {
		
		String a = "abc";
		String b = "abc";
		String c = "def";
		
		//stesso riferimento
		if (a==b) {
			System.out.println("Both string refer to the same object");
		}
		
		//riferimento diverso
		if (a==c) {
			System.out.println("Both strings refer to the same object");
		}else {
			System.out.println("Both strings refer to the different object");
		}

	}

}

L’output del programma sopra è:

Both string refer to the same object
Both strings refer to the different object

Consulta questo post per ulteriori informazioni su Java String Pool.

String intern() Method

Quando creiamo una stringa utilizzando una stringa letterale, viene creata nel pool delle stringhe. Ma cosa succede se creiamo una stringa utilizzando la parola chiave `new` con lo stesso valore presente nel pool delle stringhe? Possiamo spostare la stringa dalla memoria heap al pool delle stringhe? Per questo si utilizza il metodo `intern()`, che restituisce una rappresentazione canonica dell’oggetto stringa. Quando chiamiamo il metodo `intern()` su un oggetto stringa creato utilizzando la parola chiave `new`, verifica se esiste già una stringa con lo stesso valore nel pool. In caso affermativo, restituisce il riferimento di quell’oggetto stringa dal pool. In caso contrario, crea una nuova stringa con lo stesso contenuto nel pool e restituisce il riferimento.

package com.journaldev.examples;

/**
 * Java String intern
 * 
 * @author pankaj
 *
 */
public class StringInternExample {

	public static void main(String[] args) {
		
		String s1 = "pankaj";
		String s2 = "pankaj";
		String s3 = new String("pankaj");
		
		System.out.println(s1==s2);//true
		System.out.println(s2==s3);//false
		
		String s4 = s3.intern();
		System.out.println(s1==s4);//true

	}

}

Controlla questo post per saperne di più sul metodo Java String intern.

Benefici dell’immuabilità delle stringhe

Alcuni dei vantaggi di avere la classe String come immutabile sono:

  1. String Constant Pool, quindi risparmio di memoria.
  2. Sicurezza, in quanto non può essere modificata.
  3. Sicurezza delle operazioni in multithreading
  4. Sicurezza del caricamento delle classi

Controlla questo post per ulteriori informazioni su Vantaggi dell’immuabilità delle stringhe.

Java 8 String join()

A new static method join() has been added in String class in Java 8. This method returns a new String composed of copies of the CharSequence elements joined together with a copy of the specified delimiter. Let’s look at an example to understand it easily.

List<String> words = Arrays.asList(new String[]{"Hello", "World", "2019"});
String msg = String.join(" ", words);
System.out.println(msg);

Output: Hello World 2019

Metodi String di Java 9

Sono stati aggiunti due metodi alla classe String nella versione di Java 9. Sono – codePoints() e chars(). Entrambi questi metodi restituiscono un oggetto IntStream su cui possiamo eseguire alcune operazioni. Diamo un’occhiata veloce a questi metodi.

String s = "abc";

s.codePoints().forEach(x -> System.out.println(x));

s.chars().forEach(x -> System.out.println(x));

Output:

97
98
99
97
98
99

Java 11 Nuovi Metodi della Classe String

Sono stati aggiunti molti nuovi metodi alla classe String nel rilascio di Java 11.

  • isBlank() – restituisce true se la stringa è vuota o contiene solo punti di codice spazio bianco, altrimenti false.
  • lines() – restituisce uno stream di righe estratte da questa stringa, separate dai terminatori di riga.
  • strip(), stripLeading(), stripTrailing() – per eliminare gli spazi bianchi iniziali e finali dalla stringa.
  • repeat() – restituisce una stringa il cui valore è la concatenazione di questa stringa ripetuta un numero di volte dato.

Diamo un’occhiata a un esempio di programma per questi metodi.

package com.journaldev.strings;

import java.util.List;
import java.util.stream.Collectors;

/**
 * JDK 11 New Functions in String class
 * 
 * @author pankaj
 *
 */
public class JDK11StringFunctions {

	public static void main(String[] args) {
		// isBlank()
		String s = "abc";
		System.out.println(s.isBlank());
		s = "";
		System.out.println(s.isBlank());

		// lines()
		String s1 = "Hi\nHello\rHowdy";
		System.out.println(s1);
		List lines = s1.lines().collect(Collectors.toList());
		System.out.println(lines);

		// strip(), stripLeading(), stripTrailing()
		String s2 = "  Java,  \tPython\t ";
		System.out.println("#" + s2 + "#");
		System.out.println("#" + s2.strip() + "#");
		System.out.println("#" + s2.stripLeading() + "#");
		System.out.println("#" + s2.stripTrailing() + "#");

		// repeat()
		String s3 = "Hello\n";
		System.out.println(s3.repeat(3));
		s3 = "Co";
		System.out.println(s3.repeat(2));

	}

}

Output:

false
true
Hi
Hello
Howdy
[Hi, Hello, Howdy]
#  Java,  	Python	 #
#Java,  	Python#
#Java,  	Python	 #
#  Java,  	Python#
Hello
Hello
Hello

CoCo

Ecco tutto sulla classe String di Java, i suoi metodi ed esempi di manipolazione di stringhe.

Puoi trovare più esempi di stringhe nel nostro Repository GitHub.

Riferimento: Documentazione API

Source:
https://www.digitalocean.com/community/tutorials/java-string