Java 将void返回到文本文件的打印方法

我想问这个问题，但在我当前的驱动程序中，我已经使用迭代器成功地将树的前序打印到文本文件中。我不知道如何打印递归方法，因为我不能将它们放入println语句中，因为它们是void方法。我知道我应该让这个方法把writer作为一个参数，但不知道怎么做（driver的最后两个println语句）。感谢您的帮助

司机：

package driver;

import java.io.*;
import java.util.*;

public class Driver {
    
    private static Scanner file;
    static PrintWriter outputFilePrinter;
    static Scanner inputFileScanner;

    public static void main(String[] args) throws FileNotFoundException {
       
        Scanner inFile; //Declaring scanner obj
        PrintWriter printWriter = new PrintWriter("output.txt"); //Text file where results are printed to
        inFile = new Scanner(new File("input.txt")); //Text file where student names and associated number are read from
        
        BinarySearchTreeInterface<String> aTree = new BinarySearchTree<>() {}; //Giving access to BinarySearchTree methods
      
        
        while (inFile.hasNext()) { //Scans input file
            String name = inFile.nextLine(); //Assigns contents to string obj
            aTree.add(name); //Add string to a tree
        } //End while
        
    
        Iterator<String> traverse = aTree.getPreorderIterator(); //Using iterator to print tree in an "postorder" fashion   
            while (traverse.hasNext())
        printWriter.println(traverse.next()); //Prints tree
        
        System.out.println("Postorder Recrusive: ");
        aTree.postorderTraverse();
        System.out.println("");
        System.out.println("Inorder Recursive: ");
        aTree.inorderTraverse();
     
        printWriter.close(); //Closes file
       
    } //End Main

} //End Driver

包驱动程序；
导入java.io.*；
导入java.util.*；
公务舱司机{
专用静态扫描文件；
静态PrintWriter输出文件打印机；
静态扫描仪输入文件扫描仪；
公共静态void main（字符串[]args）引发FileNotFoundException{
Scanner infle；//声明Scanner obj
PrintWriter PrintWriter=new PrintWriter（“output.txt”）；//打印结果的文本文件
infle=new Scanner（新文件（“input.txt”）；//从中读取学生姓名和相关号码的文本文件
BinarySearchTreeInterface aTree=new BinarySearchTree（）{}；//提供对BinarySearchTree方法的访问权限
而（infle.hasNext（））{//扫描输入文件
String name=infle.nextLine（）；//将内容分配给字符串obj
aTree.add（name）；//将字符串添加到树中
}//结束时
迭代器遍历=aTree.getPreorderIterator（）；//使用迭代器以“后序”方式打印树
while（traverse.hasNext（））
printWriter.println（traverse.next（））；//打印树
System.out.println（“Postorder Recurusive:”）；
aTree.postorderTraverse（）；
System.out.println（“”）；
System.out.println（“顺序递归：”）；
aTree.inorderTraverse（）；
printWriter.close（）；//关闭文件
}//末端总管
}//端驱动程序

我正在尝试打印的递归方法：

    public void inorderTraverse() {
    inorderTraverse(root);
    }

    public void inorderTraverse(BinaryNode<T> node) {
        if (node != null) {
            inorderTraverse(node.getLeftChild());
            System.out.println(node.getData());
            inorderTraverse(node.getRightChild());
        }
    }

    public void postorderTraverse() {
        postorderTraverse(root);
    }

    public void postorderTraverse(BinaryNode<T> node) {
        if (node != null) {  
        postorderTraverse(node.getLeftChild());
        postorderTraverse(node.getRightChild());
        System.out.println(node.getData());
        }
    }

orderTraverse（）中的公共void{
inorderTraverse（根）；
}
OrderTraverse中的公共void（二进制节点）{
如果（节点！=null）{
inorderTraverse（node.getLeftChild（））；
System.out.println（node.getData（））；
inorderTraverse（node.getRightChild（））；
}
}
public void postorderTraverse（）{
postorderTraverse（根）；
}
public void postorderTraverse（BinaryNode节点）{
如果（node！=null）{
postorderTraverse（node.getLeftChild（））；
postorderTraverse（node.getRightChild（））；
System.out.println（node.getData（））；
}
}

您可以将遍历代码更改为

public void inorderTraverse(PrintWriter printWriter) {
    inorderTraverse(root, printWriter);
}

public void inorderTraverse(BinaryNode<T> node, PrintWriter printWriter) {
    if (node != null) {
        inorderTraverse(node.getLeftChild(), printWriter);
        printWriter.println(node.getData());
        inorderTraverse(node.getRightChild(), printWriter);
    }
}

public void postorderTraverse(PrintWriter printWriter) {
    postorderTraverse(root, printWriter);
}

public void postorderTraverse(BinaryNode<T> node, PrintWriter printWriter) {
    if (node != null) {  
        postorderTraverse(node.getLeftChild(), printWriter);
        postorderTraverse(node.getRightChild(), printWriter);
        printWriter.println(node.getData());
    }
}

public void inorderTraverse(Consumer<T> consumer) {
    inorderTraverse(root, consumer);
}

public void inorderTraverse(BinaryNode<T> node, Consumer<T> consumer) {
    if (node != null) {
        inorderTraverse(node.getLeftChild(), consumer);
        consumer.accept(node.getData());
        inorderTraverse(node.getRightChild(), consumer);
    }
}

public void postorderTraverse(Consumer<T> consumer) {
    postorderTraverse(root, consumer);
}

public void postorderTraverse(BinaryNode<T> node, Consumer<T> consumer) {
    if (node != null) {  
        postorderTraverse(node.getLeftChild(), consumer);
        postorderTraverse(node.getRightChild(), consumer);
        consumer.accept(node.getData());
    }
}

aTree.postorderTraverse(printWriter::println);
aTree.postorderTraverse(System.out::println);