Before varargs existed in Java 5, writing a method that accepted a flexible number of arguments meant either creating multiple overloads for one, two, three, four arguments, or forcing the caller to pack everything into an array first. Both approaches were clumsy. Varargs solved this.

A varargs parameter lets a method accept any number of arguments of the same type — zero, one, five, or a hundred — without the caller needing to create an array or the developer needing to write multiple overloads. The JVM creates the array behind the scenes.

What Are varargs?

varargs (variable arguments) is a special parameter syntax that allows a method to accept zero or more arguments of the same type. It is declared using three dots (...) after the type.

Java

Try it out

// This method accepts any number of int arguments
public int sum(int... numbers) { ... }

// All of these are valid calls:
sum()                  // zero arguments
sum(10)                // one argument
sum(10, 20)            // two arguments
sum(10, 20, 30, 40)    // four arguments
int[] arr = {1, 2, 3};
sum(arr)               // passing an existing array

Inside the method, numbers is treated as a plain int[]. The JVM collects whatever arguments are passed into an array before calling the method.

What the JVM does:

  Caller writes:  sum(10, 20, 30)
                     |
                     v
  JVM creates:    int[] numbers = {10, 20, 30}
                     |
                     v
  Method receives: sum(int[] numbers)  — works like a normal array

Basic Syntax and Usage

Java

Try it out

// File: VarargsBasics.java

public class VarargsBasics {

    // Accepts zero or more int values
    public int sum(int... numbers) {
        int total = 0;
        for (int n : numbers) {
            total += n;
        }
        return total;
    }

    // Accepts zero or more Strings
    public void printAll(String... messages) {
        System.out.println("Total messages: " + messages.length);
        for (String msg : messages) {
            System.out.println("  " + msg);
        }
    }

    // varargs combined with regular parameters
    // Regular parameter MUST come before the varargs parameter
    public void log(String level, String... messages) {
        for (String msg : messages) {
            System.out.println("[" + level + "] " + msg);
        }
    }

    public static void main(String[] args) {

        VarargsBasics vb = new VarargsBasics();

        // sum — different number of arguments
        System.out.println("sum()           = " + vb.sum());
        System.out.println("sum(5)          = " + vb.sum(5));
        System.out.println("sum(1,2,3)      = " + vb.sum(1, 2, 3));
        System.out.println("sum(10,20,30,40)= " + vb.sum(10, 20, 30, 40));

        // Existing array also works directly
        int[] marks = {85, 90, 78, 95, 88};
        System.out.println("sum(array)      = " + vb.sum(marks));

        System.out.println();
        vb.printAll(); // zero arguments — messages.length is 0
        System.out.println();
        vb.printAll("Server started", "Database connected");

        System.out.println();
        vb.log("INFO",  "Server started", "Listening on port 8080");
        vb.log("ERROR", "Connection refused");
    }
}

Output:
sum()           = 0
sum(5)          = 5
sum(1,2,3)      = 6
sum(10,20,30,40)= 100
sum(array)      = 436

Total messages: 0

Total messages: 2
  Server started
  Database connected

[INFO] Server started
[INFO] Listening on port 8080
[ERROR] Connection refused

When no arguments are passed, numbers.length is 0 and the loop body never executes — the method returns 0 cleanly. The caller never needs to create an array or check whether to pass null.

varargs Rules — What You Must Know

Rule 1 — Only ONE varargs parameter per method.

  VALID:   void method(int... nums)
  VALID:   void method(String s, int... nums)
  INVALID: void method(int... nums, String... strs)   ← compile error

Rule 2 — varargs must be the LAST parameter.

  VALID:   void log(String level, String... messages)
  INVALID: void log(String... messages, String level) ← compile error

Rule 3 — The varargs parameter is a regular array inside the method.

  public void show(int... nums) {
      int[] arr = nums;   // valid — nums IS an int[]
      nums.length;        // valid
      nums[0];            // valid — but check length first!
  }

Rule 4 — An existing array can be passed directly.

  int[] values = {1, 2, 3};
  sum(values); // valid — array passed as varargs

Rule 5 — null can be passed but causes NullPointerException when iterated.

  sum(null); // compiles, but nums is null inside — NPE if you access nums.length

