Cum se schimbă obiectele în Java?

Schimbarea obiectelor este una dintre cele mai populare acțiuni în programare. Este deosebit de util în sortare. Ceea ce se întâmplă în schimb este că două variabile își schimbă valorile. În acest articol, învățăm cum să schimbăm obiecte în Java în două cazuri diferite. Unul schimbă obiecte independente, iar celălalt schimbă două obiecte într-o listă sau într-o matrice. Să examinăm mai întâi schimbul de obiecte independente.

Schimbarea obiectelor este diferită de schimbarea tipurilor de date primitive

Una dintre metodele comune de utilizat pentru a schimba valorile primitive este utilizarea unei variabile temporale. Cu toate acestea, știți că Java folosește „Pass by Value” atunci când transmite parametrii unei metode. Prin urmare, schimbarea obiectelor nu va funcționa așa cum vă așteptați cu această metodă. Următorul exemplu o va arăta.

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;
        }
    }
}

Ieșire: Nu a existat nicio schimbare! Când apelăm metoda swap și trecem obiectele, transmitem o copie a obiectului, cu toate valorile proprietăților. Acesta este motivul pentru care se numește „Trecere prin valoare”. Metoda swap schimbă de fapt obiectele care afectează doar copia obiectului original. Deci obiectele originale sunt păstrate neschimbate. Soluția pentru aceasta ar fi să folosiți o clasă wrapper pentru a înfășura cele două obiecte.

Schimbarea obiectelor cu o clasă 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;
        }
    }
}

Aici am folosit o clasă wrapper care are o proprietate a tipului de obiecte pe care trebuie să le schimbăm. Folosind o metodă simplă de swap, schimbă conținutul obiectelor InnerClass ale obiectelor clasei wrapper. Pentru orice implementare ulterioară a obiectelor InnerClass schimbate, putem folosi wrapperObj1.xyz și wrapperObj2.xyz în consecință. Ieșire:

Metoda încorporată swap() în Java

Clasele Java Collections Framework au o metodă încorporată de a schimba elemente numită swap() . Java.util este o clasă de utilitate care conține metode statice care pot funcționa pe elemente precum Liste din interfața Collection. Utilizarea metodei swap este mult mai ușoară decât exemplul discutat mai devreme. Metoda swap() este o metodă statică și, prin urmare, o invocați cu numele clasei ca Collections.swap() . Tipul de returnare al metodei swap() este nul, deci nu va returna nimic. Trebuie să transmiteți trei argumente metodei swap() . Verificați nota de mai jos.

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

Parametri:

• listă — lista conține elementele pe care le schimbăm.
• a — indicele unui element de schimbat .
• b — indicele altui element de schimbat .

Rețineți că această metodă va arunca o excepție IndexOutOfBoundsException dacă a sau b se află în afara limitei dimensiunii listei. Indicele maxim al listei este cu unul mai mic decât dimensiunea listei. Orice valoare a indexului mai mare decât aceasta va cauza excepția IndexOutOfBoundsException. Un exemplu de utilizare a metodei swap pe o ArrayList este prezentat mai jos.

metoda swap() pe o 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);
        }
    }
}

ArrayList de fructe conține șase elemente. Schimbăm al 2- ^lea și al 5- ^lea element folosind metoda funcției swap() . Cea mai bună practică este să scrieți metoda swap() într-un bloc try-catch, deoarece poate arunca o excepție IndexOutOfBoundsException în timpul rulării. Ieșire: Dacă trecem „2” și „8” ca indici, aplicația va arunca o excepție deoarece dimensiunea listei este de șase.

Collections.swap(fruits, 2, 8);

Ieșirea va fi:

Concluzie

În acest tutorial, am discutat câteva tehnici de schimb utilizate în Java. Unul dintre ele folosește o clasă wrapper, iar celălalt folosește metoda Collection.swap() . Este important să ne amintim că gestionarea excepțiilor ar trebui făcută atunci când utilizați funcția swap() , deoarece aruncă o excepție de rulare.