come faccio a rendere la mia funzione di scambio in java?

Question

come faccio a rendere la mia funzione di scambio in java se non esiste un metodo con cui possiamo passare per riferimento? Qualcuno potrebbe darmi un codice?

swap(int a, int b) 
{ 
    int temp = a; 
    a = b; 
    b = temp; 
} 

ma il cambiamento solito essere riflessa dal java passa dal valore

Answer 1

Non è possibile creare un metodo swap, in modo che dopo aver chiamato swap(x,y) il i valori di x e y saranno scambiati. Potresti creare un tale metodo per le classi mutabili scambiando il loro contenuto¹, ma questo non cambierebbe la loro identità dell'oggetto e non potresti definire un metodo generale per questo.

È tuttavia possibile scrivere un metodo che scambia due elementi in un array o in un elenco, se questo è ciò che si desidera.

¹ Ad esempio, è possibile creare un metodo di scambio che richiede due elenchi e dopo aver eseguito il metodo, l'elenco x avrà il contenuto precedente della lista y e l'elenco y avrà il contenuto precedente della lista x.

Answer 2

Dipende da cosa si vuole fare. Questo codice scambia due elementi di un array.

void swap(int i, int j, int[] arr) { 
    int t = arr[i]; 
    arr[i] = arr[j]; 
    arr[j] = t; 
} 

Qualcosa di simile scambia il contenuto di due int[] di uguale lunghezza.

void swap(int[] arr1, int[] arr2) { 
    int[] t = arr1.clone(); 
    System.arraycopy(arr2, 0, arr1, 0, t.length); 
    System.arraycopy(t, 0, arr2, 0, t.length); 
} 

Qualcosa di simile scambia il contenuto di due BitSet (utilizzando il XOR swap algorithm):

void swap(BitSet s1, BitSet s2) { 
    s1.xor(s2); 
    s2.xor(s1); 
    s1.xor(s2); 
} 

Qualcosa di simile scambia i x e y campi di alcune Point classe:

void swapXY(Point p) { 
    int t = p.x; 
    p.x = p.y; 
    p.y = t; 
} 

Answer 3

Potrei fare qualcosa di simile al seguente. Naturalmente, con la ricchezza delle classi Collection, non riesco a immaginare di aver mai bisogno di usarlo in qualsiasi codice pratico.

public class Shift { 
    public static <T> T[] left (final T... i) { 
    if (1 >= i.length) { 
     return i; 
    } 
    final T t = i[0]; 
    int x = 0; 
    for (; x < i.length - 1; x++) { 
     i[x] = i[x + 1]; 
    } 
    i[x] = t; 
    return i; 
    } 
} 

Chiamato con due argomenti, è uno scambio.

Può essere utilizzato come segue:

int x = 1; 
int y = 2; 
Integer[] yx = Shift.left(x,y); 

alternativa:

Integer[] yx = {x,y}; 
Shift.left(yx); 

Poi

x = yx[0]; 
y = yx[1]; 

Nota: auto-scatole primitive.

Answer 4

penso che questo è il più vicino si può arrivare a un semplice scambio, ma non ha un modello di utilizzo semplice:

int swap(int a, int b) { // usage: y = swap(x, x=y); 
    return a; 
} 

y = swap(x, x=y); 

Essa si basa sul fatto che x passerà in swap prima y viene assegnato a x, quindi x viene restituito e assegnato a .

Si può rendere generico e scambiare qualsiasi numero di oggetti dello stesso tipo:

<T> T swap(T... args) { // usage: z = swap(a, a=b, b=c, ... y=z); 
    return args[0]; 
} 

c = swap(a, a=b, b=c) 

Answer 5

public class Swap1 { 
    public static void main(String[] args){ 
     int x =7; 
     int y = 3; 

     swap(x,y); 

     System.out.println("x = " + x); 
     System.out.println("y = " + y); 
    } 

    public static void swap(int x, int y) { 
     int temp = x; 
     x = y; 
     y = temp; 
    } 
} 

Answer 6

A quanto pare non ho punti reputazione abbastanza per commentare su Dansalmo's answer, ma è un buono, anche se errato. La sua risposta è in realtà un K-combinator.

int K(int a, int b) { 
    return a; 
} 

JLS is specific about argument evaluation when passing to methods/ctors/etc. (Non era così nelle specifiche più vecchie?)

Concesso, questo è un idioma funzionale, ma è abbastanza chiaro per coloro che lo riconoscono. (Se non si capisce il codice a trovare, non lo fanno scimmia in su!)

y = K(x, x=y); // swap x and y 

Il K-Combinator è progettato appositamente per questo genere di cose. AFAIK non c'è motivo per cui non dovrebbe passare una revisione del codice.

Mio $ 0,02.

Answer 7

AFAIS, nessuno cita atomic reference.

Integer

public void swap(AtomicInteger a, AtomicInteger b){ 
    a.set(b.getAndSet(a.get())); 
} 

String

public void swap(AtomicReference<String> a, AtomicReference<String> b){ 
    a.set(b.getAndSet(a.get())); 
} 

Answer 8

Prova questa magia

public static <T> void swap(T a, T b) { 
    try { 
     Field[] fields = a.getClass().getDeclaredFields(); 
     for (Field field : fields) { 
      field.setAccessible(true); 
      Object temp = field.get(a); 
      field.set(a, field.get(b)); 
      field.set(b, temp); 
     } 
    } catch (IllegalAccessException e) { 
     e.printStackTrace(); 
    } 
} 

e provarlo!

System.out.println("a:" + a); 
    System.out.println("b:" + b); 
    swap(a,b); 
    System.out.println("a:" + a); 
    System.out.println("b:" + b);