varargs vs Array Parameter — Comparison Table

Aspect	`int... numbers` (varargs)	`int[] numbers` (array)
Caller syntax	`method(1, 2, 3)` — no array needed	`method(new int[]{1,2,3})` — array required
Zero arguments	`method()` — valid	`method(new int[]{})` or `method(null)`
Passing existing array	`method(arr)` — works directly	`method(arr)` — works directly
Inside the method	Treated as a regular array	Treated as a regular array
Position in parameter list	Must be last	Any position
Multiple varargs in one method	Not allowed — only one	Multiple array params allowed
Overloading	Compiler prefers exact match over varargs	Normal overload resolution
JVM	Creates array from supplied arguments	Array passed directly — no creation
Readability at call site	Clean — `sum(1, 2, 3)`	Verbose — `sum(new int[]{1, 2, 3})`
When to use	When the number of arguments genuinely varies	When you always have a pre-existing array

varargs and Overloading — How the Compiler Chooses

The compiler treats varargs as a last-resort match. If an exact-match overload exists, it is always preferred over the varargs version.

Java

Try it out

// File: VarargsOverloadDemo.java

public class VarargsOverloadDemo {

    // Exact match — two ints
    public static void display(int a, int b) {
        System.out.println("Two-int overload: " + a + ", " + b);
    }

    // Exact match — one int
    public static void display(int a) {
        System.out.println("One-int overload: " + a);
    }

    // varargs — last resort
    public static void display(int... nums) {
        System.out.println("varargs overload, count=" + nums.length);
        for (int n : nums) System.out.print(n + " ");
        if (nums.length > 0) System.out.println();
    }

    public static void main(String[] args) {

        display(5);          // exact match — one-int overload
        display(5, 10);      // exact match — two-int overload
        display(5, 10, 15);  // no exact match — varargs
        display();           // no exact match — varargs with zero elements
        display(1, 2, 3, 4); // no exact match — varargs
    }
}

Output:
One-int overload: 5
Two-int overload: 5, 10
varargs overload, count=3
5 10 15 
varargs overload, count=0
varargs overload, count=4
1 2 3 4

display(5) and display(5, 10) both have exact-match overloads — they never touch the varargs version. Only calls with three or more arguments, or zero arguments, fall through to the varargs overload.

varargs With Different Types

Varargs works with any type — including String, custom classes, and Object for mixed types.

Java

Try it out

// File: VarargsTypesDemo.java

public class VarargsTypesDemo {

    // String varargs
    public static String joinWith(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();
    }

    // double varargs — calculates average
    public static double average(double... values) {
        if (values.length == 0) return 0.0;
        double sum = 0;
        for (double v : values) sum += v;
        return sum / values.length;
    }

    // Object varargs — accepts anything
    public static void printDetails(String label, Object... attributes) {
        System.out.print(label + ": ");
        for (int i = 0; i < attributes.length; i++) {
            System.out.print(attributes[i]);
            if (i < attributes.length - 1) System.out.print(" | ");
        }
        System.out.println();
    }

    public static void main(String[] args) {

        // String varargs
        System.out.println(joinWith(", ", "Priya", "Rohan", "Sneha", "Karan"));
        System.out.println(joinWith(" / ", "Mumbai", "Delhi", "Bengaluru"));
        System.out.println(joinWith("-", "2024", "01", "15"));

        System.out.println();

        // double varargs
        System.out.printf("Avg marks  : %.2f%n", average(85.0, 90.0, 78.0, 95.0));
        System.out.printf("Avg single : %.2f%n", average(100.0));
        System.out.printf("Avg empty  : %.2f%n", average());

        System.out.println();

        // Object varargs — mix of types
        printDetails("Employee", "EMP-042", "Priya Mehta", "Engineering", 85000);
        printDetails("Product",  "SKU-101", "Laptop",       "Electronics", 45999.0, true);
    }
}

Output:
Priya, Rohan, Sneha, Karan
Mumbai / Delhi / Bengaluru
2024-01-15

Avg marks  : 87.00
Avg single : 100.00
Avg empty  : 0.00

Employee: EMP-042 | Priya Mehta | Engineering | 85000
Product: SKU-101 | Laptop | Electronics | 45999.0 | true

