Nell'esempio fornito verrà creato un solo oggetto. Innanzitutto JVM non troverà alcun oggetto stringa con il valore Welcome nel pool costante di stringhe, quindi creerà un nuovo oggetto. Dopodiché troverà la stringa con il valore Welcome nel pool, non creerà un nuovo oggetto ma restituirà il riferimento alla stessa istanza. In questo articolo impareremo a conoscere le stringhe Java.

Cosa sono le stringhe in Java?

Le stringhe sono il tipo di oggetti che possono memorizzare il carattere dei valori e in Java ogni carattere viene memorizzato in 16 bit, ovvero utilizzando la codifica UTF a 16 bit. Una stringa funziona allo stesso modo di un array di caratteri in Java.

Esempio:

String name = 'Geeks';>

Esempio di stringa in Java

Di seguito è riportato un esempio di una stringa in Java:

// Java Program to demonstrate // String public class StringExample {  // Main Function  public static void main(String args[])  {  String str = new String('example');  // creating Java string by new keyword  // this statement create two object i.e  // first the object is created in heap  // memory area and second the object is  // created in String constant pool.  System.out.println(str);  } }>

example>

Modi di creare una stringa

Esistono due modi per creare una stringa in Java:

• Stringa letterale
• Utilizzo della nuova parola chiave

Sintassi:

 = '';>

1. String letterale

Per rendere Java più efficiente in termini di memoria (perché non vengono creati nuovi oggetti se esiste già nel pool costante di stringhe).

Esempio:

String demoString = techcodeview.com;>

2. Utilizzando una nuova parola chiave

• String s = nuova String(Benvenuto);
• In tal caso, JVM creerà un nuovo oggetto stringa nella memoria heap normale (non pool) e il messaggio di benvenuto letterale verrà inserito nel pool costante di stringhe. La variabile s farà riferimento all'oggetto nell'heap (non pool)

Esempio:

String demoString = new String (techcodeview.com);>

Interfacce e classi in stringhe in Java

CharBuffer : Questa classe implementa l'interfaccia CharSequence. Questa classe viene utilizzata per consentire l'utilizzo dei buffer di caratteri al posto di CharSequences. Un esempio di tale utilizzo è il pacchetto di espressioni regolari java.util.regex.

Corda : È una sequenza di caratteri. In Java, gli oggetti String sono immutabili, il che significa una costante e non possono essere modificati una volta creati.

Interfaccia CharSequence

L'interfaccia CharSequence viene utilizzata per rappresentare la sequenza di caratteri in Java.
Le classi implementate utilizzando l'interfaccia CharSequence sono menzionate di seguito e forniscono molte funzionalità come sottostringa, lastoccurence, prima occorrenza, concatenate , toupper, tolower ecc.

1. Corda
2. StringBuffer
3. StringBuilder

1. Corda

String è una classe immutabile che significa una costante e non può essere modificata una volta creata e se desideriamo cambiare, dobbiamo creare un nuovo oggetto e anche le funzionalità che fornisce come toupper, tolower, ecc. Tutte restituiscono un nuovo oggetto, non è modificabile l'oggetto originale. È automaticamente thread-safe.

Sintassi

String str= 'geeks';  or String str= new String('geeks')>

2. StringBuffer

StringBuffer è una classe pari di Corda , è di natura mutabile ed è una classe thread-safe, possiamo usarla quando disponiamo di un ambiente multi-thread e di un oggetto condiviso di buffer di stringhe, ovvero utilizzato da thread multipli. Poiché è thread-safe, vi è un sovraccarico aggiuntivo, quindi viene utilizzato principalmente per programmi multithread.

struttura dati

Sintassi:

StringBuffer demoString = new StringBuffer('techcodeview.com');>

3. StringBuilder

