How to convert an array to a list in Java

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

public class Main {
    public static void main(String[] args) {
        String[] langs = {"Java", "Kotlin", "Scala"};

        // Copy the elements into a new, resizable ArrayList
        List<String> list = new ArrayList<>(Arrays.asList(langs));
        list.add("Groovy");
        list.remove("Scala");
        System.out.println(list);

        // The list owns its own copy, so the array is untouched
        System.out.println(Arrays.toString(langs));

        // Adding to a list you already have: Collections.addAll
        List<String> more = new ArrayList<>(List.of("Clojure"));
        Collections.addAll(more, langs);
        System.out.println(more);
    }
}

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] langs = {"Java", "Kotlin", "Scala"};
        List<String> view = Arrays.asList(langs);

        // A view backed by the array: writes show up on both sides
        view.set(0, "JAVA");
        langs[2] = "SCALA";
        System.out.println(view);
        System.out.println(Arrays.toString(langs));

        // It is not a java.util.ArrayList, and its size is fixed
        System.out.println(view.getClass().getName());
        try {
            view.add("Groovy");
        } catch (UnsupportedOperationException e) {
            System.out.println("add failed: " + e);
        }

        // Varargs work too, and sorting in place is allowed
        List<Integer> nums = Arrays.asList(3, 1, 2);
        Collections.sort(nums);
        System.out.println(nums);
    }
}

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

public class Main {
    public static void main(String[] args) {
        String[] langs = {"Java", "Kotlin", "Scala"};

        // Java 9+: an unmodifiable copy of the array's elements
        List<String> fixed = List.of(langs);
        langs[0] = "C#";
        System.out.println(fixed);

        try {
            fixed.set(0, "Go");
        } catch (UnsupportedOperationException e) {
            System.out.println("set failed: " + e);
        }

        // Unlike Arrays.asList, List.of rejects null elements
        String[] withNull = {"a", null, "c"};
        System.out.println(Arrays.asList(withNull));
        try {
            List.of(withNull);
        } catch (NullPointerException e) {
            System.out.println("List.of threw NullPointerException");
        }
    }
}

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        String[] tags = {"java", "go", "java", "rust", "go"};

        // LinkedHashSet drops duplicates and keeps first-seen order
        Set<String> ordered = new LinkedHashSet<>(Arrays.asList(tags));
        System.out.println(ordered);

        // TreeSet drops duplicates and sorts
        Set<String> sorted = new TreeSet<>(Arrays.asList(tags));
        System.out.println(sorted);

        // HashSet is the usual choice, but its order is unspecified
        Set<String> hashed = new HashSet<>(Arrays.asList(tags));
        System.out.println(hashed.size() + " " + hashed.contains("rust"));

        // Set.of (Java 9+) throws on duplicates instead of dropping them
        try {
            Set.of(tags);
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }
}

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

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("Java", "Kotlin", "Scala"));

        // Pass a zero-length array; toArray allocates one of the right size
        String[] a = list.toArray(new String[0]);
        System.out.println(Arrays.toString(a));

        // Java 11+: pass the array constructor instead
        String[] b = list.toArray(String[]::new);
        System.out.println(b.length + " " + b[2]);

        // From a stream, e.g. after transforming the elements
        String[] c = list.stream().map(String::toUpperCase).toArray(String[]::new);
        System.out.println(Arrays.toString(c));

        // The no-argument toArray() returns Object[], not String[]
        Object[] objects = list.toArray();
        System.out.println(objects.getClass().getSimpleName());
        try {
            String[] d = (String[]) objects;
            System.out.println(d.length);
        } catch (ClassCastException e) {
            System.out.println("cast failed: ClassCastException");
        }
    }
}

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

public class Main {
    public static void main(String[] args) {
        int[] nums = {3, 1, 4, 1, 5};

        // The trap: T is inferred as int[], so this list has ONE element
        List<int[]> wrong = Arrays.asList(nums);
        System.out.println(wrong.size());

        // Box each int into an Integer (Stream.toList() is Java 16+)
        List<Integer> boxed = Arrays.stream(nums).boxed().toList();
        System.out.println(boxed);

        // Need a resizable list? Collect into an ArrayList
        List<Integer> list = Arrays.stream(nums).boxed()
                .collect(Collectors.toCollection(ArrayList::new));
        list.add(9);
        System.out.println(list);

        // And back again: unbox each Integer into an int[]
        int[] back = list.stream().mapToInt(Integer::intValue).toArray();
        System.out.println(Arrays.toString(back));
    }
}