Basic I/O Operations In Java

INPUT / OUTPUT STREAMS

• Streams represent the flow of data and that data can be in any format
• Like (byte, text, primitive data type etc)
• To write data into a destination, the output stream is used
• To read the data, the input stream is used
DIFFERENT FORMATS OF READING AND WRITING:

Types of data

1. Binary data

2. Text data

3. Formatted data

4. Buffering .
INPUT / OUTPUT STREAMS

1. Binary data:

▪ data will be read in byte format : 0’s and 1’s

▪ “FileInputStream” and “FileOutputStream “classes are used for reading the content as a byte

▪ In this way, for every byte, the compiler will send a request to the OS
INPUT / OUTPUT STREAMS

⮚ more test.txt
This is a text file.
It contains two lines.

⮚ hexdump test.txt
0000000 54 68 69 73 20 69 73 20 61 20 74 65 78 74 20 66
0000010 69 6c 65 2e 0a 49 74 20 63 6f 6e 74 61 69 6e 73
0000020 20 74 77 6f 20 6c 69 6e 65 73 2e 0a
000002c
>
 INPUT / OUTPUT STREAMS

import java.io.FileInputStream; catch (FileNotFoundException e) {

import java.io.FileNotFoundException; e.printStackTrace();
import java.io.FileOutputStream; }
import java.io.IOException; catch (IOException e) {
public class ByteStreamsDemo {
public static void main(String[] args) throws IOException { e.printStackTrace();
FileInputStream fin =null; }
FileOutputStream fout =null; finally {
try { if(fin!=null) {
fin=new FileInputStream("input.txt"); fin.close();
fout=new FileOutputStream("out.txt"); }if(fout!=null) {
int c; fout.close();
while((c=fin.read() )!= -1) }
{ }
fout.write(c); }
} }
}
INPUT / OUTPUT STREAMS

2. Text data:

▪ Text data consists of Java strings or character streams.

▪ A string is a fixed finite sequence of characters and is an instance of java.lang.String

▪ the DataInputStream or DataOutputStream, classes are used to read and write

▪ the content as primitive data type such us boolean, char, byte, short, int, long, float, double

and String.
INPUT / OUTPUT STREAMS

public class DataInputOutputStreamDemo { catch (IOException e) {

public static void main(String[] args) { e.printStackTrace();
File file = new File("read.bin"); }finally {
FileOutputStream fos = null; try {
DataOutputStream dos = null; if(fos!=null){
try { fos.close();
fos=new FileOutputStream(file); }
dos=new DataOutputStream(fos); if(dos!=null){
dos.writeInt(50244); dos.close();
dos.writeDouble(400.253); }
dos.writeChar('d'); } catch (Exception e) {
dos.flush(); e.printStackTrace();
} }
}
INPUT / OUTPUT STREAMS

/*Reading operation */ finally {

try {
FileInputStream fis = null; if(fis!=null){
DataInputStream dis = null; fis.close();
try { }
fis = new FileInputStream(file); if(dis!=null){
dis = new DataInputStream(fis); dis.close();
System.out.println(dis.readInt()); }
System.out.println(dis.readDouble()); } catch (Exception e) {
System.out.println(dis.readChar()); e.printStackTrace();
} }
catch (IOException e) { }
e.printStackTrace(); }
} }
INPUT / OUTPUT STREAMS

3. Formatted data:
▪ to translate raw text or binary data to a desired form
● This may involve specialized hardware, for example to play an audio stream or to
display an image.
● A highly versatile and configurable class for parsing input text in a known format
is java.util.Scanner.
● On the output side, java.io.PrintStream provides extensive text formatting
capabilities.
INPUT / OUTPUT STREAMS

4. Buffering:
▪ Access to the underlying input stream may be inefficient if the source is remote
or the medium is slow.
▪ To improve performance, input streams and readers are often wrapped in a
BufferedInputStream or BufferedReader to provide buffering.
InputStream in = new BufferedInputStream(new FileInputStream(fileName));

Reader in = new BufferedReader(new FileReader(fileName));

INPUT / OUTPUT STREAMS

public class BufferedStreamDemo { } finally {

public static void main(String[] args) throws IOException{ if (input != null) {
BufferedReader input = null; input.close();
BufferedWriter output = null; }
try { if (output != null) {
input = new BufferedReader(new FileReader("input.txt")); output.close();
output = new BufferedWriter(new FileWriter("out1.txt")); }
int c; }
while ((c = input.read()) != -1) { }
output.write(c); }
}
INPUT SOURCES

● Most input data is available in the form of an InputStream.

