dichiarazione e inizializzazione di stringhe

[Freax]

queste 2 parti di codice, per dichiarare e inizializzare una stringa, sono equivalenti?

String varX= "ciao ciao";

String varX= new String("ciao ciao");

oppure fanno rispettivamente parte di diverse revisioni di Java?

[oronze]

http://www.coderanch.com/t/381271/ja...ring-Marcus-vs

[valia]

oltre alla considerazione di quanti oggetti si creano:

String s = new String("pippo");

equivale a

1. creare la stringa pippo (la jvm deve averne una rappresentazione)
2. creare l'oggetto s che inizialmente ha una stringa vuota
3. copiare l'oggetto pippo in s

  /**
     * Initializes a newly created <code>String</code> object so that it
     * represents the same sequence of characters as the argument; in other
     * words, the newly created string is a copy of the argument string. Unless 
     * an explicit copy of <code>original</code> is needed, use of this 
     * constructor is unnecessary since Strings are immutable. 
     *
     * @param   original   a <code>String</code>.
     */
    public String(String original) {
	int size = original.count;
	char[] originalValue = original.value;
	char[] v;
  	if (originalValue.length > size) {
 	    // The array representing the String is bigger than the new
 	    // String itself.  Perhaps this constructor is being called
 	    // in order to trim the baggage, so make a copy of the array.
	    v = new char[size];
 	    System.arraycopy(originalValue, original.offset, v, 0, size);
 	} else {
 	    // The array representing the String is the same
 	    // size as the String, so no point in making a copy.
	    v = originalValue;
 	}
	this.offset = 0;
	this.count = size;
	this.value = v;
    }

questo è quanto riportano i sorgenti java riguardo a string.

Poi in base a quanto riportato sopra ci saranno ottimizzazioni sull'uso delle stringhe in memoria, ma anche questa è una delle ragioni per non usare questo costrutto

[LeleFT]

Originariamente inviato da valia
Poi in base a quanto riportato sopra ci saranno ottimizzazioni sull'uso delle stringhe in memoria, ma anche questa è una delle ragioni per non usare questo costrutto

@Freax... a meno che non ci siano delle ottime ragioni per voler tenere distinti due oggetti con lo stesso contenuto. Prova questi test:

String s1 = "CIAO";
String s2 = "CIAO";
String s3 = new String("CIAO");
String s4 = new String("CIAO");

System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s3 == s4);
System.out.println(s1.equals(s3));
System.out.println(s3.equals(s4));

Ciao.

[Freax]

quindi, in sostanza, uso più memoria, alloco un oggetto in più, e quindi una inizializzazione di una classe String in più, giusto?

[valia]

vedila così: che bisogno hai di creare un oggetto e clonarlo per avere quello di partenza?
A meno di particolari esigenze non usare questo approccio

[Freax]

correggetemi se sbaglio, con

String varX= new String("ciao ciao");

io ho una costante che viene clonata come variabile di istanza?

dal punto di vista della memoria, quindi, "ciao ciao" e varX, fanno riferimento a 2 indirizzi differenti con proprietà di modifica differenti ?

a dire la verità non mi è chiarissimo il concetto ma inizio a comprenderne i "margini di manovra", mi mancano gli ultimi capitoli dal libro e forse quelli mi aiuteranno

[valia]

no, tu hai una rappresentazione interna di ciao ciao che viene clonata per creare la tua stringa, roba inutile nel 95% delle situazioni in cui basta fare solo un assegnamento.

Passare per il costruttore significa creare 2 oggetti con riferimenti diversi che hanno lo stesso contenuto (inefficiente appunto)

[Freax]

Originariamente inviato da valia
no, tu hai una rappresentazione interna di ciao ciao che viene clonata per creare la tua stringa, roba inutile nel 95% delle situazioni in cui basta fare solo un assegnamento.

Passare per il costruttore significa creare 2 oggetti con riferimenti diversi che hanno lo stesso contenuto (inefficiente appunto)

ma io ciao ciao lo passo come costante, che senso ha dire che ci sono 2 oggetti? dopo quella chiamata la costante "ciao ciao" non dovrebbe essere eliminata dal garbage collector e quindi in memoria mi ritrovo con 1 solo oggetto ovvero varX?

[LeleFT]

Originariamente inviato da Freax
correggetemi se sbaglio, con

String varX= new String("ciao ciao");

io ho una costante che viene clonata come variabile di istanza?

dal punto di vista della memoria, quindi, "ciao ciao" e varX, fanno riferimento a 2 indirizzi differenti con proprietà di modifica differenti ?

a dire la verità non mi è chiarissimo il concetto ma inizio a comprenderne i "margini di manovra", mi mancano gli ultimi capitoli dal libro e forse quelli mi aiuteranno

Devi partire da un concetto fondamentale riguardante le stringhe: esse sono immutabili. Cioè sono oggetti che non possono essere modificati.

Non ho ben capito cosa significhi per te "proprietà di modifica differenti", ma nel caso delle stringhe, tutte hanno la stessa capacità di modifica: nulla, assente, impossibile, niet.

Il discorso sulle stringhe in Java è piuttosto complesso, cercherò di riassumerlo:

Vi sono sostanzialmente 2 tipi di stringa: la stringa literal e la stringa non literal (se vogliamo darle un nome). Le stringhe literal sono tutte quelle che tu scrivi dentro al sorgente (ovvero, ogni volta che apri le virgolette, scrivi qualcosa e chiudi le virgolette, stai costruendo una stringa literal). Le altre (non literal) sono stringhe che provengono dall'esterno del sorgente (lette in input dalla tastiera, da un file, da una connessione via socket, ecc) e di cui, quindi, il compilatore non è a conoscenza del contenuto.

Tutte le stringhe literal finiscono nello String Literal Pool: è una lista di riferimenti, dove ciascun riferimento punta ad un oggetto String presente nello heap (come tutti gli oggetti).

Quindi, con questa istruzione

String pippo = new String("Mia Stringa");

crei due oggetti: uno è la stringa literal "Mia Stringa" (che va a finire nello String Literal Pool) e l'altro è un secondo oggetto del tutto identico al primo (dal punto di vista del contenuto), ma puntato solo dal reference "pippo".

Queste due istruzioni

String strA = "Mia Stringa";
String strB = "Mia Stringa";

creano due reference (strA e strB), che puntano entrambi all'unico oggetto presente nello heap (e puntato sempre da un reference nello String Literal Pool) perchè entrambi si riferiscono allo stesso literal.

Credo che questo documento ti possa chiarire molto le idee.


Ciao.