איך מחליפים אובייקטים ב-Java?

החלפת אובייקטים היא אחת הפעולות הפופולריות ביותר בתכנות. זה שימושי במיוחד במיון. מה שקורה בהחלפה הוא שני משתנים המחליפים את הערכים שלהם. במאמר זה נלמד כיצד להחליף אובייקטים ב-Java בשני מקרים שונים. האחד הוא החלפת אובייקטים עצמאיים והשני הוא החלפת שני אובייקטים ברשימה או מערך. תחילה נבחן החלפת אובייקטים עצמאיים.

החלפת אובייקטים שונה מהחלפת סוגי נתונים פרימיטיביים

אחת השיטות הנפוצות לשימוש כדי להחליף ערכים פרימיטיביים היא שימוש במשתנה זמני. עם זאת, אתה יודע ש-Java משתמשת ב-"Pass By Value" בעת העברת פרמטרים לשיטה. לכן, החלפת אובייקטים לא תעבוד כפי שציפית בשיטה זו. הדוגמה הבאה תראה זאת.

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

הפלט: לא הייתה החלפה! כאשר אנו קוראים לשיטת swap ומעבירים את האובייקטים, אנו מעבירים עותק של האובייקט, עם כל ערכי המאפיינים. זו הסיבה שבגללה זה נקרא "עובר על ידי ערך". שיטת ההחלפה למעשה מחליפה את האובייקטים שמשפיעים רק על העותק של האובייקט המקורי. אז החפצים המקוריים נשמרים ללא שינוי. הפתרון לכך יהיה להשתמש במחלקת עטיפה כדי לעטוף את שני האובייקטים.

החלפת חפצים עם כיתת עטיפה

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

כאן השתמשנו במחלקת עטיפה שיש לה מאפיין של סוג האובייקטים שאנחנו צריכים להחליף. על ידי שימוש בשיטת החלפה פשוטה, הוא מחליף את התוכן של אובייקטי InnerClass של אובייקטי מחלקת ה-wrapper. לכל יישום נוסף של אובייקטי InnerClass שהוחלפו, נוכל להשתמש ב-wrapperObj1.xyz וב-wrapperObj2.xyz בהתאם. הפלט:

שיטת ה-swap() המובנית ב-Java

למחלקות של Java Collections Framework יש שיטה מובנית להחלפת אלמנטים הנקראת swap() . ה- java.util הוא מחלקת עזר המכילה שיטות סטטיות שיכולות לפעול על אלמנטים כמו רשימות מממשק האוסף. השימוש בשיטת ההחלפה הוא הרבה יותר קל מהדוגמה שדיברנו עליה קודם לכן. השיטה swap() היא שיטה סטטית ולכן אתה מפעיל אותה עם שם המחלקה בתור Collections.swap() . סוג ההחזרה של שיטת swap() בטל ולכן הוא לא יחזיר דבר. עליך להעביר שלושה ארגומנטים לשיטת swap() . בדוק את ההערה למטה.

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

פרמטרים:

• list — רשימה מכילה את האלמנטים שאנו מחליפים.
• a - אינדקס של רכיב שיש להחליף .
• b - אינדקס של אלמנט אחר שיש להחליף .

שים לב ששיטה זו תזרוק IndexOutOfBoundsException אם a או b נמצאים מחוץ לטווח של גודל הרשימה. האינדקס המרבי של הרשימה הוא אחד פחות מגודל הרשימה. כל ערך אינדקס יותר מזה יגרום ל- IndexOutOfBoundsException להיזרק. דוגמה לשימוש בשיטת ההחלפה ב- ArrayList מוצגת להלן.

שיטת swap() ב- 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 של פירות מכיל שישה אלמנטים. אנו מחליפים את ^{האלמנטים השני} והחמישי באמצעות שיטת הפונקציה swap() . השיטה הטובה ביותר היא לכתוב את שיטת swap() בתוך בלוק try-catch מכיוון שהיא יכולה לזרוק IndexOutOfBoundsException בזמן ריצה. הפלט: אם נעביר את '2' ו-'8' כאינדקסים, האפליקציה תזרוק חריגה מכיוון שגודל הרשימה הוא שישה.

Collections.swap(fruits, 2, 8);

הפלט יהיה:

סיכום

במדריך זה, דנו בכמה טכניקות החלפה המשמשות ב-Java. אחד מהם משתמש במחלקת עטיפה והשני משתמש בשיטת Collection.swap() . חשוב לזכור שטיפול בחריגים צריך להיעשות בעת שימוש בפונקציה swap() מכיוון שהיא זורקת חריג בזמן ריצה.