Object... attributes accepts any mix of types — the JVM boxes primitives automatically. This is exactly how String.format, printf, and logging frameworks like Log4j accept format arguments.

Real-World Example 1 — Report Builder for a School Management System

The Business Problem

A school management system used in institutions like CBSE schools or coaching centres generates student progress reports. A report line can carry different amounts of data depending on which subjects the student appeared for — some students have five subjects, others have eight. Rather than creating separate methods for each possible count, a varargs-based report builder handles all cases cleanly.

Java

Try it out

// File: SubjectScore.java

public class SubjectScore {

    private final String subject;
    private final int    marks;
    private final int    maxMarks;

    public SubjectScore(String subject, int marks, int maxMarks) {
        this.subject  = subject;
        this.marks    = marks;
        this.maxMarks = maxMarks;
    }

    public String  getSubject()  { return subject; }
    public int     getMarks()    { return marks; }
    public int     getMaxMarks() { return maxMarks; }
    public double  getPercent()  { return (marks * 100.0) / maxMarks; }

    public String getGrade() {
        double pct = getPercent();
        if (pct >= 90) return "A+";
        if (pct >= 75) return "A";
        if (pct >= 60) return "B";
        if (pct >= 45) return "C";
        return "D";
    }

    @Override
    public String toString() {
        return String.format("%-20s %3d/%3d  %-3s (%.1f%%)",
                subject, marks, maxMarks, getGrade(), getPercent());
    }
}

Java

Try it out

// File: ReportBuilder.java

public class ReportBuilder {

    private static final String DIVIDER = "─".repeat(52);

    // varargs — handles any number of subjects cleanly
    public void generateReport(String studentName,
                                String rollNumber,
                                String className,
                                SubjectScore... scores) {

        System.out.println(DIVIDER);
        System.out.println("  STUDENT PROGRESS REPORT");
        System.out.println(DIVIDER);
        System.out.printf("  Name    : %s%n", studentName);
        System.out.printf("  Roll No : %s%n", rollNumber);
        System.out.printf("  Class   : %s%n", className);
        System.out.println(DIVIDER);
        System.out.printf("  %-20s %7s  %-3s %s%n",
                "Subject", "Marks", "Grade", "Percent");
        System.out.println(DIVIDER);

        if (scores.length == 0) {
            System.out.println("  No scores recorded.");
        } else {
            int    totalMarks    = 0;
            int    totalMaxMarks = 0;

            for (SubjectScore score : scores) {
                System.out.println("  " + score);
                totalMarks    += score.getMarks();
                totalMaxMarks += score.getMaxMarks();
            }

            double overallPct = (totalMarks * 100.0) / totalMaxMarks;
            System.out.println(DIVIDER);
            System.out.printf("  %-20s %3d/%3d       (%.1f%%)%n",
                    "TOTAL", totalMarks, totalMaxMarks, overallPct);
            System.out.printf("  Overall Grade: %s%n",
                    overallPct >= 75 ? "DISTINCTION" :
                    overallPct >= 60 ? "FIRST CLASS" :
                    overallPct >= 45 ? "PASS" : "FAIL");
        }
        System.out.println(DIVIDER);
    }
}

Java

Try it out

// File: SchoolReportDemo.java

public class SchoolReportDemo {

    public static void main(String[] args) {

        ReportBuilder builder = new ReportBuilder();

        // Student 1 — 5 subjects
        builder.generateReport(
            "Priya Sharma", "R-2024-042", "Class X - A",
            new SubjectScore("Mathematics",       92, 100),
            new SubjectScore("Science",            88, 100),
            new SubjectScore("English",            79, 100),
            new SubjectScore("Hindi",              83, 100),
            new SubjectScore("Social Studies",     76, 100)
        );

        System.out.println();

        // Student 2 — 8 subjects (PCM + extras)
        builder.generateReport(
            "Rohan Mehta", "R-2024-078", "Class XII - Science",
            new SubjectScore("Physics",            75, 100),
            new SubjectScore("Chemistry",          68, 100),
            new SubjectScore("Mathematics",        82, 100),
            new SubjectScore("English",            71, 100),
            new SubjectScore("Computer Science",   94, 100),
            new SubjectScore("Physical Education", 88, 100)
        );

        System.out.println();

        // Student 3 — no scores yet (varargs allows zero)
        builder.generateReport("Sneha Rao", "R-2024-015", "Class IX - B");
    }
}

