How to read and write files in Java 8

This tutorial presents the different options available to read and write files in Java .

Reading files

Using  FileInputStream and BufferedReader

Use this method when you want to read text from a character input stream. Buffering characters provides efficiency of the reading process.

File file = new File("myFile.zip");
try {
  FileInputStream fis = new FileInputStream(file);
  BufferedReader br = new BufferedReader(new InputStreamReader(fis));
  String line;
  while((line=br.readLine())!=null){
    System.out.println(line);
  }
  br.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when reading the file
  e.printStackTrace();
}

 

Using FileReader and BufferedReader

This example is similar the previous one, except the fact that we build the BufferedReader from a FileReader.

Use this option when you have to read character based content. You cannot specify the encoding charset for this method and it will use the platform encoding.

File file = new File("myFile.txt");
try {
  BufferedReader br = new BufferedReader(new FileReader(file));
  String line;
  while((line=br.readLine())!=null){
    System.out.println(line);
  }
  br.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when reading the file
  e.printStackTrace();
}

 

Using Files.newBufferedReader() in Java 7 and above

This example is similar to the first one (Using FileInputStreamAND BufferedReader) .  It uses the java.nio package and the try-with-resources exception management structure. It works starting from java 7.

The necessary imports

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

The code

Path path = Paths.get("c:/tmp/myfile.csv");
Charset charset = Charset.forName("UTF-8");
try (BufferedReader reader = Files.newBufferedReader(path, charset)) {
  String line = null;
  while ((line = reader.readLine()) != null) {
    System.out.println(line);
  }
} catch (IOException e) {
  e.printStackTrace();
}

 

Using Lambda expression in Java 8

One of the benefits of Lambda Expression is the reduction of the number of lines of code. In this example, we will read and print the content of a file in one line using Lambda Expressions and java.nio.file.Files class :

Files.lines(new File("c:/myfile.txt").toPath()).forEach(System.out::println);

(for simplicity we didn’t include the exception management for the IOException exception)

Writing files

Using FileOutputStream

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos));
  bw.write("Write somthing to the file ...");
  bw.newLine();
  bw.close();
} catch (FileNotFoundException e){
  // File was not found
  e.printStackTrace();
} catch (IOException e) {
  // Problem when writing to the file
  e.printStackTrace();
}

 

Using FileWriter

You better use FileWriter or PrintWriter if you plan to write some character based content or a text file.

try {
  FileWriter fw = new FileWriter("myOutFile.txt");
  fw.write("Example of content");
  fw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

 

Using PrintWriter

Similar to FileWriter but with some specifities. Here is the Oracle’s PrintWriter definition:

Prints formatted representations of objects to a text-output stream. This class implements all of the print methods found in PrintStream. It does not contain methods for writing raw bytes, for which a program should use unencoded byte streams.

try {
  PrintWriter pw = new PrintWriter("myOutFile.txt");
  pw.write("Example of content");
  pw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

 

Using OutputStreamWriter

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  OutputStreamWriter osw = new OutputStreamWriter(fos);
  osw.write("Soe content ...");
  osw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

 

log4j.properties example

The following example will show how redirect log outpout to Console, a file and both.

This configuration should be writen in log4j.properties file.

 

write the log in the console

# Logger options
log4j.rootLogger=INFO, stdout

# Write the log to the standard output
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

 

write the log in a file

# Logger options
log4j.rootLogger=INFO, file
log4j.appender.file=org.apache.log4j.RollingFileAppender

# Write the log to a file
log4j.appender.file.File=/var/logs/log.log
log4j.appender.file.MaxFileSize=50MB
log4j.appender.file.MaxBackupIndex=10
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

 

write the log in both console and a file

# Logger options
log4j.rootLogger=INFO, file, stdout
log4j.appender.file=org.apache.log4j.RollingFileAppender

# Write the log to the standard output
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

# Write the log to a file
log4j.appender.file.File=/var/logs/log.log
log4j.appender.file.MaxFileSize=50MB
log4j.appender.file.MaxBackupIndex=10
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

 

How to read and write Properties file in java 8

In Java, properties files are used to store data and configuration. This tutorial will show you how to store and read properties files in Java 8.

Using InputStream

Write to properties file

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Properties;

public class PropertiesFileSample {
 
 final private static String PROPERTIES_FILE_PATH="config.properties";

 public static void main(String[] args) {
  
  Properties properties = new Properties();
  
  // using java 8 try-with-resources structure,
  // so the output stream will be closed automatically
  try(OutputStream outputStream = new FileOutputStream(PROPERTIES_FILE_PATH)){
   
   // set some values
   properties.setProperty("username", "sampleusername");
   properties.setProperty("url", "tutoref.com");
   
   // store the values
   properties.store(outputStream, null);
   
  } catch (IOException e) {
   e.printStackTrace();
  } 
 }

}

The result will look like this :

#Sat Jul 08 23:55:53 EDT 2017
url=tutoref.com
username=sampleusername

 

Read from a properties file

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class PropertiesFileSample {
 
 final private static String PROPERTIES_FILE_PATH="config.properties";

 public static void main(String[] args) {
 
  Properties properties = new Properties();
 
  // using java 8 try-with-resources structure
  // so the input stream will be closed automatically
  try(InputStream inputStream = new FileInputStream(PROPERTIES_FILE_PATH)){
 
  // read a value
  String url = properties.getProperty("url");
 
  // display the value
  System.out.println(url);
 
 } catch (IOException e) {
  e.printStackTrace();
 } 
 }

}

 

Load properties from classpath

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class PropertiesFileSample {
 
 final private static String PROPERTIES_FILE_PATH="config.properties";

 public static void main(String[] args) {
  
  Properties properties = new Properties();
  
  // using java 8 try-with-resources structure
  // so the input stream will be closed automatically
  try(
    InputStream inputStream=
    PropertiesFileSample.class.getResourceAsStream(PROPERTIES_FILE_PATH)
    ){
   
   // load the properties
   properties.load(inputStream);
   
   // read a value
   String url = properties.getProperty("url");
   
   // display the value
   System.out.println(url);
   
  } catch (IOException e) {
   e.printStackTrace();
  } 
 }

}

 

If you want to load the properties file from a non-static method, you should use the following:

InputStream is = getClass().getClassLoader().getResourceAsStream(PROPERTIES_FILE_PATH);