Newsgroup: it.comp.java
Titolo: domanda su liste in java e puntatori(?)

Salve, dopo tanta fatica ho scritto il mio primo
programma in java quasi serio che implementa 
una lista .
In pratica creo un 'oggetto impiegato che ha come
attributo il nome e il numero di interno.
L'oggetto e' del tipo lista :
class Lista{
String nome;
int interno;
Lista next;
}
Esempio :dopo la fase di inserimento dovrebbe apparire una scritta
del tipo:
Nome impiegato:sergio
Interno impiegato:1234
Ora ottengo uno warning perche' sembra di capire
non "compilo" in modalita' deprecation(?), con un -p
sembra, poi il programma alcune volte gira altre no.
Mi spiego, di solito la prima volta ,ma non sempre,
funziona e quando do quit esce stampando come sopra.
Altre volte la maggior parte, quando batto quit al posto
del nome dell'impiegato rimane imbalsamato e faccio un ctrl c
per chiudere non ottenendo naturalmente la stampa.
Domande: gli oggetti rimangono residenti in memoria
e creano confusione alle successive esecuzioni?.
Non ho ben compreso il concetto di distruttore ,credo,
devo scrivere anche dei metodi distruttori?.
E' possibile alle successive esecuzioni del programma
riattaccarsi alla lista precedentemente creata se non
e' stata distrutta?.
Altro problema, chiedo scusa per la lunghezza della lettera
 ma non riesco ad andare avanti, se batto come numero
interno 111 per esempio ottengo in stampa un numero
del tipo 939294922 , che sembra un'indirizzo di memoria
dei puntatori del c.
E' evidente che ancora sono un po' grezzino in java.
Vi ringrazio tantissimo per l'aiuto che vorrete darmi.
Vi chiederei gentilmente anche il nome di un buon
libro in java che tratti soprattutto le strutture dati
e i puntatori "impliciti" di questo linguaggio.
Ho comprato introduzione a java
di Bertacca e Guidi della McGraw-Hill che vale
quello che costa, cioe' poco.
Con il thinking J non ci levo l gambe.
Ecco il prg
import java.io.*;
class Lista{
String nome;  //informazione sul nome
int interno;  //informazione sul numero di interno
Lista next;   //puntatore implicito all'elemento succ
}
 class provaLista{
//devi inserire il nome e il numero dell'impiegato
static Lista leggiLista() throws IOException{
// impiegato e' un 'oggetto di tipo lista
Lista impiegato = new Lista();
//creo due nuovi oggetti del tipo DtaInputStream
DataInputStream leggiNome=new DataInputStream(System.in);
DataInputStream leggiNum=new DataInputStream(System.in);
String Nome=leggiNome.readLine();
/*---Stringa nulla fine lista---*/
if(Nome==null||Nome.equals("quit"))
return(null);
/*------------------------------*/
else{
int Num=leggiNum.readInt();
impiegato.nome=Nome;
impiegato.interno=Num;
impiegato.next=leggiLista();
return impiegato;
}
}
 static void stampa(Lista impiegato){
if(impiegato!=null){
System.out.println("Nome impiegato :"+impiegato.nome);
System.out.println("Interno impiegato:"+impiegato.interno);
stampa(impiegato.next);
}
else System.exit(0);
}
public static void main(String[] argv) throws IOException{
Lista impiegato =leggiLista();
stampa(impiegato);
}
}
--
Posted from 
mercurio.val.it
 [194.244.89.10] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Con il thinking J non ci levo l gambe.
Cerca di cavarcele perché è tra i migliori. Buono studio.
Ciao,
 Stefano
----------
"X WindowSSS, teSSSoro mio... lo odieremo per SSSempre"
Bill Gollum
----------

devo scrivere anche dei metodi distruttori?.
Al contrario di C++, Java non ha distruttori espliciti - cioe' un metodo che 
viene invocato immediatamente come conseguenza di un "delete" da parte del 
programmatore - cioe' la cancellazione di un oggetto. Per l'ottimo motivo che 
Java non ha l'operatore "delete". :) In Java, quando tutti i reference ad un 
oggetto vanno fuori scope, l'oggetto e' marcato "garbage" e un thread asincrono 
(il garbage collector), in qualche momento futuro, provvede al rilascio della 
relativa memoria.
void finalize() viene invocato dalla JVM quando la distruzione fisica 
dell'oggetto e' imminente, e all'uscita della JVM se hai impostato 
Runtime.setFinalizersOnExit(true). 
Tieni presente che il quando e' dipendente dalla tecnica di garbage collection, 
su cui la JVM fa poche assunzioni. Il package java.lang.ref ti da' strumenti e 
concetti per avere piu' controllo sul processo.
-- 
God is Real, unless declared Integer.
ObjectZone - 
http://space.tin.it/computer/csadun

 Runtime.setFinalizersOnExit(true). 
          ^^^ 
nel jdk1.2.2 il metodo runFinalizersOnExit() risulta deprecato, non
perche` sostituito da una nuova versione, ma perche` indicato come
"inherently unsafe". Sai se esiste un'alternativa "sicura"?
Ho un server che gestisce dei dati in memoria e ho la necessita` di
assicurare la scrittura degli stessi su disco alla chiususa
dell'applicazione. Quando capita pero` che si termini la JVM con
ctrl-c sulla console o mandandogli un segnale di terminazione, il
finalize() non viene richiamato e io finisco col perdere le modifiche
apportate... ci sto` pensando da un po`, ma l'unica soluzione che
ho trovato e` appunto il runFinalizerOnExit()... mi sembra funzionare,
ma non vorrei correre rischi se fosse possibile fare altrimenti!
-- 
Ciao, Matteo                        !! Memories flashin' through my head
                                    /\ Was I just born or am I dead?
mailto:
matteo.mattia
 (at) 
libero.it
 \/              -- The Morning After
                                    　                   Faith No More


L'idea, se non capisco male, e' che finalize() dovrebbe agire solo sugli 
oggetti garbage - mentre se la JVM esce, far girare i finalizers su oggetti non 
garbage puo'causare effetti indesiderati/inaspettati.
Molto dipende, quindi dal tuo design: se disegni oggetti in cui "finalize" e' 
un clenaup locale o comunque non ha side effects che devono essere *diversi* in 
caso di terminazione normale o anomale, non dovresti aver problemi.