Output:
────────────────────────────────────────────────────
  STUDENT PROGRESS REPORT
────────────────────────────────────────────────────
  Name    : Priya Sharma
  Roll No : R-2024-042
  Class   : Class X - A
────────────────────────────────────────────────────
  Subject              Marks  Grade Percent
────────────────────────────────────────────────────
  Mathematics            92/100  A+  (92.0%)
  Science                88/100  A   (88.0%)
  English                79/100  A   (79.0%)
  Hindi                  83/100  A   (83.0%)
  Social Studies         76/100  A   (76.0%)
────────────────────────────────────────────────────
  TOTAL                418/500       (83.6%)
  Overall Grade: DISTINCTION
────────────────────────────────────────────────────

────────────────────────────────────────────────────
  STUDENT PROGRESS REPORT
────────────────────────────────────────────────────
  Name    : Rohan Mehta
  Roll No : R-2024-078
  Class   : Class XII - Science
────────────────────────────────────────────────────
  Subject              Marks  Grade Percent
────────────────────────────────────────────────────
  Physics                75/100  A   (75.0%)
  Chemistry              68/100  B   (68.0%)
  Mathematics            82/100  A   (82.0%)
  English                71/100  B   (71.0%)
  Computer Science       94/100  A+  (94.0%)
  Physical Education     88/100  A   (88.0%)
────────────────────────────────────────────────────
  TOTAL                478/600       (79.7%)
  Overall Grade: DISTINCTION
────────────────────────────────────────────────────

────────────────────────────────────────────────────
  STUDENT PROGRESS REPORT
────────────────────────────────────────────────────
  Name    : Sneha Rao
  Roll No : R-2024-015
  Class   : Class IX - B
────────────────────────────────────────────────────
  Subject              Marks  Grade Percent
────────────────────────────────────────────────────
  No scores recorded.
────────────────────────────────────────────────────

One generateReport method handles five subjects, six subjects, and zero subjects without any changes. Without varargs, you would need separate overloads — or force the caller to always build a SubjectScore[] manually before calling the method.

Real-World Example 2 — Order Summary Builder for an E-Commerce App

The Business Problem

A food ordering app like Zomato or Swiggy displays an order summary before checkout. A customer might order one item or ten items. The summary builder must handle any count, calculate the total, and apply delivery charges — all through one clean method call that reads naturally for any number of items.

Java

Try it out

// File: FoodItem.java

public class FoodItem {

    private final String name;
    private final double price;
    private final int    quantity;

    public FoodItem(String name, double price, int quantity) {
        this.name     = name;
        this.price    = price;
        this.quantity = quantity;
    }

    public String getName()     { return name; }
    public double getPrice()    { return price; }
    public int    getQuantity() { return quantity; }
    public double getLineTotal(){ return price * quantity; }

    @Override
    public String toString() {
        return String.format("  %-25s x%d  Rs.%7.2f", name, quantity, getLineTotal());
    }
}

Java

Try it out

// File: OrderSummaryService.java

public class OrderSummaryService {

    private static final double DELIVERY_FEE       = 30.0;
    private static final double FREE_DELIVERY_ABOVE = 299.0;
    private static final double GST_RATE            = 0.05;

