How to create a Java String from the contents of a file

Question

I've been using this idiom for some time now. And it seems to be the most wide spread at least in the sites I've visited.

Does anyone have a better/different way to read a file into a string in Java.

Thanks

 private String readFile( String file ) throws IOException {
    BufferedReader reader = new BufferedReader( new FileReader (file));
    String line  = null;
    StringBuilder stringBuilder = new StringBuilder();
    String ls = System.getProperty("line.separator");
    while( ( line = reader.readLine() ) != null ) {
        stringBuilder.append( line );
        stringBuilder.append( ls );
    }
    return stringBuilder.toString();
 }

Answer 1

Better? I don't know. Different? Sure. Instead of reading line by line, you can read char by char, with an InputStream instead of a Reader.

Answer 2

You could try:

FileInputStream input = new FileInputStream(filePath);

byte[] fileData = new byte[input.available()];

input.read(fileData);
input.close();

return new String(fileData, "UTF-8");

I'm not sure what problems might occur with the bytes and character sets etc, but it works for me.

Answer 3

Commons IOUtils:

http://commons.apache.org/io/api-1.4/index.html?org/apache/commons/io/IOUtils.html

public static String readFileToString(File file)
                           throws IOException

Reads the contents of a file into a String using the default encoding for the VM. The file is always closed.

Parameters:
    file - the file to read, must not be null 
Returns:
    the file contents, never null 
Throws:
    IOException - in case of an I/O error
Since:
    Commons IO 1.3.1

Edit by Oscar Reyes

I've found the code used ( indirectly ) by that class:

IOUtils.java under Apache Licence 2.0

    public static long copyLarge(InputStream input, OutputStream output)
           throws IOException {
       byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
       long count = 0;
       int n = 0;
       while (-1 != (n = input.read(buffer))) {
           output.write(buffer, 0, n);
           count += n;
       }
       return count;
   }

Very similar to the one use by Ritche_W

Answer 4

Java attempts to be extremely general and flexible in all it does. As a result, something which is relatively simple in a scripting language (your code would be replaced with "open(file).read()" in python) is a lot more complicated. There doesn't seem to be any shorter way of doing it, except using an external library (like Willi aus Rohr mentioned). Your options:

• Use an external library.
• Copy this code into all your projects.
• Create your own mini-library which contains functions you use often.

Your best bet is probably the 2nd one, as it has the least dependencies.

Answer 5

In general, you should specify the character encoding to use when converting the bytes of a file to text. There are some special cases when you just want to use the platform default, but they are rare, and you should be able to explicitly justify why this is okay.

Anyway, here's an efficient way to it:

private static String readFile(String path) throws IOException {
  FileInputStream stream = new FileInputStream(new File(path));
  try {
    FileChannel fc = stream.getChannel();
    MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
    /* Instead of using default, pass in a decoder. */
    return Charset.defaultCharset().decode(bb).toString();
  }
  finally {
    stream.close();
  }
}

Answer 6

If you're looking for an alternative that doesn't involve a 3rd party library (e.g. commons IO), you can use the Scanner class

private String readFile(String pathname) throws IOException {
    StringBuilder stringBuilder = new StringBuilder();
    Scanner scanner = new Scanner(new File(pathname));

    try {
        while(scanner.hasNextLine()) {        
            stringBuilder.append(scanner.nextLine() + "\n");
        }
    } finally {
        scanner.close();
    }
    return stringBuilder.toString();
}

Answer 7

That code will normalize line breaks, which may or may not be what you really want to do.

Here's an alternative which doesn't do that, and which is (IMO) simpler to understand than the NIO code (although it still uses java.nio.charset.Charset):

public static String readFile(String file, String csName)
            throws IOException {
    Charset cs = Charset.forName(csName);
    return readFile(file, cs);
}

public static String readFile(String file, Charset cs)
            throws IOException {
    // No real need to close the BufferedReader/InputStreamReader
    // as they're only wrapping the stream
    FileInputStream stream = new FileInputStream(file);
    try {
        Reader reader = new BufferedReader(new InputStreamReader(stream, cs));
        StringBuilder builder = new StringBuilder();
        char[] buffer = new char[8192];
        int read;
        while ((read = reader.read(buffer, 0, buffer.length)) > 0) {
            builder.append(buffer, 0, read);
        }
        return builder.toString();
    } finally {
        // Potential issue here: if this throws an IOException,
        // it will mask any others. Normally I'd use a utility
        // method which would log exceptions and swallow them
        stream.close();
    }        
}

Answer 8

There is a variation on the same theme that uses a for loop, instead of a while loop, to limit the scope of the line variable. Whether it's "better" is a matter of personal taste.

for(String line = reader.readLine(); line != null; line = reader.readLine()) {
    stringBuilder.append(line);
    stringBuilder.append(ls);
}

Answer 9

public static String slurp (final File file)
throws IOException {
    StringBuilder result = new StringBuilder();

    try {
        BufferedReader reader = new BufferedReader(new FileReader(file));

        char[] buf = new char[1024];

        int r = 0;

        while ((r = reader.read(buf)) != -1) {
            result.append(buf, 0, r);
        }
    }
    finally {
        reader.close();
    }

    return result.toString();
}

Answer 10

Guava has a method similar to the one from Commons IOUtils that Willi aus Rohr mentioned:

import com.google.common.base.Charsets;
import com.google.common.io.Files;

// ...

String text = Files.toString(new File(path), Charsets.UTF_8);

EDIT by Oscar Reyes

This is the ( simplified ) underlying code on the cited library:

InputStream in = new FileInputStream(file);
byte[] b  = new byte[file. length()];
int len = b.length;
int total = 0;

while (total < len) {
  int result = in.read(b, total, len - total);
  if (result == -1) {
    break;
  }
  total += result;
}

return new String( b , Charsets.UTF_8 );

Answer 11

To read a File as binary and convert at the end

public static String readFileAsString(String filePath) throws IOException {
    DataInputStream dis = new DataInputStream(new FileInputStream(filePath));
    try {
        long len = new File(filePath).length();
        if (len > Integer.MAX_VALUE) throw new IOException("File "+filePath+" too large, was "+len+" bytes.");
        byte[] bytes = new byte[(int) len];
        dis.readFully(bytes);
        return new String(bytes, "UTF-8");
    } finally {
        dis.close();
    }
}