boolean b1 = rootFolder.contains("Eminem"):

public boolean contains(List<Node<String>> childrens, String text) {
    return recurse(childrens, text);
}
 
private boolean recurse(List<Node<String>> childrens, String text) {
    return childrens.stream()
        .anyMatch(children -> children.data.equals(text) || children.children.size() > 0 && recurse(children.children, text));
}

ç

List l = new ArrayList();
        l.add("123");
        boolean b = l.contains("123");
        System.out.println("Exists:" + b);

import java.util.List;


public class Tree<T> extends Node<T> {

    public Tree(T data) {

        super(data, null);
    }

    public boolean contains(T value) {
        return recurse();
    }

    private boolean recurse(T value) {
        return childrens.stream()
                .anyMatch(children -> children.data.equals(text) || children.children.size() > 0 && recurse(children.children, text));
    }

}

boolean b1 = rootFolder.contains("Eminem");
        System.out.println(b1);

import java.util.ArrayList;

import java.util.List;


public class Node<T> {
    private T data;
    private final List<Node<T>> children = new ArrayList<>();
    private final Node<T> parent;

    
    public Node(T data, Node<T> parent) {
        this.data = data;
        this.parent = parent;
    }

    public void addChild(Node<T> node) {
        children.add(node);
    }

   
    public Node<T> addChild(T nodeData) {
    	
    	Node<T> newNode = new Node<T>( nodeData, this ); 
        children.add( newNode );
        return newNode;
    }

   
    public List<Node<T>> iterate() {
        return children;
    }

    public void remove(Node<T> node) {
        children.remove(node);
    }

    public List<Node<T>> getChildren() {
        return children;
    }

    public Node getParent() {
        return parent;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
    public boolean contains(List<Node<String>> childrens, String text) {
    return recurse(childrens, text);
}
 
private boolean recurse(List<Node<String>> childrens, String text) {
    return childrens.stream()
        .anyMatch(children -> children.data.equals(text) || children.children.size() > 0 && recurse(children.children, text));
}
 
 

    
    }

----------------------------------
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import javax.swing.tree.TreeNode;

import java.util.*;

public class TreePrint {

    public static void main(String[] args) {

        Tree<String> rootFolder = new Tree<>("RootFolder");

        Node<String> video = rootFolder.addChild("Video");
        Node<String> music = rootFolder.addChild("Music");
        Node<String> picture = rootFolder.addChild("Picture");

        video.addChild("Terminator");
        video.addChild("Die Hard");
        video.addChild("Rocky");
        music.addChild("Eminem");
        Node<String> picture1 = picture.addChild("Picasso");
        picture1.addChild("P1");
        Node<String> picture2 = picture1.addChild("P2");
        picture2.addChild("P3");
        picture2.addChild("P3");

        printTree(rootFolder);
        System.out.println(rootFolder.contains(rootFolder.getChildren(), "Terminator"));
    }

    private static <T> void printTree(Node<T> node) {
        printTree(node, 0);
    }

    private static <T> void printTree(Node<T> node, int level) {
        printNode(node, level);
        if (node.getChildren() != null) {
            for (Node childNode : node.getChildren()) {
                printTree(childNode, level + 1);
            }
        }
    }

    private static <T> void printNode(Node<T> kid, int level) {

        for (int i = 0; i < level; i++) {
            System.out.print("  ");
        }

        System.out.println(kid.getData());
        
    }
}

public class Tree<T> extends Node<T> {

    public Tree(T data) {
        
        super(data, null);
    }
}

boolean b1 = rootFolder.contains("Eminem");
        System.out.println(b1);