    // varargs — any number of food items
    public void printOrderSummary(String customerName,
                                   String restaurantName,
                                   FoodItem... items) {

        System.out.println("╔══════════════════════════════════════════╗");
        System.out.println("║         ORDER SUMMARY                   ║");
        System.out.println("╠══════════════════════════════════════════╣");
        System.out.printf("║  Customer   : %-27s║%n", customerName);
        System.out.printf("║  Restaurant : %-27s║%n", restaurantName);
        System.out.println("╠══════════════════════════════════════════╣");

        if (items.length == 0) {
            System.out.println("║  No items in order.                     ║");
            System.out.println("╚══════════════════════════════════════════╝");
            return;
        }

        double subtotal = 0;
        for (FoodItem item : items) {
            System.out.println("║" + item + "║");
            subtotal += item.getLineTotal();
        }

        double gst      = subtotal * GST_RATE;
        double delivery = subtotal >= FREE_DELIVERY_ABOVE ? 0.0 : DELIVERY_FEE;
        double total    = subtotal + gst + delivery;

        System.out.println("╠══════════════════════════════════════════╣");
        System.out.printf("║  %-25s       Rs.%7.2f║%n", "Subtotal",  subtotal);
        System.out.printf("║  %-25s       Rs.%7.2f║%n", "GST (5%)",  gst);
        System.out.printf("║  %-25s       Rs.%7.2f║%n",
                delivery == 0 ? "Delivery (FREE!)" : "Delivery", delivery);
        System.out.println("╠══════════════════════════════════════════╣");
        System.out.printf("║  %-25s       Rs.%7.2f║%n", "TOTAL", total);
        System.out.println("╚══════════════════════════════════════════╝");
    }

    // varargs overload — calculates total without printing
    public double calculateTotal(FoodItem... items) {
        double subtotal = 0;
        for (FoodItem item : items) subtotal += item.getLineTotal();
        double delivery = subtotal >= FREE_DELIVERY_ABOVE ? 0.0 : DELIVERY_FEE;
        return subtotal + (subtotal * GST_RATE) + delivery;
    }
}

Java

Try it out

// File: ZomatoOrderDemo.java

public class ZomatoOrderDemo {

    public static void main(String[] args) {

        OrderSummaryService service = new OrderSummaryService();

        // Order 1 — single item (qualifies for free delivery)
        System.out.println("=== Order 1 ===\n");
        service.printOrderSummary(
            "Priya Mehta", "Biryani House",
            new FoodItem("Chicken Biryani (Full)", 349.0, 1)
        );

        System.out.println();

        // Order 2 — multiple items
        System.out.println("=== Order 2 ===\n");
        service.printOrderSummary(
            "Rohan Sharma", "Pizza Palace",
            new FoodItem("Margherita Pizza",     199.0, 1),
            new FoodItem("Garlic Bread",          79.0, 2),
            new FoodItem("Pasta Arrabiata",       149.0, 1),
            new FoodItem("Cold Coffee",            69.0, 2)
        );

        System.out.println();

        // Order 3 — large family order
        System.out.println("=== Order 3 ===\n");
        service.printOrderSummary(
            "Sneha Kapoor", "South Indian Corner",
            new FoodItem("Masala Dosa",           89.0, 3),
            new FoodItem("Idli Sambar (4 pcs)",   69.0, 2),
            new FoodItem("Filter Coffee",          35.0, 4),
            new FoodItem("Medu Vada",              49.0, 2),
            new FoodItem("Pongal",                 79.0, 1)
        );

        // Quick total without printing
        double quickTotal = service.calculateTotal(
            new FoodItem("Veg Wrap",  129.0, 2),
            new FoodItem("Smoothie",   99.0, 1)
        );
        System.out.printf("%nQuick total for 3 items: Rs.%.2f%n", quickTotal);
    }
}

Output:
=== Order 1 ===

╔══════════════════════════════════════════╗
║         ORDER SUMMARY                   ║
╠══════════════════════════════════════════╣
║  Customer   : Priya Mehta               ║
║  Restaurant : Biryani House             ║
╠══════════════════════════════════════════╣
║  Chicken Biryani (Full)   x1  Rs. 349.00║
╠══════════════════════════════════════════╣
║  Subtotal                       Rs.349.00║
║  GST (5%)                       Rs. 17.45║
║  Delivery (FREE!)               Rs.  0.00║
╠══════════════════════════════════════════╣
║  TOTAL                          Rs.366.45║
╚══════════════════════════════════════════╝

=== Order 2 ===

╔══════════════════════════════════════════╗
║         ORDER SUMMARY                   ║
╠══════════════════════════════════════════╣
║  Customer   : Rohan Sharma              ║
║  Restaurant : Pizza Palace              ║
╠══════════════════════════════════════════╣
║  Margherita Pizza         x1  Rs. 199.00║
║  Garlic Bread             x2  Rs. 158.00║
║  Pasta Arrabiata          x1  Rs. 149.00║
║  Cold Coffee              x2  Rs. 138.00║
╠══════════════════════════════════════════╣
║  Subtotal                       Rs.644.00║
║  GST (5%)                       Rs. 32.20║
║  Delivery (FREE!)               Rs.  0.00║
╠══════════════════════════════════════════╣
║  TOTAL                          Rs.676.20║
╚══════════════════════════════════════════╝

