Varargs & Heap Pollution

// Varargs declaration
public static int sum(int... numbers) {
    int total = 0;
    for (int n : numbers) {
        total += n;
    }
    return total;
}

// All valid calls:
sum();             // empty array: int[0]
sum(1);            // int[]{1}
sum(1, 2, 3);     // int[]{1, 2, 3}
sum(new int[]{1, 2, 3}); // explicit array also works

// VALID: varargs as last parameter
public void log(Level level, String pattern, Object... args) { }

// INVALID: varargs not last
public void broken(String... names, int count) { }  // COMPILE ERROR

// INVALID: two varargs
public void broken(int... a, String... b) { }       // COMPILE ERROR

public class Overloading {
    static void print(int a, int b)   { System.out.println("fixed"); }
    static void print(int... nums)    { System.out.println("varargs"); }

    public static void main(String[] args) {
        print(1, 2);    // "fixed" — Phase 1 exact match wins
        print(1);       // "varargs" — no fixed-arity match
        print();        // "varargs" — no fixed-arity match
    }
}

static void process(int... nums)    { }
static void process(long... nums)   { }

process(1, 2);  // COMPILE ERROR: ambiguous!
// Both are Phase 3 candidates — neither is more specific

static void foo(Object... args)  { }
static void foo(Integer... args) { }

foo(1, 2);  // Integer... wins (more specific than Object...)
foo(1, "x"); // Object... wins (Integer... cannot accept String)

static void show(int... nums) {
    System.out.println("int varargs: " + Arrays.toString(nums));
}

static void show(Integer... nums) {
    System.out.println("Integer varargs: " + Arrays.toString(nums));
}

show(1, 2, 3);  // COMPILE ERROR: ambiguous!

// Fix: be explicit
show(new int[]{1, 2, 3});       // calls int... version
show(new Integer[]{1, 2, 3});   // calls Integer... version

int[] primitives = {1, 2, 3};
List<int[]> wrong = Arrays.asList(primitives);  // List of ONE element (the array itself!)
// asList(T... a) — T cannot be int, so T = int[], creating a single-element list

Integer[] boxed = {1, 2, 3};
List<Integer> correct = Arrays.asList(boxed);   // List of THREE elements

// Heap pollution via raw types
List<String> strings = new ArrayList<>();
List rawList = strings;          // unchecked assignment — warning
rawList.add(42);                 // puts Integer into List<String> — pollution!
String s = strings.get(0);       // ClassCastException! String expected, got Integer

// The compiler generates this:
@SuppressWarnings("unchecked")
static <T> void dangerous(T... elements) {
    // At runtime: T... becomes Object[]
    Object[] array = elements;           // legal! T[] IS-A Object[]
    array[0] = "sneaky string";          // pollution if T != String
    T first = elements[0];              // ClassCastException if T was Integer
}

static void faultyMethod(List<String>... stringLists) {
    // After erasure: List[] stringLists (raw array)
    Object[] array = stringLists;        // List[] IS-A Object[]

    List<Integer> intList = List.of(42);
    array[0] = intList;                  // ArrayStoreException? NO! 
    // Both are List at runtime — type erasure removes the generic info

    String s = stringLists[0].get(0);    // ClassCastException!
    // Expected String, got Integer
}

@SafeVarargs
static <T> List<T> listOf(T... elements) {
    // SAFE: only reads from elements, never writes to the array
    List<T> result = new ArrayList<>(elements.length);
    for (T element : elements) {
        result.add(element);
    }
    return result;
}

// UNSAFE: returns the varargs array directly — exposes it!
static <T> T[] toArray(T... args) {
    return args;  // DANGER: caller gets Object[] disguised as T[]
}

// This causes ClassCastException:
String[] strings = toArray("a", "b");  // Object[] cannot be cast to String[]

// java.util.Collections
@SafeVarargs
public static <T> boolean addAll(Collection<? super T> c, T... elements)

// java.util.List (Java 9+)
@SafeVarargs
static <E> List<E> of(E... elements)

// java.util.EnumSet
@SafeVarargs
public static <E extends Enum<E>> EnumSet<E> of(E first, E... rest)

// Cannot use @SafeVarargs on non-final instance method
public <T> void process(T... items) {
    @SuppressWarnings("unchecked")
    T[] localRef = items;  // suppress only here

    for (T item : localRef) {
        // safe read-only usage
        handle(item);
    }
}

// java.util.Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);  // wraps the varargs array directly!
}

// java.util.List (Java 9+)
@SafeVarargs
static <E> List<E> of(E... elements) {
    // defensive copy — does NOT retain the array
}

// List.of() overloads to avoid varargs array allocation for small sizes:
static <E> List<E> of()                           // 0 elements
static <E> List<E> of(E e1)                       // 1 element
static <E> List<E> of(E e1, E e2)                 // 2 elements
// ... up to 10 fixed-arity overloads
static <E> List<E> of(E... elements)              // 11+ elements (varargs)

// SLOW: varargs allocates array every call
public static int sum(int... numbers) { /* ... */ }

// Calling sum(a, b) creates new int[]{a, b} each time

