Find the Neighbours of a Node in a tree

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class TreeNode {
    public int value;
    public TreeNode left;
    public TreeNode right;

    public TreeNode(int val) {
        value = val;
        left = null;
        right = null;
    }
}

public class BinaryTree {
    // Check if a node with the target value exists in the binary tree
    public static boolean nodeExists(TreeNode root, int targetValue) {
        if (root == null) {
            return false;  // If the root is null, the node does not exist.
        }

        if (root.value == targetValue) {
            return true;  // If the current node's value matches the target, it exists.
        }

        // Recursively search in the left and right subtrees.
        return nodeExists(root.left, targetValue) || nodeExists(root.right, targetValue);
    }

    // Find neighbors of a node with the target value in the binary tree
    public static List<Integer> findNodeNeighbors(TreeNode root, int targetValue) {
        List<List<Integer>> ans = new ArrayList<>();  // List of lists to store levels of nodes
        List<Integer> vec = new ArrayList<>();  // List to store neighbors

        if (root == null) {
            return vec;  // If the root is null, there are no neighbors.
        }

        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);

        while (!q.isEmpty()) {
            int size = q.size();
            List<Integer> ds = new ArrayList<>();  // List to store nodes at the current level

            for (int i = 0; i < size; i++) {
                TreeNode temp = q.poll();
                ds.add(temp.value);

                if (temp.left != null) {
                    q.add(temp.left);
                }

                if (temp.right != null) {
                    q.add(temp.right);
                }
            }

            ans.add(ds);  // Store the nodes at the current level in the answer list.
        }

        for (List<Integer> it : ans) {
            if (it.contains(targetValue)) {
                vec = it;  // If the target value is found in a level, set it as the neighbors.
                return vec;
            }
        }

        return vec;  // Return the list of neighbors.
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        root.right.left = new TreeNode(6);
        root.right.right = new TreeNode(7);

        List<Integer> ans = new ArrayList<>();
        int targetValue = 4;

        if (nodeExists(root, targetValue)) {
            System.out.println("Node with value " + targetValue + " exists.");
            ans = findNodeNeighbors(root, targetValue);
        } else {
            System.out.println("Node with value " + targetValue + " does not exist.");
        }

        System.out.println("Neighbours are:");
        for (int it : ans) {
            System.out.print(it + " ");
        }
    }
}