Quick total for 3 items: Rs.397.35

The same printOrderSummary method handles one item, four items, five items, and zero items. Without varargs, Zomato's backend would need printOrderSummary(FoodItem item1), printOrderSummary(FoodItem i1, FoodItem i2), and so on — or force every caller to build a FoodItem[]. Varargs makes the call site read naturally, just like placing an order in the app.

Best Practices

Always handle the zero-argument case explicitly. When scores.length == 0 is valid input, handle it — print "no items", return 0, return an empty list. Do not assume the varargs array always has elements. Do not access arr[0] without checking arr.length > 0 first.

Use varargs when the argument count genuinely varies at the call site. If every caller always passes exactly two or three values, write two or three explicit parameters — the call site is clearer and mistakes are caught at compile time. Varargs is for genuine variability, not for avoiding the effort of typing parameter names.

Never store the varargs array reference outside the method. The JVM creates a new array for each call. Storing it and relying on it after the method returns is fragile — the caller might not expect the array to be held by anything.

Prefer explicit parameters for the first one or two required arguments. Write log(String level, String... messages) rather than log(String... args) when level is always required. The method signature communicates what is mandatory and what is optional, and the compiler enforces the mandatory part.

Common Mistakes

Mistake 1 — Accessing varargs Array Without Length Check

Java

Try it out

public static double firstValue(double... values) {
    return values[0]; // ArrayIndexOutOfBoundsException if called with no arguments
}

firstValue();       // caller passes nothing — values is empty — crash
firstValue(10.0);   // works fine

// Fix — check length first
public static double firstValue(double... values) {
    if (values.length == 0) return 0.0;
    return values[0];
}

Mistake 2 — Passing null Causes NullPointerException

Java

Try it out

public static void printAll(String... messages) {
    for (String msg : messages) {       // NullPointerException here
        System.out.println(msg);
    }
}

printAll(null); // null is assigned to messages itself — not a null element inside
// messages == null — iterating it with for-each throws NullPointerException

Exception in thread "main" java.lang.NullPointerException

When null is passed to a varargs method, Java interprets it as setting the entire array to null — not as an array containing one null element. Guard against it explicitly: if (messages == null) return; or use Objects.requireNonNull.

Mistake 3 — Ambiguous Overload With varargs

Java

Try it out

public static void show(int... nums)     { System.out.println("int varargs"); }
public static void show(Integer... nums) { System.out.println("Integer varargs"); }

show(1, 2, 3); // Compile error — ambiguous:
               // 1, 2, 3 could match int... or Integer... (autoboxing)

Compile error: reference to show is ambiguous

Defining two varargs overloads where one is the autoboxed version of the other creates an ambiguity the compiler cannot resolve. Avoid having both int... and Integer... overloads for the same method name.

Mistake 4 — Putting varargs Before Other Parameters

Java

Try it out

// Compile error — varargs must be the last parameter
public static void register(String... names, String city) { } // error

// Fix
public static void register(String city, String... names) { } // correct

Compile error: varargs parameter must be the last parameter

Interview Questions

Q1. What are varargs in Java and how do they work internally?

varargs (variable arguments) allow a method to accept any number of arguments of the same type using the ... syntax. The JVM collects the supplied arguments into an array before calling the method — inside the method, the varargs parameter behaves as a regular array. A method can have at most one varargs parameter and it must be the last parameter in the list. Callers can pass individual values, an existing array, or nothing at all.

Q2. What are the rules for using varargs in Java?

A method can have only one varargs parameter. The varargs parameter must be the last parameter in the method signature — placing it before any other parameter causes a compile error. Inside the method, the varargs parameter is a regular array and can be iterated, passed to other methods, or checked with .length. An existing array can be passed directly as a varargs argument. When null is passed, the array reference itself is null — not an array containing null.

Q3. What is the difference between varargs and an array parameter?

