write me an export function to write a binary tree to a file in java, in a visually appealing way , and give an example of  how it looks for that code:import com.sun.source.tree.Tree;

import java.io.*;
import java.util.*;
class TreeNode {
    char data;
    TreeNode left, right;
    List<TreeNode> children;
    TreeNode(char data) {
        this.data = data;
        this.left = this.right = null;
        this.children = new ArrayList<>();
    }
}
public class Main {
    public static TreeNode importGeneralizedTree(String input) {
        Map<Character, ArrayList<Character>> treeMap = new HashMap<>();
        char root = 'a';

        // Step 1: Reading the file and building the tree map
        try (BufferedReader br = new BufferedReader(new FileReader(input))) {
            String line;
            while ((line = br.readLine()) != null) {
                if (line.trim().isEmpty()) continue; // Skip empty lines
                String[] parts = line.trim().split("->");
                char parent = parts[0].charAt(0);
                if (root =='a') {
                    root = parent;
                }
                ArrayList<Character> children = new ArrayList<>();
                if (parts.length > 1) {
                    for (char child : parts[1].toCharArray()) {
                        children.add(child);
                    }
                }
                treeMap.put(parent, children);
            }
        } catch (FileNotFoundException e) {
            System.err.println("The file " + input + " was not found");
            return null;
        } catch (IOException e) {
            System.err.println("An error occurred while reading the file " + input + ".");
            return null;
        }
        // Print the map
        System.out.println("Tree Map:");
        for (Map.Entry<Character, ArrayList<Character>> entry : treeMap.entrySet()) {
            System.out.print(entry.getKey() + " -> ");
            for (char child : entry.getValue()) {
                System.out.print(child + " ");
            }
            System.out.println();
        }
        Map<Character, TreeNode> nodes = new HashMap<>();
        for (Map.Entry<Character, ArrayList<Character>> entry : treeMap.entrySet()) {
            char parent = entry.getKey();
            ArrayList<Character> children = entry.getValue();

            TreeNode parentNode = nodes.computeIfAbsent(parent, TreeNode::new);
            for (char child : children) {
                TreeNode childNode = nodes.computeIfAbsent(child, TreeNode::new);
                parentNode.children.add(childNode);
            }
        }
        return nodes.get(root);
    }


       






    public static TreeNode genericToBinary(TreeNode root) {
        if (root == null || root.children.size() == 0) {
            return root;
        }
        root.right = genericToBinary(root.children.get(root.children.size() - 1));
        TreeNode curr = root.right;

        for (int i = root.children.size() - 2; i > -1; i--) {
            curr.left = genericToBinary(root.children.get(i));
            curr = curr.left;
        }
        return root;
    }
    public static TreeNode binaryToGeneric(TreeNode root) {
        if (root == null) {
            return null;
        }

        // Create the generic root node
        TreeNode genericRoot = new TreeNode(root.data);
        // Use a recursive helper function to handle the conversion
        convertNode(root, genericRoot, null);
        return genericRoot;
    }
    //extended method for the previous one ;)
    private static void convertNode(TreeNode binaryNode, TreeNode genericNode, TreeNode parentGenericNode) {
        if (binaryNode == null) {
            return;
        }if (binaryNode.left != null) {
            TreeNode leftGenericChild = new TreeNode(binaryNode.left.data);
            if (parentGenericNode != null) {
                parentGenericNode.children.add(leftGenericChild); // Add as a sibling to the parent node
            }
            convertNode(binaryNode.left, leftGenericChild, parentGenericNode);
        }if (binaryNode.right != null) {
            TreeNode rightGenericChild = new TreeNode(binaryNode.right.data);
            genericNode.children.add(rightGenericChild); // Add as a child to the current node
            convertNode(binaryNode.right, rightGenericChild, genericNode);
        }
    }

    public static void main(String[] args) throws IOException {

        TreeNode root = importGeneralizedTree("input.txt");

        TreeNode binaryTree = genericToBinary(root);
       exportToFile(binaryTree,"tree.txt");
    }
}