Distruggere una variabile

[Ironmax]

Salve.
Vorrei sapere come è possibile distruggere una variabile di tipo integer.
Ho questo codice di esempio:

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int conta_sovrascrittura = 0;
		int i = 0;
		for (; i < 5 ;) {
			System.out.println("Ciao " + i);
			i++;
		}

		//int i=0;
		for (; i < 7 ;) {
			System.out.println(" Mondo " + i);
			i++;
		}
	}

Prima del secondo for vorrei distruggere la variabile "i" ed rinizializzarla, è possibile?
Grazie.

[CaMpIoN]

Non si può distruggere una variabile, è il garbage collection che libera la memoria automaticamente cancellando le variabili e il resto che un programma java non usa più.
Innanzitutto precisiamo che inizializzare una variabile non è uguale ad assegnare una variabile, inizializzarla e dichiarare l'identificatore e il tipo, assegnare invece e appunto assegnare un valore adatto alla variabile, una variabile viene inizializzata una sola volta, mentre l'assegnazione può avvenire più volte, per inizializzare la variabile i nel tuo caso puoi usare:

int i;

Per assegnare un valore alla variabile i invece:

i = 0;

Quelli che usi tu per incrementare una variabile si chiama operatore di postincremento, cioè prima restituisce la variabile e poi la incrementa:

i++

questo equivale a:

i+=1;

che però a sua volta equivale a:

i=i+1; //Questa è un'assegnazione;

Scusami per il tanto utilizzo del codice, ma è meglio spiegarlo in questo modo.
Se hai capito la differenza tra assegnare ed inizializzare saprai che ti basta riassegnare la variabile e non rinizializzarla.

[Ironmax]

Non si può distruggere una variabile, è il garbage collection che libera la memoria automaticamente cancellando le variabili e il resto che un programma java non usa più
...

Scusa allora bisogna aspettare solo ed esclusivamente il garbage collector per liberare un'area di memoria? Mi sembra strano.

Scusami per il tanto utilizzo del codice, ma è meglio spiegarlo in questo modo. Se hai capito la differenza tra assegnare ed inizializzare saprai che ti basta riassegnare la variabile e non rinizializzarla.

So già la differenza e la riassegnazione l'ho già fatta, volevo trovare un qualcosa che ripulisca la memoria in maniera mirata e completa di tutta la variabile.

[Dark867]

Invece è proprio così: java è bello perché si occupa lui di tutto!
Fare quello che vuoi non è possibile

[MItaly]

Mi sembra che qui si stia facendo un po' di confusione.

In primo luogo, una variabile locale in sé viene distrutta quando esce di scope. Per cui, se vuoi limitare l'esistenza di una variabile ti basta inserirla in uno scope ristretto:

public void metodo()
{
    { // apro un nuovo blocco
        int i=10; // i è locale a questo blocco più interno
        ....
    } // qui i smette di esistere
    {
        int i=25; // questa i è un'altra variabile rispetto alla precedente
        ...
    }
}

Tutto questo ovviamente è puramente concettuale e in sé non ha una particolare differenza rispetto a riassegnare 25 a i, dato che alla fin della fiera la "nuova" i con ogni probabilità andrà a riciclare lo spazio sullo stack della precedente.

Fin qui il garbage collector non c'entra assolutamente nulla, sono semplicemente regole di scoping.

Ora, il punto è: cosa è contenuto esattamente in una variabile?

Dipende dal tipo.

In Java ci sono due categorie di tipi: i tipi primitivi e "tutti gli altri" (con abuso di terminologia da .NET li chiamerei "i value type" e i "reference type").

I tipi primitivi sono sostanzialmente vari tipi di numeri; quando dichiari una variabile di un tipo primitivo, essa contiene effettivamente il valore che ci memorizzi, e la sua esistenza si conclude completamente nel momento in cui essa esce di scope.

I "reference types", invece, sono classi, enum & co (tutto il resto, in sostanza). Quando tu dichiari una variabile di un tipo "reference type" in realtà stai dichiarando un riferimento (che può anche essere nullo) ad un oggetto di quel tipo, quello che in C sarebbe un puntatore. La differenza è evidente ad esempio nell'inizializzazione:

int i = 10;
UnTipo t = new UnTipo();

nel primo caso stai copiando direttamente il valore in i, nel secondo crei con new un oggetto di tipo UnTipo in un'area di memoria separata (l'heap) e inizializzi t con un riferimento all'oggetto appena creato.

Ora, con i reference types la questione è più complicata rispetto ai tipi primitivi, dato che è possibile avere più variabili che hanno un riferimento allo stesso oggetto, per cui, anche se una variabile esce di scope o le viene assegnato un altro riferimento ad oggetto, è possibile che un'altra continui ad avere un riferimento al medesimo oggetto. In linguaggi senza garbage collection questo è un problema non indifferente, in Java la questione è semplificata con il GC.
Infatti quando una variabile di tipo reference esce di scope la variabile in sé viene distrutta, ma l'oggetto a cui punta continua ad esistere per il motivo spiegato sopra. Ovviamente se si andasse avanti indefinitamente a creare oggetti senza distruggerli prima o poi finirebbe la memoria disponibile.

Il trucco è che ciclicamente viene fatto partire il GC, che altro non è che una parte della JVM che (semplificando) passa in rassegna tutti gli oggetti creati e vede se nel programma in esecuzione ci sono ancora variabili che si riferiscono ad essi. Dopo aver effettuato i controlli del caso, gli oggetti che non hanno più riferimenti vengono eliminati, e la memoria che occupavano resa disponibile per nuovi oggetti.

Nota però che tutto questo non ha alcuna influenza con il caso che hai specificato, dato che stai parlando di una variabile di tipo int, che non è gestita dal GC e cessa di esistere appena finisce il blocco in cui è dichiarata.