[JAVA] Chiarimento su strutture lineari

[x3d0]

Ciao a tutti,
questo è un metodo di una struttura lineare

Codice PHP:

public void rimuoviUtente(String n) {
        Utente p = inizio;
        if (p == null)
            return;
        if (p.nome.equals(n)) {
            inizio = inizio.prox;
            return;
        }
        while ((p.prox != null) && (!p.prox.nome.equals(n)))
            p = p.prox;
        if (p.prox != null) 
            p.prox = p.prox.prox;
        //QUI!


    } 


Codice PHP:

public class Utente {
    String nome;
    String email;
    Utente prox;
  
    public Utente(String n, String e) {
        nome = n;
        email = e;
        prox = null;
    }
} 


Il metodo rimuove correttamente un utente dalla lista. Quello che non capisco è: La nuova lista "p", creata all'interno del metodo, è accessibile solo all'interno del metodo. Perchè non viene copiata dentro this.inizio che è pubblico?

O meglio, siccome il metodo rimuoviUtente viene chiamato dall'esterno e dall'esterno viene letto solamente this.inizio perchè "p" non viene copiato in this.inizio?

La classe e il collaudo funziona correttamente. Ma non capisco come diavolo faccia se non gli aggiungo

Codice PHP:

this.inizio = p; 


Se lo aggiungo dopo viene cancellato il primo nodo della lista e anche l'ultimo. E non capisco il perchè...

[Gin&&Tonic]

A

[Gin&&Tonic]

while ((p.prox != null) && (!p.prox.nome.equals(n))) 
            p = p.prox; 
        if (p.prox != null) 
            p.prox = p.prox.prox; 
        //QUI! ??
devi togliere completamente l'if interno al while , non serve a nulla. La tua "lista utenti" viene già esaminata nodo per nodo dall'istruzione:

while (p.prox != null) 
     p = p.prox; 

    }

In altre parole il metodo è questo:

public void rimuoviUtente(String n) { 
        Utente p = inizio; 
        if (p == null) 
            return; 
      
        while (p.prox != null) {
            p = p.prox; 
            if (p.nome.equals(n)) { 
            inizio = inizio.prox; 
            return; 
      }
   } 
}

Non ho capito bene cosa fà questo : Utente p = inizio;

[x3d0]

Si, ma non capisco perchè non viene aggiornata la variabile this.inizio, ma solo la variabile locale

Questo ad esempio è un altro pezzo di codice.
Io ragiono così:
- Inizializzo "p" al valore this.inizio. (Prodott inizio è il primo nodo della lista)
perchè non posso scorrere direttamente su this.inizio altrimenti viene cambiato il valore e rimangono con solamente l'ultimo nodo in mano.
- Se è nullo, ovvero se sto al primo nodo, allora aggiungo un nuovo nodo al primo (this.inizio)
(Fin qui ha senso..)
- Poi ciclo i successivi nodi della lista "p"
- Quando si verifica una certa condizione, aggiorno l'attributo "quantità" di "p".

Questo codice funziona (e' un esercizio d'esempio).
Quello che non capisco è come faccia a funzionare se la variabile "p" è una variabile locale!!
Avrebbe più senso se la modifica della quantità fosse stata fatta a this.inizio (come per il primo nodo).

Illuminatemi. Non riesco a venirne a capo! Please

Codice PHP:

public void aggiornaMagazzino(String c, String d, int q) {
        Prodotto p = this.inizio;
        if (p == null)
            this.inizio = new Prodotto(c, d, q);
        else {
            while (p.prox != null)
                p = p.prox;
            if (condizione) 
                p.quant += q;
            
        }
    } 


[X3n0]

non è che potresti postare i codici completi di tutte le classi? così non si riesce a ragionare

[x3d0]

Si, certo. Ecco qui...

Codice PHP:

public class Magazzino
{
    Prodotto inizio;

    public void aggiornaMagazzino(String c, String d, int q) {
        Prodotto p = inizio;
        if (p == null)
            inizio = new Prodotto(c, d, q);
        else {
            while (p.prox != null)
                p = p.prox;
            if (condizione) 
                p.quant += q;
        }
    }
} 


Codice PHP:

public class Prodotto {
    String codice;
    String desc;
    int quant;
    Prodotto prox;
   
    public Prodotto(String c, String d, int q) {
        codice = c;
        desc = d;
        quant = q;
        prox = null;
    }
} 


[X3n0]

allora il punto è che fai casino con i campi della classe prodotto.
nel paradigma ad oggetti è sempre sconsigliabile lasciare accessibili dall'esterno campi di una classe, e quindi è anche sconsigliabile andarvi ad accedere.

il mio consiglio è di rendere disponibili dei metodi nella classe prodotto che ne accedano ai campi.

ad esempio quando vuoi settare il prossimo prodotto, invece di fare p=p.prox avrai un metodo

public boolean setProx(Prodotto p){
     if(this.prox!=null){
          this.prox=p;
          return true;
     }
     else
          return false;
}

e poi richiami in "magazino" inizio.setProx(p);


ma perchè non usare una List?

[x3d0]

Non posso usare List perchè è un esercizio d'esame. La difficoltà è farlo senza List e framework vari.

A parte il fatto di incapsulare this.inizio. Quello è chiaro ma non è un problema ora.