// FAST: fixed-arity overloads for common cases
public static int sum(int a, int b) { return a + b; }
public static int sum(int a, int b, int c) { return a + b + c; }
public static int sum(int... numbers) { /* fallback for 4+ args */ }

// SLF4J provides fixed-arity overloads to avoid varargs:
void info(String format, Object arg);          // 1 arg — no array
void info(String format, Object arg1, Object arg2); // 2 args — no array  
void info(String format, Object... arguments); // 3+ args — varargs fallback

public static String format(String pattern, Object... args) {
    // Safe: only reads args, never writes to array
    StringBuilder sb = new StringBuilder();
    int argIndex = 0;
    for (int i = 0; i < pattern.length(); i++) {
        if (pattern.charAt(i) == '{' && i + 1 < pattern.length() 
            && pattern.charAt(i + 1) == '}') {
            sb.append(argIndex < args.length ? args[argIndex++] : "{}");
            i++; // skip '}'
        } else {
            sb.append(pattern.charAt(i));
        }
    }
    return sb.toString();
}

format("Hello {}, you have {} messages", "Alice", 5);
// → "Hello Alice, you have 5 messages"

@SafeVarargs
public static <T> Set<T> setOf(T... elements) {
    Set<T> set = new LinkedHashSet<>(elements.length * 4 / 3 + 1);
    Collections.addAll(set, elements);
    return Collections.unmodifiableSet(set);
}

@SafeVarargs
public static <T> Stream<T> concat(Stream<T>... streams) {
    return Arrays.stream(streams).flatMap(Function.identity());
}

public static void requireNonNull(String message, Object... values) {
    for (int i = 0; i < values.length; i++) {
        if (values[i] == null) {
            throw new NullPointerException(message + " [index=" + i + "]");
        }
    }
}

requireNonNull("Constructor args", name, email, address);

@SafeVarargs
public static <E extends Enum<E>> EnumSet<E> enumSetOf(E first, E... rest) {
    EnumSet<E> set = EnumSet.of(first, rest);
    return set;
}

// ApplicationContext — load multiple config locations
ApplicationContext ctx = new ClassPathXmlApplicationContext(
    "applicationContext.xml", "services.xml", "dao.xml"  // varargs
);

// JdbcTemplate — query with varargs parameters
List<User> users = jdbcTemplate.query(
    "SELECT * FROM users WHERE age > ? AND city = ?",
    new UserRowMapper(),
    25, "NYC"  // Object... args bound to PreparedStatement
);

// Spring's Assert utility
Assert.notNull(value, "Value must not be null");
Assert.isTrue(count > 0, "Count must be positive");

// assertAll — varargs of Executable lambdas
assertAll("user validation",
    () -> assertEquals("Alice", user.getName()),
    () -> assertEquals(30, user.getAge()),
    () -> assertNotNull(user.getEmail())
);

// assertEquals with message supplier
assertEquals(expected, actual, () -> "Failed for input: " + input);

// assertThrows does NOT use varargs — single Executable
assertThrows(IllegalArgumentException.class, () -> parse("bad"));

// verify with varargs matchers
verify(service).process(any(), anyString(), anyInt());

// Stubbing methods that accept varargs
when(formatter.format(anyString(), any(Object[].class)))
    .thenReturn("mocked");

// ArgumentCaptor for varargs
@Captor ArgumentCaptor<Object[]> argsCaptor;
verify(logger).info(eq("pattern"), argsCaptor.capture());

// SAFE: iterate and collect
@SafeVarargs
static <T> List<T> immutableListOf(T... elements) {
    return List.copyOf(Arrays.asList(elements));
}

// SAFE: pass to another safe method
@SafeVarargs
static <T> Set<T> unionOf(Set<T>... sets) {
    Set<T> result = new HashSet<>();
    for (Set<T> s : sets) {
        result.addAll(s);
    }
    return result;
}

// UNSAFE: never do this!
static <T> T[] dangerous(T... args) {
    return args;  // leaks Object[] as T[] — ClassCastException
}

// UNSAFE: storing array reference
class Holder<T> {
    T[] data;
    @SafeVarargs // WRONG! This is not safe
    final void set(T... args) {
        this.data = args;  // stores array — someone else might corrupt it
    }
}

static <T> T[] toArray(T... args) {
    return args;
}

static <T> T[] duplicate(T a, T b) {
    return toArray(a, b);
}

public static void main(String[] args) {
    String[] result = duplicate("hello", "world");  // ClassCastException!
}

static <T> void addToList(List<T> list, T... elements) {
    for (T e : elements) {
        list.add(e);
    }
}

static void count(int... nums)     { System.out.println("int varargs"); }
static void count(int a, int b)    { System.out.println("fixed arity"); }

count(1, 2);

int[] arr = {1, 2, 3};
var list = Arrays.asList(arr);
System.out.println(list.size());  // 1, not 3!

List<String> a = new ArrayList<>(List.of("hello"));
List<String> b = new ArrayList<>(List.of("world"));
List<String>[] array = new List[]{a, b};  // unchecked warning

faultyMethod(array);

static void faultyMethod(List<String>... lists) {
    Object[] objs = lists;
    objs[0] = List.of(42);       // no ArrayStoreException!
    String s = lists[0].get(0);  // ClassCastException: Integer -> String
}