Newsgroup: it.comp.java
Titolo: Utilizzo memoria

Salve a tutti.
Scusate la domanda molto stupida ma sto collassando il sistema.
Ho dei cicli for che girano molte volte e ogni volta per circa 1000 / 1500
record a volta.
All'interno di questi cicli devo visualizzare alcune informazioni
lavorando i dati.
La domanda è questa. Per memorizzare i dati mi conviene utilizzare una
struttura dipo questa ..
String appo = null;
for (int i = 0; i < 1000; i++)
{
   appo = nomeOggetto.getValore();
   ... 
}
dichiarando la Stringa appo fuori dal ciclo.
Oppure mi conviene dichiararla all'interno del ciclo ?
for (int i = 0; i < 1000; i++)
{
   String appo = nomeOggetto.getValore();
   ... 
}
Oppure è la stessa cosa dato che uscito dal ciclo la stringa non è più
referenziata e quindi cancellata?
Può sembrare una cavolata ma sto andando ad esclusioni dato che ho un
programma che lavora su un infinità di dati e credo di aver fatto da
qualche parte una stupidaggine che mi impalla tutto.
Vabbè che java è lenta di per se, ma il mio programma batte tutti.
Non so se può essere di aiuto, ma il ciclo for lavora per visualizzare e
poi rileggere i valori che inserisco in una jTable.
Grazie a tutti.
Alessandra
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

Ciao,
no sono molto bravo in ottimizzazioni e performance... ma la prima cosa
 che mi viene in mente è di utilizzare una applicazione che controlli 
proprio queste cose... mi sembra che in post precedenti c'erano 
 indicati alcuni se non sbaglio jprobe...
ma comunque basta che fai una ricerca ne trovi molti.
Rispetto alla tua domanda mi viene da pensare che Java lavorando per 
riferimenti le due cose sono simili, non dovrebbero istanziare oggetti 
e quindi, anche se ari è più efficente  appo = nomeOggetto.getValore();
,
non creo che  sia questo che ti crea problemi.
Se provi a mandare il codice posso darci un occhi veloce....
CIao
--gio
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 }
Ragioniamoci su...
Quando dichiari un oggetto, qualsiasi esso sia(anche le Stringhe), 
allochi una variabile che dovra' contenere il riferimento all'oggetto 
stesso. Percui nel ciclo, COMUNQUE crei oggetti sempre nuovi, nel primo 
caso copi il riferimento ad essi in una variabile esistente da uno scoop 
esterno, nel secondo caso crei ogni volta un riferimento nuovo, usato 
solo nel ciclo for, quindi fuori da esso non lo usi piu'. In termini di 
velocita' dovrebbe essere equivalente, in termini di quandtita' di 
memoria, teoricamente anche, perche' dovrebbe pensare direttamente il 
garbage collector a gestire la cosa.
Quindi la risposta e' : dipende da come il garbage collector gestisce la 
memoria in quest'occasione.
Secondo me, ma non vorrei dire una cavolata, il compilatore ottimizza 
l'istruzione ed usa sempre la stessa variabile, per memorizzare i 
riferimenti che crei. Se vuoi chiedo al prof. all'universita' e poi te 
lo dico.. Ho lezione questa sera, parliamo degli array, magari riusciamo 
ad infilare anche sta domanda.
Comunque.. Se fosse come ti ho detto, il secondo metodo sarebbe non solo 
piu' pulito (dichiari la veriabile solo dove serve), ma anche piu' 
performante, inquanto la variabile non ti rimane allocata in memoria 
oltre alla porzione di codice in cui realmente la utilizzi, quindi 
appena fuori dal ciclo for, viene distrutta e puo' essere recuperata.
Io di solito uso questo secondo metodo...
Ciao e ci sentiamo dopo la lezione ;)
-- 
            Davide Gurgone
      web: 
http://www.gurgone.it/
mail: davidechiocciolinagurgonepuntoit


Non credo che il pc ti collassi per questa inezia...
Sarebbe logico pensare che, essendo la dichiarazione un'operazione, il
processore impiega un certo tempo per effettuarla e quindi farla 1000 volte
(2° caso) comporta una spesa maggiore che farla 1 volta sola, tuttavia penso
che il "compilatore" ottimizzi la questione da solo.Ricordo che in altri
linguaggi non era possibile utilizzare la seconda forma...quindi concentrati
piuttosto su quello che fai tra i "..."
ad esempio
1. evita l'utilizzo dell'operatore di concatenazione a favore di un corretto
utilizzo della classe StringBuffer
2. Sicura che rilasci le risorse appena possibile?
3. Utilizzi in aggiornamento/inserimento un Vector o un ArrayList? Evitali a
favore della LinkedList
4. Utilizza un profiler.
...altre dritte non mancheranno ;)

Analizzando il codice risultante dalla compilazione di una classe con le 2
differenti versioni noto che
il compilatore non fà differenza.
Quindi non è poi così importante dove dichiari la tua variabile, a mio
parere.
Tommaso Torti