Provo a spiegarmi meglio. Questo codice funziona perfettamente.
Il problema è che non capisco come faccia a funzionare.
se "p" non è nullo viene modificato un valore di un nodo della lista.
Fin qui tutto ok.
Il fatto è che la variabile "p" è locale, quindi dovrebbe morire alla fine del metodo e, subito dopo la modifica della lista, non c'è alcun legame con this.inizio!
Quando vado a stampare l'intera lista (da un altro metodo), ovvero "inizio" non vado a leggere "p"! Ma la lista risulta modificata! Cosa fà??

Codice PHP:

public class Magazzino 
{ 
    Prodotto inizio; 

    public void aggiornaMagazzino(String c, String d, int q)
 { 
        Prodotto p = inizio; 
        if (p == null) 
            inizio = new Prodotto(c, d, q); 
        else { 
            while (p.prox != null) 
                p = p.prox; 
            if (condizione) 
                p.quant += q; 
        } 
    } 
} 


[X3n0]

tu modifichi però inizio e il campo quantità della classe prodotto, è ovvio che la tua struttura dati ne sarà modificata!

o forse non ho capito bene cosa vuoi dire...

[banryu79]

Originariamente inviato da x3d0

...
Il fatto è che la variabile "p" è locale, quindi dovrebbe morire alla fine del metodo e, subito dopo la modifica della lista, non c'è alcun legame con this.inizio!
...
Quando vado a stampare l'intera lista (da un altro metodo), ovvero "inizio" non vado a leggere "p"! Ma la lista risulta modificata! Cosa fà??
...

Ciao x3d0,
credo che tu non abbia ben chiara la distinzione, in Java, tra un'istanza e il riferimento ad un'istanza.

Questa è la dichiarazione di un riferimento ad una istanza di tipo Prodotto con inizializzazione al valore di default:

Prodotto p;
// equivale a: 
// Prodotto p = null;

Anche questa è la dichiarazione di un riferimento ad una istanza di tipo Prodotto (con inizializzazione al valore di default):

Prodotto inizio;
// equivale a:
// Prodotto inizio = null;

"p" e "inizio", nei codici qui sopra, sono dei riferimenti inizializzati a null, cioè non si riferiscono (oppure non puntano, non sono collegati, come preferisci) a nessuna istanza di Prodotto.
Se provi ad accedere ad un membro di istanza di Prodotto (ad esempio al membro "codice" così: "p.codice;") tramite uno di questi due riferimenti viene lanciata una NullPointerException.

Come abbiamo detto, "p" e "inizio" sono dei riferimenti. Ma quando entrano in gioco le istanze vere e proprie?
Quando vengono create con la keyword "new".
Qui, ad esempio:

Prodotto p = new Prodotto(c, d, q);

Cosa succede? A sinistra dell'operatore di assegnamento viene dichiarato "p" come un riferimento di tipo Prodotto; a destra dell'operatore di assegnamento viene creata un'istanza di Prodotto.
Il risultato ora è che "p" si riferisce a quell'istanza di Prodotto.
Nota come nel codice un'istanza di per se non ha un nome, è anonima; a venire nominati sono solo i riferimenti alle istanze (in Java).

Un ultimo esempio.
Nel codice che segue immagina che la chiamata a stampa() abbia l'effetto di stampare il nome di ogni riferimento a Prodotto esistente seguito dal valore dei membri dell'istanza di Prodotto a cui è collegato.

Prodotto inizio, p;

// 1)
inizio = new Prodotto("123", "istanza1", 1);
p = inizio;
stampa();
// inizio = ["123", "istanza1", 1]
// p = ["123", "istanza1", 1]

// 2
inizio = null;
stampa();
// inizio = null
// p = ["123", "istanza1", 1]

// 3
inizio =  new Prodotto("456", "istanza2", 1);
stampa();
// inizio = ["456", "istanza2", 1]
// p = ["123", "istanza1", 1]

// 4
Prodotto tmp = inizio:
inizio = p;
p = tmp;
tmp = null;
stampa();
// inizio = ["123", "istanza1", 1]
// p = ["456", "istanza2", 1]
// tmp = null

// 5
Prodotto a, b;
a = new Prodotto("789, "istanza3", 1);
b = a;
a.codice = "999";
b.desc = "istanzaX";
stampa();
// inizio = ["123", "istanza1", 1]
// p = ["456", "istanza2", 1]
// tmp = null
// a = ["999", "istanzaX", 1]
// b = ["999", "istanzaX", 1]

La morale è che l'operatore di assegnamento (=) applicato ad un riferimento collega quel riferimento con un'istanza, o indicando l'istanza a cui collegarsi direttamente (il caso del new) o indicandola indirettamente tramite un'altro riferimento.
Cioè l'assegnamento è un'operazione che modifica il riferimento (lo fa puntare ad un'altra istanza) e non tocca le istanze.

Invece l'assegnamento applicato a un membro di istanza attraverso un riferimento a quella istanza (il caso di a.codice = ... oppure b.desc = ..., con a e b che puntano alla stessa istanza) è una mutazione che si applica all'istanza stessa e non tocca i riferimenti (cioè non sono "a" e "b" a venire modificati, ma l'istanza a cui entrambi si riferiscono).


Ora prova ad analizzare nuovamente la classe Magazzino e il suo metodo aggiornaMagazzino: dovresti essere in grado di spiegarci cosa fa, e quindi perchè "funziona"