请用java语言帮我实现一个接口，该接口可以一个树结构的对象的每层数据都提取出来重新组装成一个树结构。

可以使用以下Java接口实现：

public interface TreeFlattener<T> {
    /**
     * 将树结构的对象每层数据都提取出来重新组装成一个树结构
     * @param root 根节点
     * @return 重新组装的树结构
     */
    TreeNode<T> flattenTree(TreeNode<T> root);
}

其中，`TreeNode` 是树节点的定义，其代码如下：

public class TreeNode<T> {
    private T val;
    private List<TreeNode<T>> children;

    public TreeNode(T val) {
        this.val = val;
        children = new ArrayList<>();
    }

    public T getVal() {
        return val;
    }

    public void setVal(T val) {
        this.val = val;
    }

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

    public void setChildren(List<TreeNode<T>> children) {
        this.children = children;
    }
}

接下来，我们可以使用以下代码实现该接口：

public class TreeFlattenerImpl<T> implements TreeFlattener<T> {
    public TreeNode<T> flattenTree(TreeNode<T> root) {
        if (root == null) {
            return null;
        }
        Queue<TreeNode<T>> queue = new LinkedList<>();
        queue.offer(root);
        TreeNode<T> newRoot = new TreeNode<>(root.getVal());
        List<TreeNode<T>> newChildren = new ArrayList<>();
        newChildren.add(newRoot);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<TreeNode<T>> levelNodes = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode<T> cur = queue.poll();
                for (TreeNode<T> child : cur.getChildren()) {
                    TreeNode<T> newNode = new TreeNode<>(child.getVal());
                    levelNodes.add(newNode);
                    queue.offer(child);
                }
            }
            if (!levelNodes.isEmpty()) {
                newChildren.forEach(node -> node.setChildren(levelNodes));
                newChildren = levelNodes;
            }
        }
        return newRoot;
    }
}

这里使用了 BFS 遍历树结构，通过队列来实现。我们从根节点开始，将其加入队列中，然后逐层遍历其子节点，并将子节点加入队列中。在每一层遍历完后，我们重新构建该层的树结构，并将其作为上一层树结构的子节点，最终返回新的根节点即可。

使用方法如下：

public static void main(String[] args) {
    TreeNode<Integer> root = new TreeNode<>(1);
    TreeNode<Integer> left = new TreeNode<>(2);
    TreeNode<Integer> right = new TreeNode<>(3);
    root.getChildren().add(left);
    root.getChildren().add(right);
    TreeNode<Integer> left1 = new TreeNode<>(4);
    TreeNode<Integer> right1 = new TreeNode<>(5);
    left.getChildren().add(left1);
    left.getChildren().add(right1);
    TreeNode<Integer> left2 = new TreeNode<>(6);
    TreeNode<Integer> right2 = new TreeNode<>(7);
    right.getChildren().add(left2);
    right.getChildren().add(right2);
    TreeFlattener<Integer> treeFlattener = new TreeFlattenerImpl<>();
    TreeNode<Integer> newRoot = treeFlattener.flattenTree(root);
}

我们可以将上面代码中的 `root` 参数替换为自己的树结构对象即可。