Java Day-6

© People Strategists - Duplication is strictly prohibited -
www.peoplestrategists.com
1

Day 6
Input/Output Operations
Annotation Basics
Enum

Basic IO
• Java provides a standard way of reading from and writing to files.
• Java defines the two streams, byte stream and character stream to
read and write data .
• Java byte streams are used to perform input and output of 8-bit
bytes.
• Java character streams are used to perform input and output for 16-
bit Unicode.
• To perform the read and write operation, Java provides a set of
classes packed inside java.io package.

Basic IO
• Java provides a set classes inside the java.io package to perfrom I/O
operations.
• The hierarchy of classes in java.io package:
java.lang.Object
java.io.InputStream java.io.BufferedInputStream
java.io.OutputStream java.io.BufferedOutputStream
java.io.Reader java.io.BufferedReader
java.io.Writer java.io.BufferedWriter

InputStream Class
• The InputStream class is used for reading byte streams.
• The hierarchy of InputStream class:
java.io.InputStream
java.io.FileInputStream
java.io.FilterInputStream
java.ioBufferedInputStream
java.io.DataInputStream

InputStream Class (Contd.)
• The following table list the methods in InputStream class:
Return Type Method Name Description
int available() Returns an estimate of the number of bytes that can
be read
void close() Closes the input stream and releases any system
resources associated with the stream.
int read() Reads the next byte of data from the input stream.
int read(byte[] b) Reads some number of bytes from the input stream
and stores them into the buffer array b.
int read(byte[] b, int off, int
len)
Reads up to len bytes of data from the input stream
into an array of bytes.
long skip(long n) Skips over and discards n bytes of data from this
input stream.

OutputStream Class
• The OutputStream class is used for writing byte stream.
• The hierarchy of OutputStream class:
java.io.OutputStream
java.io.FileOutputStream
java.io.FilterOutputStream
java.ioBufferedOutputStream
java.io.DataOutputStream

OutputStream Class (Contd.)
• The following table list the methods in OutputStream class:
int flush() Flushes this output stream and forces any
buffered output bytes to be written out.
int writ(byte[] b) Writes b.length bytes from the specified byte
array to this output stream.
int write(byte[] b, int off,
int len)
Writes len bytes from the specified byte array
starting at offset off to this output stream.
long Write(int b) Writes the specified byte to this output stream.

Reader Class
• The Reader class is used for reading character streams.
• The hierarchy of Reader class:
java.io.Reader
java.io.InputStreamReader java.io.FileReader
java.ioBufferedReader

Reader Class (Contd.)
• The following table list the methods in Reader class:
int read() Reads a single character.
int read(char[] b) Reads characters into an array.
int read(char[] b, int off, int
len)
Reads characters into a portion of an array.
int read(CharBuffer target) Attempts to read characters into the specified
character buffer.
long skip(long n) Skips over and discards n bytes of data from this
input stream.

Writer Class
• The Writer class is used for writing character streams.
• The hierarchy of Writer class:
java.io.Writer
java.io.InputStreamWriter java.io.FileWriter
java.io.BufferedWriter
Java.io.PrintWriter

Writer Class (Contd.)
• The following table list the methods in Writer class:
close close() Closes the input stream and releases any system
int flush() Flushes this output stream and forces any
buffered output bytes to be written out.
int writ(char[] b) Writes an array of characters.
int write(char[] b, int off,
int len)
Writes a portion of an array of characters.
long Write(int b) Writes a single character.
void write(String str) Writes a string.
void write(String str, int off,
int len)
Writes a portion of a string.

File Class
• The File class is used to access files, file attributes, and file systems.
• The constructors in File class:
• File(String pathname):Creates a new File instance by converting the given
pathname string into an abstract pathname.
• File(String parent, String child) :Creates a new File instance from a parent
pathname string and a child pathname string.

File Class (Contd.)
• The following table list the methods in File class:
boolean createNewFile() Atomically creates a new, empty file named by this abstract
pathname if and only if a file with this name does not yet exist.
boolean delete() Deletes the file or directory denoted by this abstract pathname.
boolean exists() Tests whether the file or directory denoted by this abstract
pathname exists.
String getName() Returns the name of the file or directory denoted by this abstract
pathname.
boolean isFile() Tests whether the file denoted by this abstract pathname is a
normal file.
boolean isDirectory() Tests whether the file denoted by this abstract pathname is a
directory.
long length() Returns the length of the file denoted by this abstract pathname.