A varargs parameter allows the caller to pass individual values directly — method(1, 2, 3) — while an array parameter forces the caller to construct an array first — method(new int[]{1, 2, 3}). Inside the method, both are treated identically as arrays. The key practical difference is call-site readability: varargs reads naturally for variable-count inputs, while an array parameter is better when the caller always has a pre-built collection.

Q4. How does the compiler resolve overloads when a varargs method and a fixed-parameter method both match?

The compiler applies a resolution order: exact match first, then widening, then autoboxing, and varargs last. If a fixed-parameter method matches the argument types exactly, it is always preferred over the varargs version. Varargs is the last resort — used only when no fixed-parameter method matches. This is why display(5, 10) calls the display(int, int) overload rather than display(int... nums) when both exist.

Q5. What happens when you pass null to a varargs method?

Java interprets null passed to a varargs parameter as setting the entire array reference to null, not as an array containing a single null element. Iterating over the parameter with a for-each loop then throws NullPointerException because the array itself is null. To handle this safely, check if (parameter == null) return; at the top of the method, or use Objects.requireNonNull.

Q6. Where does Java use varargs in its own standard library?

The most widely used varargs in the standard library are System.out.printf(String format, Object... args) and String.format(String format, Object... args) — which accept format strings and any number of values. Arrays.asList(T... elements) creates a list from any number of elements. Collections.addAll(Collection c, T... elements) adds multiple elements to a collection. Logging frameworks like SLF4J and Log4j use log.info(String message, Object... args) for parameterised logging.

FAQs

Can varargs be used with generics?

Yes — <T> with T... is valid. public static <T> List<T> listOf(T... elements) is a generic varargs method. However, mixing generics with varargs generates an unchecked warning — "Possible heap pollution via varargs parameter" — because the JVM cannot fully verify the type of the array at runtime due to type erasure. The @SafeVarargs annotation suppresses this warning when the developer is certain no heap pollution occurs.

Is the array created for varargs a new array every time?

Yes. The JVM creates a new array for each varargs call. This means a varargs method called millions of times in a tight loop creates millions of short-lived arrays, which can increase GC pressure. In performance-critical code where the argument count is always fixed, explicit parameters avoid this overhead.

Can you use varargs with constructors?

Yes. Constructors follow the same rules as methods. public Team(String teamName, String... members) is a valid varargs constructor. It is called with new Team("Dev", "Priya", "Rohan", "Sneha") — the JVM packs the member names into a String[].

What is @SafeVarargs and when do you use it?

@SafeVarargs is an annotation on a method with a generic varargs parameter — <T>. It suppresses the "unchecked or unsafe operations" warning the compiler generates for generic varargs. You add it when you are certain the method does not perform unsafe operations on the varargs array — it does not store the array into a variable of a different generic type. Without it, the compiler warns on every call to the method.

Can printf be called with zero format arguments?

Yes — System.out.printf("No placeholders here\n") is valid. The varargs part receives an empty Object[]. The method simply prints the format string with no substitutions. This is the same behaviour as calling any other varargs method with no variable arguments.

Summary

varargs removes the friction of working with a variable number of same-type arguments. The three dots ... tell the compiler to collect whatever is passed into an array — and the calling code reads naturally without array construction boilerplate. The JVM handles all the packaging; the method handles the logic.

The rules are few and memorable: one varargs per method, always last, treated as an array inside, last resort in overload resolution. The gotchas are equally few: check .length before indexing, guard against null, avoid ambiguous autoboxed varargs overloads.

In production code, varargs appears in every logging call, every format string, every builder or collector that accepts a batch of items. Every time a fresher writes System.out.printf("Name: %s, Age: %d", name, age), they are using varargs. Understanding what happens behind that call — array creation, overload resolution, null handling — is exactly what interviewers probe.

What to Read Next

Continue Learning Methods

Next Step

Pass by Value vs Pass by Reference

See exactly what gets copied when you call a method.

→

Parameters & Return Types

Learn how methods accept input and send back output.

→

Method Overloading

Learn how one method name can work in more than one way.

→

Access Modifiers

Learn how to control who can access your code.

→

←

PreviousRecursion

NextPass by Value vs Pass by Reference

→