How to concatenate two lists in Java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> a = List.of("red", "green");
        List<String> b = List.of("blue", "yellow");

        // Copy the first list, then append the second
        List<String> combined = new ArrayList<>(a);
        combined.addAll(b);
        System.out.println(combined);
        System.out.println(a + " " + b);   // the inputs are untouched

        // The result is an ordinary ArrayList, so it can keep growing
        combined.add("purple");
        System.out.println(combined);

        // Pre-size it when the lists are large, to skip regrowing
        List<String> sized = new ArrayList<>(a.size() + b.size());
        sized.addAll(a);
        sized.addAll(b);
        System.out.println(sized);

        // addAll on a fixed-size or immutable list throws
        try {
            a.addAll(b);
        } catch (UnsupportedOperationException e) {
            System.out.println("List.of:       " + e);
        }
        List<String> fixed = Arrays.asList("red", "green");
        try {
            fixed.addAll(b);
        } catch (UnsupportedOperationException e) {
            System.out.println("Arrays.asList: " + e);
        }
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<Integer> a = List.of(1, 2, 3);
        List<Integer> b = List.of(4, 5, 6);

        // Java 16+: Stream.toList() returns an unmodifiable list
        List<Integer> combined = Stream.concat(a.stream(), b.stream()).toList();
        System.out.println(combined);
        try {
            combined.add(7);
        } catch (UnsupportedOperationException e) {
            System.out.println("toList() result can't be changed");
        }

        // Java 8+: Collectors.toList() returns an ArrayList today, but doesn't promise to
        List<Integer> collected = Stream.concat(a.stream(), b.stream())
                .collect(Collectors.toList());
        collected.add(7);
        System.out.println(collected);

        // Ask for the list type you need when you'll modify the result
        ArrayList<Integer> mutable = Stream.concat(a.stream(), b.stream())
                .collect(Collectors.toCollection(ArrayList::new));
        mutable.add(0, 0);
        System.out.println(mutable);

        // A stream can filter and map on the way through
        List<String> evens = Stream.concat(a.stream(), b.stream())
                .filter(n -> n % 2 == 0)
                .map(n -> "#" + n)
                .toList();
        System.out.println(evens);
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class Main {
    // Any number of lists, with one right-sized allocation
    @SafeVarargs
    static <T> List<T> concat(List<? extends T>... lists) {
        int size = 0;
        for (List<? extends T> list : lists) size += list.size();
        List<T> out = new ArrayList<>(size);
        for (List<? extends T> list : lists) out.addAll(list);
        return out;
    }

    public static void main(String[] args) {
        List<String> a = List.of("a", "b");
        List<String> b = List.of("c");
        List<String> c = List.of("d", "e");

        // Stream the lists themselves, then flatten each one into the stream
        List<String> all = Stream.of(a, b, c).flatMap(List::stream).toList();
        System.out.println(all);

        // The same call flattens a List<List<T>> of any length
        List<List<Integer>> batches = List.of(List.of(1, 2), List.of(3, 4), List.of(5, 6));
        List<Integer> flat = batches.stream().flatMap(List::stream).toList();
        System.out.println(flat);
        System.out.println(flat.stream().mapToInt(Integer::intValue).sum());

        // Without streams: a small varargs helper
        System.out.println(concat(a, b, c));

        // Nested Stream.concat works, but gets hard to read past two
        System.out.println(Stream.concat(Stream.concat(a.stream(), b.stream()), c.stream()).toList());
    }
}

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<String> a = List.of("go", "java", "rust");
        List<String> b = List.of("java", "zig", "go", "kotlin");

        // LinkedHashSet drops repeats and keeps first-seen order
        Set<String> merged = new LinkedHashSet<>(a);
        merged.addAll(b);
        System.out.println(merged);

        // Copy it back into a List if the caller expects one
        List<String> unique = new ArrayList<>(merged);
        System.out.println(unique.get(3));

        // The stream version: distinct() also keeps encounter order
        System.out.println(Stream.concat(a.stream(), b.stream()).distinct().toList());

        // TreeSet sorts while it removes the repeats
        Set<String> sorted = new TreeSet<>(a);
        sorted.addAll(b);
        System.out.println(sorted);

        // Only the items of b that a doesn't already have
        List<String> added = new ArrayList<>(b);
        added.removeAll(a);
        System.out.println(added);
    }
}

import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {
    // Arrays.copyOf keeps the first array's element type, so this works for any object array
    static <T> T[] concat(T[] first, T[] second) {
        T[] result = Arrays.copyOf(first, first.length + second.length);
        System.arraycopy(second, 0, result, first.length, second.length);
        return result;
    }

    public static void main(String[] args) {
        String[] a = {"a", "b", "c"};
        String[] b = {"d", "e"};

        // Allocate the result, then copy each array into place
        String[] both = new String[a.length + b.length];
        System.arraycopy(a, 0, both, 0, a.length);
        System.arraycopy(b, 0, both, a.length, b.length);
        System.out.println(Arrays.toString(both));

        // Arrays.copyOf + arraycopy, wrapped in a generic helper
        System.out.println(Arrays.toString(concat(a, b)));
        Integer[] boxed = concat(new Integer[] {1, 2}, new Integer[] {3});
        System.out.println(Arrays.toString(boxed));

        // Streams: one expression, and it scales to more arrays
        String[] viaStream = Stream.concat(Arrays.stream(a), Arrays.stream(b))
                .toArray(String[]::new);
        System.out.println(Arrays.toString(viaStream));
        String[] three = Stream.of(a, b, new String[] {"f"})
                .flatMap(Arrays::stream)
                .toArray(String[]::new);
        System.out.println(three.length);

        // Primitive arrays need IntStream (or LongStream, DoubleStream)
        int[] x = {1, 2, 3};
        int[] y = {4, 5};
        int[] nums = IntStream.concat(Arrays.stream(x), Arrays.stream(y)).toArray();
        System.out.println(Arrays.toString(nums));
    }
}