Command line arguments:

▪ user runs your program from the console, they can supply arguments on the
command line

▪ These arguments are then available to your program in the String[] array
parameter of the main method.
INPUT SOURCES

Example
⮚ if you type in a console window
java MyProgram a b "c d" e

⮚ and the main method of MyProgram looks like

public static void main(String[] args) {

for (String s : args) {
System.out.println(s);
} then you will see the
} output:

a
b
c d
e
INPUT SOURCES

In Eclipse, you can supply the command line arguments under the Arguments tab in
the run configuration.
CONSOLE (USER INPUT)

● input typed in at the keyboard by the user while the program is running
● There is a built-in InputStream just for this purpose, called System.in
● Often this is wrapped in an instance of Scanner to read the input one line at a
time
Scanner sysin = new Scanner(System.in);
System.out.print("Please type something: ");
String s = sysin.nextLine();
System.out.println("You typed: " + s);

Please type something: hi there

You typed: hi there
FILE SYSTEM

● You can create an InputStream from a binary file or a Reader from a text file by
supplying the path name to the constructor.

InputStream in = new FileInputStream("/Users/kozen/Documents/myBinaryFile");

Reader in = new FileReader("/Users/kozen/Documents/myTextFile.txt");
RESOURCE FILES

● A resource is a file with some data that your program uses internally
Example: background image, audio clip, or text
● Java looks for resources using your program’s Class Loader
● resources must be on the class path so that the ClassLoader can find them.

way to access a resource file as an InputStream:

InputStream in = ClassLoader.getSystemResourceAsStream("myResource");
OUTPUT DESTINATIONS

Console:

● To write text to the console, use

System.out.print to print a string without a trailing newline,
System.out.println to print a string with a trailing newline,
System.out.format to print a formatted string.
EXAMPLES: Reading the command line arguments

Printing out user input

void displayUserInput() {
while (true) {
System.out.print("Please type something: ");
String s = sysin.nextLine();
if (s.equals("bye")) break;
System.out.println("You typed: " + s);
}
System.out.println("bye");
}
Sample run (user input is in green):

Please type something: hi there

You typed: hi there
Please type something: Java is cool!
You typed: Java is cool!
Please type something: bye
bye
EXAMPLES :

● Printing out a text file

void displayTextFile(String fileName) {
try (InputStream in =
new BufferedInputStream(new
FileInputStream(fileName));
Scanner scanner = new Scanner(in)) {
while (scanner.hasNextLine()) {
System.out.println(scanner.nextLine());
}
} catch (IOException e) {
System.out.println("File could not be read");
}
}
EXAMPLES :

void displayTextFile2(String fileName) {

char[] buffer = new char[256];
try (Reader in = new BufferedReader(new FileReader(fileName))) {
for (int n = in.read(buffer); n != -1; n = in.read(buffer)) {
System.out.print(new String(buffer, 0, n));
}
} catch (IOException e) {
System.out.println("File could not be read");
}
}
 EXAMPLES :

● Copying a text file

long copyTextFile(File inFile, File outFile) { try (Reader in = new BufferedReader(new
if (!inFile.exists()) { FileReader(inFile));
System.out.print("Input file does not exist"); Writer out = new BufferedWriter(new
return -1; FileWriter(outFile))) {
} return in.transferTo(out);
if (outFile.exists()) { } catch (IOException e) {
System.out.print("Output file exists; System.out.println("File was not
overwrite [yes/no]? "); copied");
if (!sysin.nextLine().equals("yes"))return-1; return -1;
} }
}
EXAMPLES :

● Copying a binary file

void copyBinaryFile(File inFile, File outFile) {
if (!inFile.exists()) {
System.out.print("Input file does not exist");
return;
}
if (outFile.exists()) {
System.out.print("Output file exists; overwrite [yes/no]? ");
if (!sysin.nextLine().equals("yes")) return;
}
EXAMPLES :

● Copying a binary file

try (InputStream in =
new BufferedInputStream(new FileInputStream(inFile));
OutputStream out =
new BufferedOutputStream(new FileOutputStream(outFile))) {
for (int c = in.read(); c != -1; c = in.read()) {
out.write(c);
}
} catch (IOException e) {
System.out.println("File was not copied");
}
}
EXAMPLES :

● Printing out a text resource file

void displayTextResourceFile(String fileName) {
InputStream in = ClassLoader.getSystemResourceAsStream(fileName);
Scanner scanner = new Scanner(in);
while (scanner.hasNextLine()) {
System.out.println(scanner.nextLine());
}
scanner.close();
}