StringBuilder in Java rappresenta un'alternativa a String e StringBuffer Class, in quanto crea una sequenza mutabile di caratteri e non è thread-safe. Viene utilizzato solo all'interno del thread, quindi non vi è alcun sovraccarico aggiuntivo, quindi viene utilizzato principalmente per programmi a thread singolo.

Sintassi:

StringBuilder demoString = new StringBuilder(); demoString.append('GFG');>

StringTokenizer

StringTokenizer La classe in Java viene utilizzata per suddividere una stringa in token.

Esempio:

Un oggetto StringTokenizer mantiene internamente una posizione corrente all'interno della stringa da tokenizzare. Alcune operazioni fanno avanzare questa posizione corrente oltre i caratteri elaborati. Un token viene restituito prendendo una sottostringa della stringa utilizzata per creare l'oggetto StringTokenizer.

StringJoiner è una classe In java.util pacchetto che viene utilizzato per costruire una sequenza di caratteri (stringhe) separati da un delimitatore e facoltativamente iniziando con un prefisso fornito e terminando con un suffisso fornito. Sebbene ciò possa essere fatto anche con l'aiuto della classe StringBuilder per aggiungere un delimitatore dopo ogni stringa, StringJoiner fornisce un modo semplice per farlo senza molto codice da scrivere.

stringa Java in numero intero

Sintassi:

public StringJoiner(CharSequence delimiter)>

Sopra abbiamo visto che possiamo creare una stringa tramite String Literal.

String demoString =Benvenuto;

Qui la JVM controlla il pool di costanti di stringhe. Se la stringa non esiste, viene creata una nuova istanza di stringa e inserita in un pool. Se la stringa esiste, non creerà un nuovo oggetto. Piuttosto, restituirà il riferimento alla stessa istanza. La cache che memorizza queste istanze di stringa è nota come pool String Constant o String Pool. Nelle versioni precedenti di Java fino a JDK 6 il pool di stringhe si trovava all'interno dello spazio PermGen (generazione permanente). Ma in JDK 7 viene spostato nell'area dell'heap principale.

Stringa immutabile in Java

In Java, gli oggetti stringa sono immutabili. Immutabile significa semplicemente immodificabile o immutabile. Una volta creato un oggetto stringa, i suoi dati o il suo stato non possono essere modificati ma viene creato un nuovo oggetto stringa.

Di seguito è riportata l'implementazione dell'argomento:

// Java Program to demonstrate Immutable String in Java import java.io.*; class GFG {  public static void main(String[] args)  {  String s = 'Sachin';    // concat() method appends  // the string at the end  s.concat(' Tendulkar');    // This will print Sachin  // because strings are  // immutable objects  System.out.println(s);  } }>

Sachin>

Qui Sachin non viene modificato ma viene creato un nuovo oggetto con Sachin Tendulkar. Ecco perché una stringa è detta immutabile.

Come puoi vedere nella figura data, vengono creati due oggetti ma la variabile di riferimento si riferisce ancora a Sachin e non a Sachin Tendulkar. Ma se lo assegniamo esplicitamente alla variabile di riferimento, si riferirà all'oggetto Sachin Tendulkar.

Per esempio:

// Java Program to demonstrate Explicitly assigned strings import java.io.*; class GFG {  public static void main(String[] args)  {  String name = 'Sachin';  name = name.concat(' Tendulkar');  System.out.println(name);  } }>

Sachin Tendulkar>

Assegnazione della memoria della stringa

Ogni volta che un oggetto String viene creato come valore letterale, l'oggetto verrà creato nel pool costante String. Ciò consente a JVM di ottimizzare l'inizializzazione del valore String letterale.

Esempio:

String demoString = 'Geeks';>

La stringa può anche essere dichiarata utilizzando a nuovo operatore, ovvero allocato dinamicamente. Nel caso in cui le stringhe vengano allocate dinamicamente, viene assegnata una nuova posizione di memoria nell'heap. Questa stringa non verrà aggiunta al pool costante String.

Esempio:

String demoString = new String('Geeks');>

