[+/-] : Write to file using BufferedOutputStream

This code snippet shows how to write to a file using a BufferedOuputStream. Now it should be said that if you want to write text to a file you should probably find it easier to go with a Writer class like the BufferedWriter instead.
The write method of the BufferedOuputStream takes either a byte array or an int as argument so that is why we have to call getBytes() on any String that we provide to the write method. The getBytes method of the String class returns its content in the form of a byte array.
The other overloaded variant of the write method that takes an int as an argument prints the character that has the decimal value (or ascii value if you want) that matches the parameter. So in the example below we call write with 65 as the argument, which is the same as character 'A'.

Note that the construction of a BufferedOutputStream as below will overwrite any file with the same name that already exists.

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
    
    /**
     * Prints some data to a file
     */
    public void writeToFile(String filename) {
        
        BufferedOutputStream bufferedOutput = null;
        
        try {
            
            //Construct the BufferedOutputStream object
            bufferedOutput = new BufferedOutputStream(new FileOutputStream(filename));
            
            //Start writing to the output stream
            bufferedOutput.write("Line one".getBytes());
            bufferedOutput.write("\n".getBytes()); //new line, you might want to use \r\n if you're on Windows
            bufferedOutput.write("Line two".getBytes());
            bufferedOutput.write("\n".getBytes());
            
            //prints the character that has the decimal value of 65
            bufferedOutput.write(65);
            
        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            //Close the BufferedOutputStream
            try {
                if (bufferedOutput != null) {
                    bufferedOutput.flush();
                    bufferedOutput.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        new Main().writeToFile("myFile.txt");
    }
}

If you run the code the contents of the file should look like this:

Line one
Line two
A
...
Read more

[+/-] : Read from file with BufferedInputStream

This example shows how to read the contents of a file using a BufferedInputStream. There are a couple of ways to do so, and in this example we use a byte array to store the data read. We loop through the file contents and fill out buffer up to the size of the buffer array until there are no more data left to read. It possible to read from the file one byte at a time, but to use a buffer is more efficient.

public class Main {
    
    /**
     * This method reads contents of a file and print it out
     */
    public void readFromFile(String filename) {
        
        BufferedInputStream bufferedInput = null;
        byte[] buffer = new byte[1024];
        
        try {
            
            //Construct the BufferedInputStream object
            bufferedInput = new BufferedInputStream(new FileInputStream(filename));
            
            int bytesRead = 0;
            
            //Keep reading from the file while there is any content
            //when the end of the stream has been reached, -1 is returned
            while ((bytesRead = bufferedInput.read(buffer)) != -1) {
                
                //Process the chunk of bytes read
                //in this case we just construct a String and print it out
                String chunk = new String(buffer, 0, bytesRead);
                System.out.print(chunk);
            }
            
        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            //Close the BufferedInputStream
            try {
                if (bufferedInput != null)
                    bufferedInput.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        new Main().readFromFile("myFile.txt");
    }
}

...
Read more

[+/-] : Read each line in a comma separated file into an array

In this example we read the lines of a comma separated file and split the values into an array. This is done fairly easy with the split() method, which takes a separator as an argument and returns an array of Strings.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.IOException;


public class CsvTest {

  public void readFile() {

    BufferedReader br = null;
    
    try {
      
      br = new BufferedReader(new FileReader("thefile.csv"));
      String line = null;
      
      while ((line = br.readLine()) != null) {
        
        String[] values = line.split(",");
        
        //Do necessary work with the values, here we just print them out
        for (String str : values) {
          System.out.println(str);
        }
        System.out.println();
      }
    }
    catch (FileNotFoundException ex) {
      ex.printStackTrace();
    }
    catch (IOException ex) {
      ex.printStackTrace();
    }
    finally {
      try {
        if (br != null)
          br.close();
      }
      catch (IOException ex) {
        ex.printStackTrace();
      }
    }
  }

  public static void main(String[] args) {
    CsvTest test = new CsvTest();
    test.readFile();
  }
}

...
Read more