Question

I am reading a file to parse later on. The file is not likely to exceed an MB in size, so this is perhaps not a crucial question for me at this stage. But for best practise reasons, I’d like to know when is the optimum time to perform an operation.

Example:

Using a method I’ve pasted from http://www.dzone.com/snippets/java-read-file-string, I am reading a buffer into a string. I would now like to remove all whitespace. My method is currently this:

private String listRaw;

public boolean readList(String filePath) throws java.io.IOException {
    StringBuffer fileData = new StringBuffer(1024);
    BufferedReader reader = new BufferedReader(
            new FileReader(filePath));
    char[] buf = new char[1024];
    int numRead=0;
    while((numRead=reader.read(buf)) != -1){
        String readData = String.valueOf(buf, 0, numRead);
        fileData.append(readData);
        buf = new char[1024];
    }
    reader.close();
    listRaw = fileData.toString().replaceAll("\\s","");
    return true;
}

So, I remove all whitespace from the string at the time I store it – in it’s entirety – to a class variable.

To me, this means less processing but more memory usage. Would I be better off applying the replaceAll() operation on the readData variable as I append it to fileData for best practise reasons? Using more processing but avoiding passing superfluous whitespace around.

I imagine this has little impact for a small file like the one I am working on, but what if it’s a 200MB log file?

Is it entirely case-dependant, or is there a consensus I’d do better to follow?

---

Thanks for the input everybody. I’m sure you’ve helped to aim my mindset in the right direction for writing Java.

I’ve updated my code to take into consideration the points raised. Including the suggestion by Don Roby that at some point, I may want to keep spaces. Hopefully things read better now!

private String listRaw;

public boolean readList(String filePath) throws java.io.IOException {
    StringBuilder fileData = new StringBuilder(51200);
    BufferedReader reader = new BufferedReader(new FileReader(filePath));
    char[] buf = new char[51200];
    boolean spaced = false;
    while(reader.read(buf) != -1){
        for(int i=0;i<buf.length;i++) {
            char c = buf[i];
            if (c != '\t' && c != '\r' && c != '\n') {
                if (c == ' ') {
                    if (spaced) {
                        continue;
                    }
                    spaced = true;
                } else {
                    spaced = false;
                }

                fileData.append(c);
            }
        }
    }
    reader.close();
    listRaw = fileData.toString().trim();
    return true;
}

Answer 1

You’d better create and apply the regexp replacement only once, at the end. But you would gain much more by

• initializing the StringBuilder with a reasonable size
• avoiding the creation of a String inside the loop, and append the read characters directly to the StringBuilder
• avoiding the instantiation of a new char buffer, for nothing, at each iteration.

To avoid an unnecessary long temporary String creation, you could read char by char, and only append the char to the StringBuilder if it’s not a whitespace. In the end, the StringBuilder would contain only the good characters, and you wouldn’t need any replaceAll() call.