{"title":"Variable Arguments (Varargs)","description":"","content":"Sometimes a method needs to accept a flexible number of inputs. Consider adding products to a cart. One call might add a single item, the next call might add five, and the call after that might add fifteen. Forcing the caller to wrap those products in an array every time is noisy. Varargs let you write the method once and call it with as many arguments as you want, including zero.\n\nThis lesson covers what varargs are, how they work internally, the rules around using them, and the small set of gotchas that catch beginners. The examples stick to e-commerce: adding cart items, applying product tags, summing prices.\n\n---\n\n# The Problem Varargs Solve\n\nBefore varargs existed, a method that handled an unknown number of inputs had two options. Either expose several overloads, one per argument count, or take an array. The overload approach doesn't scale, because you'd need a new method every time someone wanted to pass one more value.\n\n\n```java\npublic class CartWithoutVarargs {\n public static void addItems(String[] items) {\n for (String item : items) {\n System.out.println(\"Added: \" + item);\n }\n }\n\n public static void main(String[] args) {\n String[] singleItem = { \"Wireless Mouse\" };\n addItems(singleItem);\n\n String[] threeItems = { \"Notebook\", \"Pen\", \"Eraser\" };\n addItems(threeItems);\n }\n}\n```\n\n\nThe method works, but every caller has to build an array first. That's friction the caller didn't ask for. The same code with varargs looks like this:\n\n\n```java\npublic class CartWithVarargs {\n public static void addItems(String... items) {\n for (String item : items) {\n System.out.println(\"Added: \" + item);\n }\n }\n\n public static void main(String[] args) {\n addItems(\"Wireless Mouse\");\n addItems(\"Notebook\", \"Pen\", \"Eraser\");\n }\n}\n```\n\n\nThe caller now writes natural-looking calls. The method signature stays the same regardless of how many items get passed. That's the whole point of varargs.\n\n---\n\n# Varargs Syntax\n\nThe varargs syntax is three dots after the parameter type: `Type... name`. The three dots are part of the declaration, not part of the type. Inside the method, `name` behaves exactly like `Type[]`.\n\n\n```java\npublic class TagPrinter {\n public static void printTags(String... tags) {\n System.out.println(\"Total tags: \" + tags.length);\n for (int i = 0; i < tags.length; i++) {\n System.out.println(i + \": \" + tags[i]);\n }\n }\n\n public static void main(String[] args) {\n printTags(\"new\", \"bestseller\", \"wireless\");\n }\n}\n```\n\n\nThe `.length` field and the index access work because `tags` is an array. The dots only appear in the method declaration. You never write `String...` anywhere else, not when assigning, not when looping.\n\nA clean way to iterate a varargs parameter is the enhanced `for` loop.\n\n\n```java\npublic class CategoryList {\n public static void listCategories(String... categories) {\n for (String category : categories) {\n System.out.println(\"Category: \" + category);\n }\n }\n\n public static void main(String[] args) {\n listCategories(\"Books\", \"Electronics\", \"Toys\");\n }\n}\n```\n\n\n---\n\n# How Varargs Work Internally\n\nWhen the compiler sees a varargs parameter, it treats the method as if you had declared an array parameter. The varargs syntax is syntactic sugar. At the call site, the compiler collects all the loose arguments, wraps them into a fresh array, and passes that array to the method.\n\n\n```mermaid\nflowchart LR\n Call[\"Call site:
addItems("A", "B", "C")\"]:::cyan --> Wrap[\"Compiler builds
new String[]
{"A", "B", "C"}\"]:::orange\n Wrap --> Param[\"Method parameter
items: String[]\"]:::green\n Param --> Body[\"Method body sees
items.length == 3
items[0] == "A"\"]:::teal\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe diagram shows the lifecycle of a varargs call. The caller writes three separate arguments. The compiler bundles them into a single array. The method receives that array and uses it like any other.\n\nYou can confirm this by accessing `.length` and indexing into the parameter as if it were an array, because that's what it is.\n\n\n```java\npublic class VarargsIsArray {\n public static void inspect(int... numbers) {\n System.out.println(\"Type behaves like int[]\");\n System.out.println(\"Length: \" + numbers.length);\n if (numbers.length > 0) {\n System.out.println(\"First: \" + numbers[0]);\n System.out.println(\"Last: \" + numbers[numbers.length - 1]);\n }\n }\n\n public static void main(String[] args) {\n inspect(10, 20, 30, 40);\n }\n}\n```\n\n\nEvery varargs call allocates a brand new array on the heap. For a method called once, this is fine. For a method called in a tight loop with primitive wrappers (`Integer...`, `Double...`), the per-call allocation plus autoboxing can add measurable overhead. When you already have an array, pass it directly to avoid building a wrapper around a wrapper.\n\n---\n\n# Passing Zero, One, or Many Arguments\n\nA varargs parameter accepts any number of arguments, including zero. Zero arguments doesn't produce a `null` array. It produces an empty array with `length == 0`.\n\n\n```java\npublic class CallWithAnyCount {\n public static void applyTags(String... tags) {\n if (tags.length == 0) {\n System.out.println(\"No tags applied.\");\n return;\n }\n for (String tag : tags) {\n System.out.println(\"Tag: \" + tag);\n }\n }\n\n public static void main(String[] args) {\n applyTags();\n System.out.println(\"---\");\n applyTags(\"sale\");\n System.out.println(\"---\");\n applyTags(\"new\", \"wireless\", \"bestseller\");\n }\n}\n```\n\n\nThe first call passes nothing, and the method sees an empty array. The second passes one value, and the array has one element. The third passes three. The method body doesn't change between these cases, which is the value of varargs.\n\nDefensive code often checks `length` first, because passing zero arguments is legal even when it doesn't make sense for the operation. Calculating an average of zero prices is a divide-by-zero waiting to happen.\n\n\n```java\npublic class AverageOfPrices {\n public static double average(double... prices) {\n if (prices.length == 0) {\n return 0.0;\n }\n double sum = 0.0;\n for (double price : prices) {\n sum += price;\n }\n return sum / prices.length;\n }\n\n public static void main(String[] args) {\n System.out.println(\"No prices: \" + average());\n System.out.println(\"One price: \" + average(29.99));\n System.out.println(\"Three prices: \" + average(10.00, 20.00, 30.00));\n }\n}\n```\n\n\nThe zero-length check is the standard way to handle the \"no arguments\" case. Either return a sensible default, throw an `IllegalArgumentException`, or document that the method requires at least one value.\n\n---\n\n# Passing an Actual Array\n\nBecause the varargs parameter is an array internally, you can pass an existing array directly instead of listing the values one by one. The compiler accepts this and uses your array as the parameter.\n\n\n```java\npublic class PassAnArray {\n public static void addItems(String... items) {\n for (String item : items) {\n System.out.println(\"Added: \" + item);\n }\n }\n\n public static void main(String[] args) {\n String[] productList = { \"Notebook\", \"Pen\", \"Eraser\" };\n addItems(productList);\n }\n}\n```\n\n\nThe compiler doesn't wrap `productList` in another array. It passes the same reference through. That means changes to the array inside the method would be visible to the caller, since both sides hold the same reference.\n\n\n```java\npublic class SharedArrayReference {\n public static void overwriteFirst(String... items) {\n if (items.length > 0) {\n items[0] = \"REPLACED\";\n }\n }\n\n public static void main(String[] args) {\n String[] productList = { \"Notebook\", \"Pen\", \"Eraser\" };\n overwriteFirst(productList);\n System.out.println(\"First after call: \" + productList[0]);\n }\n}\n```\n\n\nMost varargs methods read their inputs without modifying them, so this rarely matters. When it does, copy the array inside the method before changing anything.\n\nYou cannot pass two arrays expecting them to be merged. If you write `addItems(arr1, arr2)`, the compiler treats that as a varargs call with two arguments of type `String[]`, which won't compile against a `String...` parameter. To combine arrays, merge them yourself first or use a single array argument.\n\n---\n\n# The `null` Gotcha\n\nCalling a varargs method with `null` is the classic trap. There are two different ways to spell it, and they produce very different results.\n\nIf you pass `null` directly with no cast, the compiler treats `null` as the array reference itself. The method then receives `null` for its parameter, and any access to `.length` throws.\n\n\n```java\npublic class NullAsArray {\n public static void applyTags(String... tags) {\n System.out.println(\"Length: \" + tags.length); // NullPointerException\n }\n\n public static void main(String[] args) {\n applyTags(null);\n }\n}\n```\n\n\nThe call passes a `null` reference where `String[]` is expected. The method body then tries to read `.length` on a null array, which throws `NullPointerException`.\n\nThe fix is either to defend against the case inside the method, or to call it differently. Casting `null` to `String` instead of letting it default to the array reference produces an array containing a single `null` element.\n\n\n```java\npublic class NullAsValue {\n public static void applyTags(String... tags) {\n System.out.println(\"Length: \" + tags.length);\n if (tags.length > 0) {\n System.out.println(\"First: \" + tags[0]);\n }\n }\n\n public static void main(String[] args) {\n applyTags((String) null);\n }\n}\n```\n\n\nThe cast tells the compiler \"this `null` is a `String` element, not the whole array\". The compiler then builds a one-element array containing that `null`. The method sees `length == 1` and `tags[0] == null`.\n\nFor a defensive method, check the parameter for `null` before touching it.\n\n\n```java\npublic class SafeTagPrinter {\n public static void applyTags(String... tags) {\n if (tags == null || tags.length == 0) {\n System.out.println(\"No tags applied.\");\n return;\n }\n for (String tag : tags) {\n System.out.println(\"Tag: \" + (tag == null ? \"\" : tag));\n }\n }\n\n public static void main(String[] args) {\n applyTags((String[]) null);\n System.out.println(\"---\");\n applyTags(\"new\", null, \"wireless\");\n }\n}\n```\n\n\nTwo checks cover the realistic cases. The outer `tags == null` guards against the caller passing `null` for the whole array. The inner `tag == null` guards against any single element being `null`.\n\n---\n\n# Mixing Varargs with Regular Parameters\n\nA method can have regular parameters and one varargs parameter, but the varargs has to come last. The compiler needs that rule so it can tell which arguments are which. Without it, a call with mixed types would be ambiguous.\n\n\n```java\npublic class ApplyTags {\n public static void applyTags(String productName, String... tags) {\n System.out.println(\"Product: \" + productName);\n if (tags.length == 0) {\n System.out.println(\"(no tags)\");\n return;\n }\n for (String tag : tags) {\n System.out.println(\" - \" + tag);\n }\n }\n\n public static void main(String[] args) {\n applyTags(\"Wireless Mouse\", \"new\", \"bestseller\");\n System.out.println(\"---\");\n applyTags(\"USB Cable\");\n }\n}\n```\n\n\nThe first argument always binds to `productName`. Everything after it gets packed into the `tags` array. The second call passes no tags, so the method handles the empty case.\n\nTrying to put varargs anywhere but last is a compile error.\n\n\n```java\npublic class InvalidVarargsPosition {\n // public static void bad(String... tags, String productName) { } // compile error\n}\n```\n\n\nThe compiler rejects this with `varargs parameter must be the last parameter`. There's no way around it. If you need flexible inputs followed by a fixed value, reorder the signature so the fixed value comes first.\n\nA method can have at most one varargs parameter. You can't write `void log(String... tags, int... codes)`, even hypothetically, because the rule above already prevents two trailing varargs.\n\n---\n\n# Varargs and Overload Resolution\n\nWhen two overloads could match a call, the compiler prefers the more specific one. Varargs versions are considered the least specific because they accept the widest range of inputs. A method that takes exact parameter types wins over a varargs method when both could handle the call.\n\n\n```java\npublic class OverloadWithVarargs {\n public static void calculateTotal(double price) {\n System.out.println(\"Single price: \" + price);\n }\n\n public static void calculateTotal(double... prices) {\n double total = 0;\n for (double p : prices) {\n total += p;\n }\n System.out.println(\"Many prices total: \" + total);\n }\n\n public static void main(String[] args) {\n calculateTotal(29.99);\n calculateTotal(29.99, 9.99);\n calculateTotal();\n }\n}\n```\n\n\nThe single call with one argument hits the fixed-parameter overload because it matches exactly. The compiler doesn't go looking for the varargs version when a precise match exists. The two-argument and zero-argument calls only fit the varargs overload, so that's what runs.\n\nThis is the reason a `String.format(\"hello\")` call with no extra arguments still works. The varargs parameter receives an empty array.\n\n---\n\n# Real Examples from the Standard Library\n\nVarargs aren't an exotic feature. Several common methods in the JDK use them, and you've likely already called varargs methods without noticing. Here are four to recognize.\n\n`String.format` and `System.out.printf` both take a format string followed by a varargs `Object...` for the values that get substituted into the placeholders.\n\n\n```java\npublic class FormatExample {\n public static void main(String[] args) {\n String customerName = \"Alice\";\n int orderCount = 3;\n double total = 89.97;\n\n String summary = String.format(\n \"%s placed %d orders totalling $%.2f\",\n customerName, orderCount, total\n );\n System.out.println(summary);\n\n System.out.printf(\"Customer: %s | Orders: %d%n\", customerName, orderCount);\n }\n}\n```\n\n\nThe format string is a regular `String` parameter. Everything after it is the varargs. This is why you can pass two values, three, or none.\n\n`Arrays.asList` returns a fixed-size list backed by the arguments you pass in.\n\n\n```java\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class AsListExample {\n public static void main(String[] args) {\n List categories = Arrays.asList(\"Books\", \"Electronics\", \"Toys\");\n System.out.println(\"Categories: \" + categories);\n System.out.println(\"Size: \" + categories.size());\n }\n}\n```\n\n\n`List.of`, added in Java 9, is similar but returns an immutable list. It also uses varargs for the convenient case of small lists.\n\n\n```java\nimport java.util.List;\n\npublic class ListOfExample {\n public static void main(String[] args) {\n List wishlist = List.of(\"Wireless Mouse\", \"USB Cable\", \"Notebook\");\n System.out.println(wishlist);\n }\n}\n```\n\n\nRecognizing these signatures helps when you read JDK source or hover documentation. The three dots after a type tell you the call-site convention without you having to test it.\n\n---\n\n# Writing a Method That Uses Varargs Well\n\nA method that searches a product list by category illustrates how all the pieces fit together. The method takes a category list as varargs, prints a label, and reports how many categories were searched.\n\n\n```java\npublic class CategorySearch {\n public static void searchByCategory(String... categories) {\n if (categories.length == 0) {\n System.out.println(\"No categories provided. Showing all products.\");\n return;\n }\n System.out.println(\"Searching \" + categories.length + \" categories:\");\n for (String category : categories) {\n System.out.println(\" - \" + category);\n }\n }\n\n public static void main(String[] args) {\n searchByCategory();\n System.out.println();\n searchByCategory(\"Electronics\");\n System.out.println();\n searchByCategory(\"Books\", \"Toys\", \"Electronics\");\n System.out.println();\n\n String[] saved = { \"Clothing\", \"Shoes\" };\n searchByCategory(saved);\n }\n}\n```\n\n\nThe method handles four call styles with one signature: zero arguments, one argument, several arguments, and a pre-built array. Each path through `main` exercises a different style, and the method body doesn't have to know or care which one was used.","pageType":"java"}

Variable Arguments (Varargs)

Get Premium