File Class (Contd.)
• The following table list the methods in File class:
String[] list() Returns an array of strings naming the files and directories in the
directory denoted by this abstract pathname.
boolean mkdir() Creates the directory named by this abstract pathname.
boolean renameTo(File dest) Renames the file denoted by this abstract pathname.

File Class (Contd.)
• An example code to work with File class:
import java.io.*;
public class FileClassDemo {
public static void main(String args[])throws IOException{
File f1=new File("TestFolder");
File f2=new File("TestFile.txt");
File f3=new File("D:FileTest.txt");
File f4=new File("NewFileTest.txt");
f3.createNewFile();

File Class (Contd.)
System.out.println(f2.exists());
System.out.println(f3.getName());
System.out.println(f1.isDirectory());
System.out.println(f2.isFile());
System.out.println(f2.length());
System.out.println();
f3.renameTo(f4);
System.out.println(f4.getName());
f3.delete();
}
}

Read and Write Operations
• An example to read String from console and writing back to console
using the InputStreamReader and BufferedReader classes:
import java.io.*;
class ConsoleIOStringDemo {
public static void main(String[] args) throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader input = new BufferedReader(isr);
String name,line;
System.out.println("Enter your name:");
name=input.readLine();
System.out.println("Hi!!!!!!!!!!!!!!!!!!!!!"+name);
}
}

Read and Write Operations (Contd.)
• An example read data from the console until the String quit is entered:
import java.io.*;
class ConsoleIOStringDemo {
public static void main(String[] args) throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader input = new BufferedReader(isr);
String line;
while ((line = input.readLine()) != null) {
if(line.equals("quit")){
System.exit(1);
}
else{
System.out.println(line);
}
}
}
}

• An example to read data from file and print to the console using
FileInputStream class:
import java.io.*;
public class FileInputStreamDemo {
public static void main(String args[])throws IOException{
try(FileInputStream fis = new
FileInputStream("TestFile.txt");){
int i,j=0;
while((i=fis.read())!=-1)
{
if((char)i ==' ')
{
j++;

System.out.println();
}
else {
System.out.print((char)i);
}
}
}
}
}

