Chapters
What is a buffer?
A buffer is a temporary storage of data. A buffer can help improve the efficiency of a data transfer. For example, when we read data from a file, sometimes, transferring of data is faster than receiving the data and vice-versa. Without a buffer, our program may experience slow down or interruption due to varying rates of tranferring and receiving data. By using buffer, we can minimize these slow down or interruption. A buffer acts as a placeholder of data between two or more entities. In this way, data transfer happens in the buffer instead of direct data transfer between entities.
Buffer size can vary based on a task our program is doing. In the example above, I use 1024 bytes of 1kb(in binary) because it's one of the standard buffer sizes and it's suitable for transferring small files. Though, you can increase the buffer size if you want to. If you're doing a complex task regarding data transfer or transferring very large files, you may wanna do some testing and analyze the most suitable buffer size that your program can take advantage of.
FileReader and FileWriter
FileReader reads text from a file and
FileWriter writes text to a file. They use specified charset to decode and encode. Otherwise, they may use the default charset if a charset is not specified.
import java.io.File;
import java.io.IOException;
import java.io.FileReader;
import java.io.FileWriter;
public class SampleClass{
public static void main(String[] args)
throws IOException{
File source = new File("C:\\test\\readTest.txt");
File target = new File("C:\\test\\writeTest.txt");
try(FileReader fr = new FileReader(source);
FileWriter fw = new FileWriter(target)){
int num = 0;
while((num = fr.read()) != -1)
fw.write((char)num + "\r\n");
}
System.out.println("Done!");
}
}
CharArrayReader and CharArrayWriter
CharArrayReader is used for reading characters from a char array type whereas
CharArrayWriter is used for writing characters to a char array type.
import java.io.IOException;
import java.io.CharArrayReader;
import java.io.CharArrayWriter;
public class SampleClass{
public static void main(String[] args)
throws IOException{
char[] input = {'a','b','c','d'};
char[] output = null;
CharArrayReader car = null;
CharArrayWriter caw = null;
try{
car = new CharArrayReader(input);
caw = new CharArrayWriter();
int num = 0;
System.out.println("Input");
while((num = car.read()) != -1){
System.out.print((char)num);
caw.write(num + 1);
}
System.out.println();
System.out.println("Output");
System.out.println(caw.toString());
}
catch(Exception e){
e.printStackTrace();
}
finally{
if(car != null)
car.close();
if(caw != null)
caw.close();
}
}
}
Result
Input
abcd
Output
bcde
BufferedReader and BufferedWriter
BufferedReader reads characters from another stream whereas
BufferedWriterwrites bytes to another stream. They have internal buffers and the buffer sizes can be adjusted. The default size(8192 or 8kb) may be used if the buffers sizes are not specified. Wrapping character-based streams with this buffered streams increases the efficiency of read/write operations.
Streams like InputStreamReader, OutputStreamWriter, FileReader and FileWriter benefit from these character-based buffered streams. These character-based streams may hog our system resources. Wrapping them around character-based buffered streams will make them operate efficiently.
import java.io.File;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
public class SampleClass{
public static void main(String[] args)
throws IOException{
File source = new File("C:\\test\\readTest.txt");
File target = new File("C:\\test\\writeTest.txt");
try(BufferedReader reader = new BufferedReader(
new FileReader(source));
BufferedWriter writer = new BufferedWriter(
new FileWriter(target))){
String str = "";
//readLine() is a bufferedReader's method that
//reads a line of text.
while((str = reader.readLine()) != null){
//write the data to the other text file
writer.write(str);
//create newline
writer.newLine();
}
System.out.println("Done!");
}
}
}
PrintStream and PrintWriter
PrintStream and
PrintWriter add new functionalities to other output streams. For byte-based output streams, use PrintStream. For character-based output streams, use PrintWriter.
This example demonstrates PrintStream.
import java.io.File;
import java.io.IOException;
import java.io.CharArrayReader;
import java.io.FileOutputStream;
import java.io.PrintStream;
public class SampleClass{
public static void main(String[] args)
throws IOException{
File target = new File("C:\\test\\writeTest.txt");
char[] characters = {'!','a','~','c','i'};
try(CharArrayReader car =
new CharArrayReader(characters);
PrintStream ps =
new PrintStream(
new FileOutputStream(target),
true,
"UTF-16")){
int num = 0;
while((num = car.read()) != -1)
ps.println(num);
}
System.out.println("Done!");
}
}
This example demonstrates PrintWriter.
import java.io.File;
import java.io.IOException;
import java.io.CharArrayReader;
import java.io.FileWriter;
import java.io.PrintWriter;
public class SampleClass{
public static void main(String[] args)
throws IOException{
File target = new File("C:\\test\\writeTest.txt");
char[] characters = {'!','a','~','c','i'};
try(CharArrayReader car =
new CharArrayReader(characters);
PrintWriter ps =
new PrintWriter(
new FileWriter(target),
true)){
int num = 0;
while((num = car.read()) != -1)
ps.println((char)num);
}
System.out.println("Done!");
}
}
PipedReader and PipedWriter
PipedReader and
PipedWriter are the character-based stream versions of PipedInputStream and PipedOutputStream.
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
public class SampleClass{
public static void main(String[] args)
throws IOException{
PipedWriter pw = new PipedWriter();
PipedReader pr = new PipedReader(pw);
Thread t1 = new Thread(() -> {
try{
for(int i = 0; i < 5; i++){
pw.write(97 + i);
Thread.sleep(50);
}
pw.close();
}
catch(Exception e){
e.printStackTrace();
}
});
Thread t2 = new Thread(() -> {
try{
int num = 0;
while((num = pr.read()) != -1){
System.out.print((char)num);
System.out.print(" ");
Thread.sleep(50);
}
pr.close();
}
catch(Exception e){
e.printStackTrace();
}
});
t1.start();
t2.start();
}
}
Result
a b c d e
RandomAccessFile
Instances of
RandomAccessFile class support both reading and writing to a random access file. A random access file behaves like a large array of bytes stored in the file system. This class has file pointer. This pointer points to an index of the array of bytes in the file system. The pointer starts at the beginning of the array and move past the bytes read until an EOF(End Of File) has been reached.
Instantiating a RandomAccessFile requires a mode that determines the operation of the instance. These are the modes that we can apply:
- "r" - Open for reading only. Invoking any of the write methods of the resulting object will cause an IOException to be thrown.
- "rw" - Open for reading and writing. If the file does not already exist then an attempt will be made to create it.
- "rws" - Open for reading and writing, as with "rw", and also require that every update to the file's content or metadata be written synchronously to the underlying storage device.
- "rwd" - Open for reading and writing, as with "rw", and also require that every update to the file's content be written synchronously to the underlying storage device.
My explanation here is simplified. Check
RandomAccessFile for more information.
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Random;
public class SampleClass{
public static void main(String[] args)
throws IOException{
File file = new File("C:\\test\\fileTest.txt");
try(RandomAccessFile raf =
new RandomAccessFile(file,"rw")){
//In a simple text file,
//file length(in bytes) corresponds to the
//number of characters in that file
long ln = raf.length();
System.out.println("File length: " + ln);
char[] vowels = {'a','e','i','o','u'};
Random rand = new Random();
//reading and writing random bytes from the file
for(int i = 0; i < 5; i++){
raf.seek(rand.nextInt((int)ln));
System.out.println((char)raf.read() + " at index: "
+ " " + (raf.getFilePointer()-1));
//after a call to read() or write(), file pointer
//will past the index where a byte is read/written.
//To point the file pointer back to the previous
//index we need to move it back by one step.
//Thus, there's -1
//in this expression: raf.getFilePointer()-1
raf.seek(raf.getFilePointer()-1);
char replacement = vowels[rand.nextInt(vowels.length)];
raf.write(replacement);
System.out.println("Replaced by: " + replacement);
System.out.println();
}
}
}
}
seek() method repositions the file pointer at the specified index. getFilePointer() returns the index where the file pointer is pointing. The example above replaces any characters in the file with vowels.
Create Dummy File Using RandomAccessFile
We can create a dummy file. The dummy file that we're going to create is a file that has gibberish bytes in it.
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
public class SampleClass{
public static void main(String[] args)
throws IOException{
File file = new File("C:\\test\\dummy.dum");
//In binary
//1024 bytes = 1 kilobyte
//1024 kilobytes = 1 megabyte
//In decimal
//1000 bytes = 1 kilobyte
//1000 kilobytes = 1 megabyte
//Windows uses the binary size
//I'm not sure if there are operating
//systems that use the decimal size
long dummySize = 1024L * (1024L * 4L);
try(RandomAccessFile raf =
new RandomAccessFile(file,"rw")){
//This method sets the total length
//of the file that we're going to
//create. Undefined bytes are added
//in the process
raf.setLength(dummySize);
}
System.out.println("dummy file created!");
}
}
StringReader and StringWriter
StringReader is used to read from a String object and
StringWriter is used to write to a String object.
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
public class SampleClass{
public static void main(String[] args)
throws IOException{
String input = "I am a String!";
String output = null;
StringReader reader = new StringReader(input);
StringWriter writer = new StringWriter();
try{
int num = 0;
//read/write string input
while((num = reader.read()) != -1)
writer.write(num);
//get the written strings written
//to the writer
output = writer.toString();
}
finally{
reader.close();
writer.close();
}
System.out.println("Input: " + input);
System.out.println("Output: " + output);
}
}
Result
Input: I am a String!
Output: I am a String!
Console
Console class can access any character-based console device, if any, associated with the current Java virtual machine. This class provides a functionality to read password that is encrypted on the console screen.
import java.io.Console;
public class SampleClass{
public static void main(String[] args){
//System.console) returns the
//console associated with the
//jvm
Console c = System.console();
if(c != null){
char[] pass = null;
System.out.println("Console Test!");
System.out.println();
System.out.print("Enter name: ");
String name = c.readLine();
System.out.println("name: " + name);
System.out.println();
System.out.print("Enter password");
if((pass = c.readPassword())
!= null){
StringBuilder sb =
new StringBuilder(String.valueOf(pass));
//java documentation recommends
//manually removing characters
//in the array where the inputted
//sensitive data is stored to
//minimize the lifetime of the
//sensitive data
java.util.Arrays.fill(pass, ' ');
System.out.print("Password: ");
System.out.println(sb.toString());
//delete the characters in sb
//StringBuilder after you're done
//using it to minimize the lifetime
//of the sensitive data
sb.setLength(0);
}
}
}
}
StreamTokenizer
The
StreamTokenizer class takes an input stream and parses it into "tokens", allowing the tokens to be read one at a time. The parsing process is controlled by a table and a number of flags that can be set to various states. The stream tokenizer can recognize identifiers, numbers, quoted strings, and various comment styles.
These fields are important for us to understand.
- nval - If the current token is a number, this field contains the value of that number.
- sval - If the current token is a word token, this field contains a string giving the characters of the word token.
- TT_EOF - A constant indicating that the end of the stream has been read.
- TT_EOL - A constant indicating that the end of the line has been read.
- TT_NUMBER - A constant indicating that a number token has been read.
- TT_WORD - A constant indicating that a word token has been read.
- ttype - After a call to the nextToken method, this field contains the type of the token just read.
This example demonstrate StreamTokenizer and the usage of the fields above.
import java.io.IOException;
import java.io.StreamTokenizer;
import java.io.FileReader;
public class SampleClass{
public static void main(String[] args)
throws IOException{
try(FileReader reader =
new FileReader("C:\\test\\test.txt")){
StreamTokenizer tokenizer =
new StreamTokenizer(reader);
int currToken = tokenizer.nextToken();
//if the current token is equal to TT_EOF
//then our program reaches the end of stream
//no characters are available to be read
//anymore.
while(currToken != StreamTokenizer.TT_EOF){
//After nextToken() is invoked, ttype will
//hold a value that determines the type
//of the token that we got from the
//invocation of nextToken()
if(tokenizer.ttype == StreamTokenizer.TT_NUMBER){
//nval field holds the number value of the
//current token
System.out.println("number: " + tokenizer.nval);
}
else if(tokenizer.ttype == StreamTokenizer.TT_WORD){
//sval field holds the string value of the
//current token if the curren token is
//considered as a word
System.out.println("word: " + tokenizer.sval);
}
else{
//if ttype is not a number or a word then,
//current token is just an ordinary character
System.out.println("character: " +
(char)currToken);
}
currToken = tokenizer.nextToken();
}
}
}
}
Content of test.txt
This is a t3st!
3 Two 1 Zero
Result
word: This
word: is
word: a
word: t3st
character: !
number: 3.0
word: Two
number: 1.0
word: Zero
Now, change the content of test.txt to this
"This" is a t3st!
And the result would be
character: "
word: is
word: a
word: t3st
character: !
Where's the word "This"? you might ask. Streamtokenizer considers words that are wrapped around quotes(single or double) as String. To get that "This" word, change this code snippet
else if(tokenizer.ttype == StreamTokenizer.TT_WORD){
//sval field holds the string value of the
//current token if the curren token is
//considered as a word
System.out.println("word: " + tokenizer.sval);
}
To this
else if(tokenizer.ttype == StreamTokenizer.TT_WORD ||
tokenizer.ttype == '\'' ||
tokenizer.ttype == '"'){
//sval field holds the string value of the
//current token if the curren token is
//considered as a word
System.out.println("word: " + tokenizer.sval);
}
And the result would be
word: This
word: is
word: a
word: t3st
character: !
Not all characters are considered as "ordinary" characters by the StreamTokenizer. To make StreamTokenizer recognize those characters, we need to manually specify them as ordinary characters by using the
ordinaryChar() method. You can call this method after instantiating a StreamTokenizer object.
Example
StreamTokenizer tokenizer = new StreamTokenizer(reader);
tokenizer.ordinaryChar('/');
In addition, an instance has four flags. These flags indicate:
- Whether line terminators are to be returned as tokens or treated as white space that merely separates tokens.
- Whether C-style comments are to be recognized and skipped.
- Whether C++-style comments are to be recognized and skipped.
- Whether the characters of identifiers are converted to lowercase.
StreamTokenizer recognizes C++ and C comment style. StreamTokenizer skips those comments if it sees one. For example, when tokenizer recognizes the "\\" or the C++ comment style, tokenizer will skip text past "\\" until our program moves on to the next line. when tokenizer recognizes the "/* */" or the C comment style, tokenizer will skip all the characters within "/* */".
By default, tokenizer ignores those comments. Though, we can enable flags to make tokenizer recognize C++ and C comments by calling the
slashSlashComments() for C++ comment style and
slashStarComments() for C comment style.
Invoke
lowerCaseMode() method to enable/disable a flag that determines whether or not word token are automatically lowercased. Call
eolIsSignificant() method to enable/disable a flag that determines whether or not ends of line are treated as tokens.
