Java support and examples

Write a complete Java program, then step through its variables, object references and method calls. Select Java in the visualizer, paste a full example below and run it, or explore it directly on this page.

Program structure

• Submit one source file with exactly one public static void main(String[] args) entrypoint. The examples use Main; your entry class may have a different name.
• Put input data directly in your program and call the algorithm from main. Interactive input is not supported.
• Define helper classes and interfaces at the top level, alongside Main. Nested classes, including static class ListNode, are not supported.
• Use explicit import statements for supported standard-library classes. Do not add a package declaration. Maven, Gradle and external dependencies are not available.
• Java does not provide predefined ListNode, TreeNode, buildLinkedList or buildTree helpers. Define your node types and construct the links in the same source file, as shown below.

Runnable examples

Choose a tab to inspect each complete program. Use the playback controls to move through its execution.

public class Main {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        int result = a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        int[] values = {2, 4, 6};
        int total = 0;
        for (int value : values) {
            total += value;
        }
        int[][] matrix = {{1, 2}, {3, 4}};
        matrix[0][1] = total;
    }
}

public class Main {
    static int factorial(int n) {
        if (n <= 1) {
            return 1;
        }
        return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        int result = factorial(5);
    }
}

class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

public class Main {
    public static void main(String[] args) {
        ListNode head = new ListNode(10);
        head.next = new ListNode(20);
        head.next.next = new ListNode(30);
        ListNode current = head;
        int total = 0;
        while (current != null) {
            total += current.val;
            current = current.next;
        }
    }
}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val) {
        this.val = val;
    }
}

public class Main {
    static int sum(TreeNode node) {
        if (node == null) {
            return 0;
        }
        return node.val + sum(node.left) + sum(node.right);
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(4);
        root.left = new TreeNode(2);
        root.right = new TreeNode(6);
        int result = sum(root);
    }
}

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(3);
        numbers.add(5);
        numbers.set(0, 7);

        LinkedHashMap<String, Integer> scores = new LinkedHashMap<>();
        scores.put("Ada", 8);
        scores.put("Lin", 10);

        LinkedHashSet<Integer> unique = new LinkedHashSet<>();
        unique.add(3);
        unique.add(3);
        unique.add(5);
        int count = numbers.size() + scores.size() + unique.size();
    }
}

Supported values and execution

• Primitive and boxed values, strings, BigInteger, null, one-dimensional and multidimensional arrays.
• Source-defined objects and their fields, including inherited fields, aliases, shared references and cycles.
• Branches, loops, method calls, overloads, recursion, inheritance, dynamic dispatch, constructors, initialization, exceptions, finally and automatic resource closing.
• Expanded collection views for ArrayList, LinkedList, Arrays.asList, List.of, HashMap, LinkedHashMap, HashSet and LinkedHashSet. Other library objects may remain visible without expandable contents.

LinkedHashMap and LinkedHashSet preserve insertion order; do not rely on HashMap or HashSet iteration order. A source-defined subclass of a library collection displays its source fields rather than combining them with the library's private collection storage.

Current limitations

Java support covers single-threaded algorithm visualization, not every Java feature or standard-library type. Packages, nested/local/anonymous classes, records, lambdas, method references, pattern bindings, user-defined native methods, reflection, dynamic loading and launching other processes are not supported. Executing your source methods on another thread stops the run with a diagnostic.

Keep inputs small enough to inspect step by step. Execution and visualization limits still apply; if a run reaches a limit, reduce the input size. Compilation or runtime errors should be corrected at the reported source location. Printing is not required to observe variables or return values.

See the general usage guide for troubleshooting.