Varargs ב-Java: מתודות שמקבלות כל מספר של ארגומנטים

מתודה אחת, כל מספר של ארגומנטים

לפעמים לא יודעים מראש כמה ארגומנטים מתודה צריכה. ברגע אחד רוצים max(3, 9) ובבא אחריו max(1, 7, 4, 2, 8). בלי varargs הייתם צריכים לכתוב העמסה לכל כמות, או לחייב את הקוד הקורא לבנות מערך. Varargs, קיצור של variable arguments (ארגומנטים משתנים), מאפשרים למתודה אחת לקבל אפס, ערך אחד או ערכים רבים מאותו טיפוס.

מגדירים אותם עם שלוש נקודות (...) אחרי טיפוס הפרמטר:

public class Main {
    static int sum(int... numbers) {
        int total = 0;
        for (int n : numbers) {   // numbers הוא פשוט int[]
            total += n;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sum(1, 2, 3));        // 6
        System.out.println(sum(10, 20));         // 30
        System.out.println(sum());               // 0 - מותר לקרוא בלי ארגומנטים
        System.out.println(sum(4, 8, 15, 16));   // 43
    }
}

הקוד הקורא מעביר ערכים בודדים; בתוך המתודה numbers הוא מערך אמיתי. זה כל הרעיון: המהדר אורז את הארגומנטים לתוך מערך בשבילכם.

Varargs הם פשוט מערך

אין שום קסם בזמן ריצה. פרמטר שהוגדר int... numbers הוא בדיוק int[] ברגע שנמצאים בתוך המתודה. אפשר לבדוק את ה-length שלו, לגשת אליו לפי אינדקס ולעבור עליו בלולאה כמו על כל מערך אחר.

public class Main {
    static String join(String separator, String... parts) {
        if (parts.length == 0) {
            return "";
        }
        StringBuilder sb = new StringBuilder(parts[0]);
        for (int i = 1; i < parts.length; i++) {
            sb.append(separator).append(parts[i]);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        System.out.println(join("-", "2026", "06", "04"));  // 2026-06-04
        System.out.println(join(", ", "alone"));            // alone
    }
}

מכיוון שזה באמת מערך, אפשר גם להעביר למתודת varargs מערך שכבר יש לכם: היא מקבלת את שתי הצורות:

public class Main {
    static int sum(int... numbers) {
        int total = 0;
        for (int n : numbers) total += n;
        return total;
    }

    public static void main(String[] args) {
        int[] data = {5, 10, 15};
        System.out.println(sum(data));        // מעבירים מערך קיים
        System.out.println(sum(1, 2, 3, 4));  // או ערכים בודדים
    }
}

הכללים: אחרון, ורק אחד

שני כללים שומרים על varargs חד משמעיים, והמהדר אוכף את שניהם:

1. פרמטר ה-varargs חייב להיות האחרון. פרמטרים רגילים באים קודם, ואז הפרמטר עם ... אוסף את כל מה שנשאר.
2. למתודה יכול להיות לכל היותר פרמטר varargs אחד. עם שניים אי אפשר היה לדעת איפה אחד נגמר והבא מתחיל.

public class Main {
    // תקין: פרמטר רגיל קודם, varargs בסוף
    static void log(String level, Object... values) {
        System.out.print("[" + level + "] ");
        for (Object v : values) {
            System.out.print(v + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        log("INFO", "user", 42, true);
        log("WARN");   // חלק ה-varargs יכול להיות ריק
    }
}

זה מתקמפל. אבל אם שמים את ה-varargs ראשונים, static void log(Object... values, String level), מקבלים שגיאת קומפילציה: varargs parameter must be the last. הפרמטר הנדרש level תמיד בא לפני ה-....

איפה אתם כבר משתמשים ב-varargs

כל הזמן הזה קראתם למתודות varargs. System.out.printf ו-String.format הן הדוגמאות הקלאסיות: הפרמטר השני שלהן הוא Object... args:

public class Main {
    public static void main(String[] args) {
        System.out.printf("%s scored %d points (%.1f%%)%n", "Ada", 95, 95.0);

        String row = String.format("%-8s | %5d", "banana", 30);
        System.out.println(row);
    }
}

גם List.of(...), Arrays.asList(...) וממשקי API רבים בסגנון builder הם varargs. זו הסיבה שאפשר להעביר להם כל מספר של איברים בלי לעטוף שום דבר במערך בעצמכם.

Varargs והעמסה

Varargs והעמסה (overloading) משפיעים זה על זה בדרך מפתיעה אחת. כשהעמסה רגילה והעמסת varargs יכולות שתיהן להתאים לקריאה, Java מעדיפה את הספציפית יותר: המתודה עם מספר הפרמטרים הקבוע מנצחת:

public class Main {
    static String pick(int a, int b) {
        return "two-arg version";
    }

    static String pick(int... nums) {
        return "varargs version";
    }

    public static void main(String[] args) {
        System.out.println(pick(1, 2));      // two-arg version (ספציפית יותר)
        System.out.println(pick(1, 2, 3));   // varargs version
        System.out.println(pick());          // varargs version
    }
}

pick(1, 2) מתאימה לשתיהן, אבל Java בוחרת בהעמסה בלי varargs כי היא ההתאמה הקרובה יותר. מתודת ה-varargs רצה רק כשאף העמסה קבועה לא מתאימה. בדרך כלל זה מה שרוצים, אבל המשמעות היא שהוספת העמסת varargs יכולה לשנות בשקט לאיזו מתודה קריאה מסוימת מתפרשת.

שימו לב לקריאות ריקות ולקריאות עם null

שתי מלכודות תופסות אנשים. הראשונה: קריאה למתודת varargs בלי ארגומנטים מעבירה למתודה מערך ריק, לא null, ולכן numbers.length הוא 0 והלולאה לא עושה כלום. לא צריך בדיקת null עבור המקרה בלי ארגומנטים:

public class Main {
    static int count(Object... items) {
        return items.length;   // 0 עבור count(), אף פעם לא NPE
    }

    public static void main(String[] args) {
        System.out.println(count());            // 0
        System.out.println(count("a", "b"));    // 2
    }
}

השנייה: העברה של null מילולי היא עמומה ומסוכנת: Java עשויה לפרש את count(null) כ"כל מערך ה-varargs הוא null" ולא כ"איבר null אחד", ואז נזרקת NullPointerException כשקוראים את ה-length שלו. אם באמת מתכוונים לאיבר null יחיד, כתבו זאת במפורש עם count((Object) null).

הבא בתור: מחלקות

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