Se desideri archiviare questa stringa nel pool costante, dovrai internarla.

Esempio:

webdriver

String internedString = demoString.intern();  // this will add the string to string constant pool.>

È preferibile utilizzare valori letterali String poiché consente a JVM di ottimizzare l'allocazione della memoria.

Un esempio che mostra come dichiarare una String

// Java code to illustrate String import java.io.*; import java.lang.*; class Test {  public static void main(String[] args)  {  // Declare String without using new operator  String name = 'techcodeview.com';  // Prints the String.  System.out.println('String name = ' + name);  // Declare String using new operator  String newString = new String('techcodeview.com');  // Prints the String.  System.out.println('String newString = ' + newString);  } }>

String name = techcodeview.com String newString = techcodeview.com>

Nota: L'oggetto stringa viene creato nell'area heap e i valori letterali vengono archiviati in un'area di memoria speciale nota come pool costante di stringhe.

Perché il pool di stringhe è passato da PermGen a IL area di heap normale?

Lo spazio di PermGen è limitato, la dimensione predefinita è di soli 64 MB. si trattava di un problema con la creazione e l'archiviazione di troppi oggetti stringa nello spazio PermGen. Ecco perché il pool di stringhe è stato spostato in un'area heap più ampia. Per rendere Java più efficiente in termini di memoria, viene utilizzato il concetto di stringa letterale. Utilizzando la parola chiave 'new', la JVM creerà un nuovo oggetto stringa nell'area heap normale anche se lo stesso oggetto stringa è presente nel pool di stringhe.

Per esempio:

String demoString = new String('Bhubaneswar');>

Diamo un'occhiata al concetto con un programma Java e visualizziamo l'effettiva struttura della memoria JVM:

Di seguito è riportata l’implementazione dell’approccio di cui sopra:

// Java program and visualize the // actual JVM memory structure // mentioned in image class StringStorage {  public static void main(String args[])  {  // Declaring Strings  String s1 = 'TAT';  String s2 = 'TAT';  String s3 = new String('TAT');  String s4 = new String('TAT');  // Printing all the Strings  System.out.println(s1);  System.out.println(s2);  System.out.println(s3);  System.out.println(s4);  } }>

TAT TAT TAT TAT>

Pool di stringhe in Java

Nota: Tutti gli oggetti in Java sono archiviati in un heap. La variabile di riferimento è per l'oggetto memorizzato nell'area dello stack oppure può essere contenuta in altri oggetti che li inseriscono anche nell'area dell'heap.

Esempio 1:

// Construct String from subset of char array // Driver Class class GFG {  // main function  public static void main(String args[])  {  byte ascii[] = { 71, 70, 71 };  String firstString = new String(ascii);  System.out.println(firstString);  String secondString = new String(ascii, 1, 2);  System.out.println(secondString);  } }>

GFG FG>

Esempio 2:

// Construct one string from another class GFG {  public static void main(String args[])  {  char characters[] = { 'G', 'f', 'g' };  String firstString = new String(characters);  String secondString = new String(firstString);  System.out.println(firstString);  System.out.println(secondString);  } }>

Gfg Gfg>

Domande frequenti

1. Cosa sono le stringhe in Java?

Le stringhe sono i tipi di oggetti che possono memorizzare caratteri come elementi.

2. Perché gli oggetti stringa sono immutabili in Java?

Perché Java utilizza il concetto di stringa letterale. Supponiamo che ci siano 5 variabili di riferimento, tutte si riferiscono a un oggetto Sachin. Se una variabile di riferimento modifica il valore dell'oggetto, sarà influenzata da tutte le variabili di riferimento. Questo è il motivo per cui gli oggetti stringa sono immutabili in Java.

3. Perché Java utilizza il concetto di stringa letterale?

Per rendere Java più efficiente in termini di memoria (perché non vengono creati nuovi oggetti se esiste già nel pool costante di stringhe).