Come scambiare oggetti in Java?

Lo scambio di oggetti è una delle azioni più popolari nella programmazione. È particolarmente utile nell'ordinamento. Ciò che accade nello scambio è che due variabili si scambiano i loro valori. In questo articolo, impariamo come scambiare oggetti in Java in due casi diversi. Uno sta scambiando oggetti indipendenti e l'altro sta scambiando due oggetti in un elenco o in una matrice. Esaminiamo prima lo scambio di oggetti indipendenti.

Lo scambio di oggetti è diverso dallo scambio di tipi di dati primitivi

Uno dei metodi comuni da utilizzare per scambiare i valori primitivi è l'utilizzo di una variabile temporale. Tuttavia, sai che Java utilizza "Pass by Value" quando passa i parametri a un metodo. Pertanto, lo scambio di oggetti non funzionerà come previsto con questo metodo. L'esempio seguente lo mostrerà.

public class ObjectSwapper {
    public static void main(String[] args) {
        InnerClass obj1 = new InnerClass(12345);
        InnerClass obj2 = new InnerClass(11111);
        swap(obj1, obj2);
        System.out.println("Obj1 ID value : " + obj1.id + "\n" + "Obj2 ID value :  " + obj2.id);
    }
    static void swap(InnerClass x, InnerClass y) {
        InnerClass temp;
        temp = x;
        x = y;
        y = temp;
    }
    static class InnerClass {
        public int id;
        public InnerClass(int Id) {
            this.id = Id;
        }
    }
}

L'output: non c'è stato scambio! Quando chiamiamo il metodo swap e passiamo gli oggetti, passiamo una copia dell'oggetto, con tutti i valori delle proprietà. Per questo si chiama “Pass by Value”. Il metodo swap in realtà scambia gli oggetti che incidono solo sulla copia dell'oggetto originale. Così gli oggetti originali vengono mantenuti inalterati. La soluzione a questo sarebbe utilizzare una classe wrapper per avvolgere i due oggetti.

Scambio di oggetti con una classe wrapper

public class ObjectSwapper {
    public static void main(String[] args) {
 
        InnerClass obj1 = new InnerClass(12345);
        InnerClass obj2 = new InnerClass(11111);
        objectWrapper wrapperObj1 = new objectWrapper(obj1);
        objectWrapper wrapperObj2 = new objectWrapper(obj2);
        // Values before swapping
        System.out.println("WrapperObj1 InncerClass ID value : " + wrapperObj1.innerObject.id + "\n" + "WrapperObj2 InncerClass ID value : "
                + wrapperObj2.innerObject.id + "\n");
        
        swap(wrapperObj1, wrapperObj2);
        
        // Values after swapping
        System.out.println("WrapperObj1 InncerClass ID value : " + wrapperObj1.innerObject.id + "\n" + "WrapperObj2 InncerClass ID value : "
                + wrapperObj2.innerObject.id);
    }
 
       static void swap(objectWrapper wrapperObj1, objectWrapper wrapperObj2) {
        InnerClass temp;
        temp = wrapperObj1.innerObject;
        wrapperObj1.innerObject = wrapperObj2.innerObject;
        wrapperObj2.innerObject = temp;
    }
 
    static class InnerClass {
        public int id;
        public InnerClass(int Id) {
            id = Id;
        }
    }
 
    static class objectWrapper {
        InnerClass innerObject;
        public objectWrapper(InnerClass objInnner) {
            this.innerObject = objInnner;
        }
    }
}

Qui abbiamo usato una classe wrapper che ha una proprietà del tipo di oggetti che dobbiamo scambiare. Utilizzando un semplice metodo swap, scambia il contenuto degli oggetti InnerClass degli oggetti della classe wrapper. Per qualsiasi ulteriore implementazione degli oggetti InnerClass scambiati, possiamo utilizzare wrapperObj1.xyz e wrapperObj2.xyz di conseguenza. Il risultato:

Il metodo swap() integrato in Java

Le classi di Java Collections Framework hanno un metodo integrato per scambiare elementi chiamato swap() . java.util è una classe di utilità che contiene metodi statici che possono operare su elementi come gli elenchi dell'interfaccia Collection. L'utilizzo del metodo swap è molto più semplice rispetto all'esempio discusso in precedenza. Il metodo swap() è un metodo statico e quindi lo invochi con il nome della classe Collections.swap() . Il tipo di ritorno del metodo swap() è void quindi non restituirà nulla. Devi passare tre argomenti al metodo swap() . Controlla la nota qui sotto.

swap(List<?> list, int a, int b)

Parametri:

• list — list contiene gli elementi che scambiamo.
• a — indice di un elemento da scambiare .
• b — indice di un altro elemento da scambiare .

Si noti che questo metodo genererà un'eccezione IndexOutOfBoundsException se a o b è fuori dall'intervallo della dimensione dell'elenco. L'indice massimo dell'elenco è inferiore di uno alla dimensione dell'elenco. Qualsiasi valore di indice superiore a quello provocherà la generazione dell'eccezione IndexOutOfBoundsException. Di seguito è riportato un esempio di come utilizzare il metodo swap su un ArrayList.

swap() metodo su un ArrayList

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ArrayListSwapper {
    public static void main(String[] args) {
        try {
            List fruits = new ArrayList();
            fruits.add("Mango");
            fruits.add("Papaya");
            fruits.add("Apple");
            fruits.add("Orange");
            fruits.add("Watermelon");
            fruits.add("Bael");
            System.out.println("Before swapping : " + fruits);
         //using Collection.swap() method
            Collections.swap(fruits, 2, 5);
            System.out.println("After swapping : " + fruits);
        } catch (IndexOutOfBoundsException e) {
            System.out.println("Index Out of Bound Exception thrown : " + e);
        }
    }
}

L'ArrayList di frutti contiene sei elementi. Scambiamo il 2 ^° e il 5 ^° elemento usando il metodo function swap() . La procedura consigliata consiste nello scrivere il metodo swap() all'interno di un blocco try-catch in quanto può generare un'eccezione IndexOutOfBoundsException in fase di esecuzione. L'output: se passiamo "2" e "8" come indici, l'applicazione genererà un'eccezione poiché la dimensione dell'elenco è sei.

Collections.swap(fruits, 2, 8);

L'output sarà:

Conclusione

In questo tutorial, abbiamo discusso un paio di tecniche di scambio utilizzate in Java. Uno di questi utilizza una classe wrapper e l'altro utilizza il metodo Collection.swap() . È importante ricordare che la gestione delle eccezioni dovrebbe essere eseguita quando si utilizza la funzione swap() poiché genera un'eccezione di runtime.