puntatore ad un intero in Java

Question

Ho un codice come questo

int a,b; 
switch(whatever){ 
    case 1: 
     lots_of_lines_dealing_with_variable_a; 
    case 2: 
     same_lines_but_dealing_with_variable_b; 
} 

ho pensato di fare:

int a,b; 
pointer_to_int p; 
switch(whatever){ 
    case 1: 
     p=a; 
    case 2: 
     p=b; 
} 
lots_of_lines_dealing_with_pointer_p; 

ridurrebbe il codice per circa la metà delle linee, ma Java non lo fa consentire i puntatori ai numeri interi. Quindi, c'è un modo per avvicinarsi a questo?

Modifica: i compiti sono molto più grandi di questo metodo. Devo creare una classe chiamata "DoubleList" che contenga due elenchi collegati in un singolo vettore. Gli interi di cui parlo sono i puntatori all'inizio delle liste, che devo spostare in altre posizioni degli elenchi quando si aggiungono o rimuovono elementi negli elenchi

Answer 1

Si potrebbe provare a utilizzare la boxe.

public class IntBoxer { 
    public IntBoxer() { 
    } 
    public IntBoxer(int startValue) { 
     this.value = startValue; 
    } 
    public int value; 
} 
IntBoxer a = new IntBoxer(); 
IntBoxer b = new IntBoxer(); 
IntBoxer p; 
Switch(whatever){ 
    case 1: 
     p=a; 
     break; 
    case 2: 
     p=b; 
     break; 
} 
lots_of_lines_dealing_with_pointer_p.value; 

Answer 2

Utilizzare la classe Integer invece di un int.

Per darvi un esempio utilizzando il codice che avete:

Integer a,b; 
Integer p; 
switch(whatever){ 
    case 1: 
     p=a; 
    case 2: 
     p=b; 
} 

Answer 3

forse mi manca qualcosa, ma sembra facilmente risolvibili a me:

int a,b; 

switch(whatever) { 
    case 1: 
    a = manipulateValue(a); 
    break; 
    case 2: 
    b = manipulateValue(b); 
    break; 
} 

int manipulateValue(int v) { 
    // lots of lines dealing with variable v 
    return v; 
} 

Se non è necessario modificare le variabili, quindi è possibile tralasciare il valore di ritorno (basta usare void) e il compito.

Se nient'altro ha bisogno di chiamare il metodo, dovrebbe essere private (è un principio generale: dare il minimo accesso possibile, per quanto necessario).

Answer 4

Sì, si chiama "un metodo":

private int lots_of_lines_dealing_with_value(int x) 
{ 
    . 
    . 
    . 
    return new_value; 
} 


int a,b; 
Switch(whatever){ 
    case 1: 
     p=lots_of_lines_dealing_with_value(a); 
     break; 
    case 2: 
     p=lots_of_lines_dealing_with_value(b); 
     break; 
} 

Answer 5

Perché non basta fare:

int a,b; 

Switch(whatever){ 
    case 1: 
     f(a); 
     break; 
    case 2: 
     f(b); 
     break; 
    default: 
     // ??? 
} 

Answer 6

Java non ha i puntatori, ha riferimenti.

Un puntatore è una variabile che contiene un indirizzo di memoria. In genere, si deruba il puntatore per ottenere la memoria necessaria per alcune operazioni.

Un riferimento è un indice in una tabella di gestione della memoria. In genere la tabella di gestione della memoria è protetta dall'accesso diretto. Nel caso di Java, il riferimento non può essere manipolato manualmente, poiché ogni lettura della variabile risulterà nel restituire l'oggetto di riferimento.

Questo ha molte implicazioni, ma è necessario per una garbage collection automatica decente. La raccolta dei dati inutili a volte comporta lo spostamento di oggetti nella memoria per creare aree più ampie di spazio libero (per gli oggetti necessari che non possono essere adattati ai fori di memoria correnti). Se Java ha esposto un puntatore, dopo la compattazione della memoria, potresti avere il "vecchio" indirizzo della memoria.

Utilizzando i riferimenti, il vostro riferimento è garantito per rimanere lo stesso, anche se la posizione effettiva della memoria si muove. Interno alla JVM è un riferimento alla tabella puntatore, ma non lo vedrai mai da un programma in esecuzione; perché, se mai lo avessi toccato, rovinerebbe la gestione automatica della memoria.

Answer 7

Bene, per questo scenario:

boolean useA; 
int a, b; 

if(useA) 
     lots_of_lines_dealing_with_variable_a; 
else 
     same_lines_but_dealing_with_variable_b; 

è possibile utilizzare:

boolean useA; 
int a, b; 

int value = useA ? a : b; 

// lines_dealing_with_value 

if(useA) 
    a = value; 
else 
    b = value; 

Ma in realtà. Metodi!