Replacing Future<Integer> with Future<Void>

Question

I am writing an application that searches for Java files in a given directory and its subdirectories and writes all the strings from those files in reverse order to a new folder. Each directory and file is handled in a separate thread. At the moment my program works correctly, but I want to change its behavior. Right now, the program overwrites the files correctly and outputs the number of overwritten files to the console at the end. I want my program to just overwrite the files and display the line "All files overwritten" at the end. But I don't quite understand how I can change my code and replace Future (I think that's my problem). Here is part of the code from the Main class:

    ExecutorService pool = Executors.newCachedThreadPool();
    ReverseWritter reverseWritter = new ReverseWritter(dirToSearch, dirToStorePath + "//" + dirToStoreName, pool);
    Future<Integer> res = pool.submit(reverseWritter);

    try {
        System.out.println(res.get() + " files reversed");
    } catch (ExecutionException | InterruptedException e) {
        e.printStackTrace();
    }
    pool.shutdown();

Here's the method that overwrites the file:

public boolean reverseWrite(File file) {
    if (file.isFile() && file.toString().endsWith(".java")) {
            String whereTo = dirToStorePathName + "\\" + file.getName().substring(0, file.getName().indexOf(".java")) + "Reversed" + ".java";
            try ( Scanner myReader = new Scanner(file);  FileWriter myWriter = new FileWriter(whereTo);) {
                while (myReader.hasNextLine()) {
                    String data = myReader.nextLine();
                    myWriter.write(new StringBuffer(data).reverse().toString());
                    myWriter.write(System.getProperty("line.separator"));
                }
            } catch (FileNotFoundException e) {
                System.out.println("An error occurred.");
                e.printStackTrace();
                return false;
            } catch (IOException e) {
                System.out.println("An error occurred.");
                e.printStackTrace();
                return false;
            }
        }
    
    return true;
}

And this is the call method (my class implements the Callable interface):

@Override
    public Integer call() {
        int count = 0;
        try {
            File[] files = dirToSearch.listFiles();
            ArrayList<Future<Integer>> result = new ArrayList<>();

            for (File f : files) {
                if (f.isDirectory()) {
                    ReverseWritter reverseWritter = new ReverseWritter(f, dirToStorePathName, pool);
                    Future<Integer> rez = pool.submit(reverseWritter);
                    result.add(rez);
                } else if (reverseWrite(f)) {
                    count++;
                }

                for (Future<Integer> rez : result) {
                    count += rez.get();
                }

            }
        } catch (ExecutionException | InterruptedException e) {
            e.printStackTrace();
        }

        return count;
    }

Answer 1

You just need to change the class to implement Callable<Void> and remove the operations which do the counting. Change the return type of call from Integer to Void.

public class ReverseWriterCallable implements Callable<Void> {

    @Override
    public Void call() throws Exception {
        //do stuff
        //don't do the counting operations
        //when return type is Void you can only return null
        return null;
    }
}

Or implement Runnable and submit it to the executor service.

public class ReverseWriterRunnable implements Runnable {

    @Override
    public void run() {
        //do stuff
        //don't do the counting operations
    }
}

Then just don't care about the result of the Future:

try {
    res.get();
    System.out.println("All files reversed");
} catch (ExecutionException | InterruptedException e) {
    e.printStackTrace();
}
pool.shutdown();