• An example to read data from console and write to a file using
BufferedReader and FileWriter classes:
import java.io.*;
public class ReadWriteDemo {
public static void main(String args[]) throws
IOException {
String consoleData;
try (BufferedReader br = new
BufferedReader(new InputStreamReader(System.in));
FileWriter fw = new
FileWriter("FileTest.txt");) {

while ((consoleData = br.readLine()) != null) {
fw.write(consoleData);
fw.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

• An example to read data from file and print to the console using
FileReader and BufferedReader classes:
import java.io.*;
class FileReaderDemo {
public static void main(String args[]) throws Exception {
FileReader fr = new FileReader("TestFile.txt");
BufferedReader br = new BufferedReader(fr);
String s;
while((s = br.readLine()) != null) {
System.out.println(s);
}
fr.close();
}
}

• An example to read file and write into another file using the
FileInputStream and BufferedWriter classes.
import java.io.*;
public class ReadWriteDemo {
public static void main(String st[]) throws Exception {
int i;
FileInputStream fis = new FileInputStream("TestFile.txt");
BufferedWriter bw = new BufferedWriter(new
OutputStreamWriter(new FileOutputStream("FOSFile.Txt")));
while ((i = fis.read()) != -1) {
bw.flush();
bw.write(i);
}
}
}

Serialization
• Serialization is a process in which current state of Object will be saved
in stream of bytes.
• Serialization is used when data needs to be sent over network or
stored in files.
• Classes ObjectInputStream and ObjectOutputStream are high-level
streams that contain the methods for serializing and deserializing an
object.
• The readObject() method is used to read an object.
• The writeObject() method is used write an object

Serialization (Contd.)
• An example to implement serialization:
import java.io.Serializable;
public class Employee implements Serializable{
int employeeId;
String employeeName;
String department;
public int getEmployeeId() {
return employeeId;
}
public void setEmployeeId(int employeeId) {
this.employeeId = employeeId;
}

public String getEmployeeName() {
return employeeName;
}
public void setEmployeeName(String employeeName) {
this.employeeName = employeeName;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
}

import java.io.*;
public class SerializeMain {
public static void main(String[] args) {
Employee emp = new Employee();
emp.setEmployeeId(101);
emp.setEmployeeName(“Raj");
emp.setDepartment("CS");

try
{
FileOutputStream fileOut = new
FileOutputStream("d:employee.txt");
ObjectOutputStream outStream = new
ObjectOutputStream(fileOut);
outStream.writeObject(emp);
outStream.close();
fileOut.close();
}catch(IOException i)
{
i.printStackTrace();
}
}
}

import java.io.*;
public class DeserializeMain {
public static void main(String[] args) {
Employee emp = null;
try
{
FileInputStream fileIn =new
FileInputStream("D:employee.txt");
ObjectInputStream in = new ObjectInputStream(fileIn);
emp = (Employee) in.readObject();
in.close();
fileIn.close();
}

catch(IOException i)
{
i.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println("Employee class not found");
c.printStackTrace();
return;
}
System.out.println("Deserialized Employee...");
System.out.println("Emp id: " + emp.getEmployeeId());
System.out.println("Name: " + emp.getEmployeeName());
System.out.println("Department: " + emp.getDepartment());
}
}

Annotations Basics
• Annotations are meta data that provide information about the code.
• Annotations are not a part of code.
• Annotations can be used to mark Java elements, such as package,
constructors, methods, fields, parameters and variables, within the
code.
• Annotations allows the compiler and JVM to extract the program
behavior and generate the interdependent code when required.
• An annotation is prefixed with @ symbol.

Built-in Java Annotations
• Java provides a set of built-in annotations.
• These built-in annotations can be categorized in as:
• Annotations used by the Java language
• Annotations applied to other annotation
• The annotations used by the Java language are defined inside the
java.lang package.
• The annotations applied to other annotation are defined inside the
java.lang.annotation package. These annotations are also called as
meta-annotation.
• The meta-annotations are mostly used with user-defined
annotations.

Built-in Java Annotations (Contd.)
• The commonly used annotation by Java language are:
• @Override
• @SuppressWarnings
• The commonly used annotations applied to other annotation are:
• @Retention
• @Target
• @Inherited
• @Documented

• @Override: Annotation is used to inform the compiler that the
method using the annotation is an overridden method.
• Consider the following code snippet:
class Base{
void display(){
}
}
class Sub extends Base{
@Override
void display(){
}
}

• In the preceding code, if the method using the annotation is not a overridden
method then a compilation error will be raised.
• @SuppressWarnings: Annotation is used to inform the compiler to
suppress warnings raised by the method using the annotation.
• Consider the following code:
void getData()throws IOException{
DataInputStream dis=new
DataInputStream(System.in);
String s=dis.readLine();
}

• The preceding code will raise a warning because the readLine() method is a
deprecated method. This warning can be suppressed by adding the following
statement before the method definition:
@SuppressWarnings("deprecation")
• Here, deprecation is the warning category.
• The @SuppressWarnings annotation can accept the warning
categories, deprecation and unchecked.
• To suppress multiple categories of warnings the following statement
is used:
@SuppressWarnings({"unchecked", "deprecation"})

• @Retention: Annotation is used to specify how the marked
annotation is stored. This annotation accepts one of the following
retention policy as argument:
• RetentionPolicy.SOURCE – The marked annotation is retained only in the
source level and is ignored by the compiler.
• RetentionPolicy.CLASS – The marked annotation is retained by the compiler at
compile time, but is ignored by the JVM.
• RetentionPolicy.RUNTIME – The marked annotation is retained by the JVM so
it can be used by the runtime environment.

• @Documented :Annotation is used to indicates that the annotation should
be documented.
• @Target: Annotation is used to restrict the usage of the annotation on
certain Java elements. A target annotation can accept one of the following
element types as its argument:
• ElementType.ANNOTATION_TYPE - Can be applied to an annotation type.
• ElementType.CONSTRUCTOR - Can be applied to a constructor.
• ElementType.FIELD - Can be applied to a field or property.
• ElementType.LOCAL_VARIABLE - Can be applied to a local variable.
• ElementType.METHOD - Can be applied to a method-level annotation.
• ElementType.PACKAGE - Can be applied to a package declaration.
• ElementType.PARAMETER - Can be applied to the parameters of a method.
• ElementType.TYPE - Can be applied to any element of a class.

• @Inherited: Annotation is used to indicate that the annotation
type is automatically inherited. When the user queries the
annotation type and the class has no annotation the defined type,
then the superclass is queried for the annotation type. The
@Inherited annotation is applied only to class declarations.

User-defined Annotations
• Java allows to create a user-defined annotation.
• The @interface element is used to declare an annotation.
• An example to create a user-defined annotation:
public abstract @interface DescAnnotation {
String description();
}
• An example to use the user defined annotation:
@DescAnnotation(description="AnnotationDemo Class")
public class AnnotationsDemo {
@DescAnnotation(description="Display method")
void display(){
}

User-defined Annotations (Contd.)
• The annotations can have any number of fields.
• An example to create a user-defined annotation with multiple fields:
int version();
}
• The class elements using the preceding annotation should define
both fields else an compilation error will be raised.

• An example to create a user-defined annotation with default field
value:
int version() default 1;
}
• The class elements using the preceding annotation can omit the
definition of version field.

• An example to create a user-defined annotation with @Retention:
import java.lang.annotation.*;
@Retention(RetentionPolicy.CLASS)
}
• The DescAnnotation annotation will be embedded into the generated
class file.

• An example to create a user-defined annotation with @Documented:
@Documented
}
• The DescAnnotation annotation will be included into Java documents
generated by Java document generator tools.

• An example to create a user-defined annotation with @Target:
@Target({ ElementType.FIELD, ElementType.METHOD})
}
• If the preceding annotation is used with elements other than method
or field, a compilation error will be raised.

• An example to create a user-defined annotation with @@Inherited:
@Inherited
}
• If the preceding annotation is applied to base class then this
annotation is also available to the sub class.

Enum
• An enum type is a special data type that allows to create a set of constants.
• An enum is defined using the enum keyword.
• An enum is created when all the possible values of a data set is know.
• An example to create a enum:
public enum PaperSize {
A0,A1,A2,A3,A4,A5,A6,A7,A8
}
• You can create a variable of enum type as shown in the following code
snippet:
PaperSize ps=PaperSize.A4;

Enum (Contd.)
• An enum can be defined inside or outside the class.
• The enum defined outside class can use only public access modifier.
However, the enum declared inside the class can use all the four
access modifier.
• An enum can declare variables and define constructors and methods.
• An example to define enum with variables, constructor, and methods:
public enum PaperSize {
A0(841,1189),A1(594,841),A2(420,594),A3(
297,420),A4(210,297),A5(148,210),A6(105,148),A7(74,105
),A8(52,74);

Enum (Contd.)
int dim1,dim2;
public int getDim1() {
return dim1;
}
public void setDim1(int dim1) {
this.dim1 = dim1;
}
public int getDim2() {
return dim2;
}
public void setDim2(int dim2) {
this.dim2 = dim2;
}
PaperSize(int dim1,int dim2){
this.dim1=dim1;
this.dim2=dim2;
}
}

Enum (Contd.)
public class EnumTest {
public static void main(String args[]){
PaperSize ps=PaperSize.A4;
System.out.println(ps.getDim1());
ps.setDim1(211);
}
}

Enum (Contd.)
• The preceding code output will be:
210
297
211

Summary
• You have learnt that:
• Java defines the two streams, byte stream and character stream to read and
write data .
• Java byte streams are used to perform input and output of 8-bit bytes.
• Java character streams are used to perform input and output for 16-bit
Unicode.
• To perform the read and write operation, Java provides a set of classes packed
inside java.io package.
• Java provides a set classes inside the java.io package to perfrom I/O
operations.
• Serialization is a process in which current state of Object will be saved in
stream of bytes.

Summary
• Annotations are meta data that provide information about the code.
• Annotations are not a part of code.
• Annotations can be used to mark Java elements, such as package,
constructors, methods, fields, parameters and variables, within the code.
• Annotations allows the compiler and JVM to extract the program behavior
and generate the interdependent code when required.
• An annotation is prefixed with @ symbol.
• Java provided a set of built-in annotations.
• An enum type is a special data type that allows to create a set of constants.
• An enum can declare variables and define constructors and methods.

Java Day-6

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Java Day-6 (20)

More from People Strategists (12)

Recently uploaded (20)

Java Day-6