// Java.io.InputStream is an abstract class
// Could not initialize InputStream object directly, through class InputStream.
// Initialize InputStream object should be through its subclasses ..
 
InputStream fileStream =new FileInputStream("C:/test.txt");
 
// Input stream from the keyboard ..
InputStream is = System.in;

// Java.io.OutputStream is an abstract class
// Could not initialize OutputStream object directly, through class OutputStream.
// Initialize OutputStream object should be through its subclasses ..
 
// Stream write to file.
OutputStream os=new FileOutputStream("D:/outData.txt");
 
// Stream write to console.
OutputStream w=System.out;

// Java.io.OutputStream is an abstract class
// Could not initialize OutputStream object directly, through class OutputStream.
// Initialize OutputStream object should be through its subclasses ..
 
// Stream write to file.
OutputStream os=new FileOutputStream("D:/outData.txt");
 
// Stream write to console.
OutputStream w=System.out;

package org.wikitechy.tutorial.javaio.stream;
 
import java.io.FileInputStream;
import java.io.InputStream;
 
public class HelloInputStream {
 
    public static void main(String[] args) {
        try {
        
            // Create InputStream object from subclass.
            // This is Stream read file.
            InputStream is = new FileInputStream("data.txt");
 
            int i = -1;
            
            // Read the turn of bytes in the stream.
            // Each time the 8-bit read, convert it to int.
            // Read the value of -1 means the end of the stream.
            while ((i = is.read()) != -1) {
                System.out.println(i + "  " + (char) i);
            }
            is.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
}

package org.wikitechy.tutorial.javaio.stream;
 
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
 
public class HelloOutputStream {
 
   public static void main(String[] args) {
       try {
           File dir = new File("C:/Test");
 
           // Create directories if not exists
           dir.mkdirs();
 
           // Create output Stream write data to file.
           OutputStream w = new FileOutputStream(
                   "C:/Test/test_outputStream.txt");
            
           // Create array of bytes, write it to stream.
           byte[] by = new byte[] { 'H', 'e', 'l', 'l', 'o' };
 
           // write turn the bytes into the stream
           for (int i = 0; i < by.length; i++) {
               byte b = by[i];
 
               // Write 1 byte.
               w.write(b);
           }
           // Close the output stream, finish write file.
           w.close();
       } catch (Exception e) {
           e.printStackTrace();
       }
   }
}

package org.wikitechy.tutorial.javaio.stream;
 
import java.io.FileInputStream;
import java.io.InputStream;
 
public class InputStreamExample2 {
 
    public static void main(String[] args) {
        try {
 
            // Create input stream, read a file.
            InputStream in = new FileInputStream("data.txt");
 
            // A temporary array to store data each reading
            byte[] temp = new byte[10];
            int i = -1;
 
            
            // Reads some number of bytes from the input stream
            // and stores them into the buffer array 'temp'.
            // Return the number of bytes actually read.
            // return -1 if end of stream.
            while ((i = in.read(temp)) != -1) {
 
                // Create String from bytes
                String s = new String(temp, 0, i);
                System.out.println(s);
            }
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package org.wikitechy.tutorial.javaio.stream;
 
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
 
public class OutputStreamExample2 {
 
    public static void main(String[] args) {
        try {
            File dir = new File("C:/Test");
 
            // Create directories if not exists.
            dir.mkdirs();            
             
            // Create output Stream to write file.
            OutputStream os = new FileOutputStream("C:/Test/test_writerOutputStream.txt");
             
            // Create array of bytes, write bytes into the file above.
            byte[] by = new byte[] { 'H', 'e', 'l', 'l', 'o', ' ', 31, 34, 92 };
            byte[] by2 = new byte[] { 'H', 'e', 'l', 'l', 'o', ' ', 'b', 'o',
                    'y' };
             
            // Write all of bytes in array into Stream.
            os.write(by);
             
            // Flush data in memory to file.
            os.flush();
             
            // Continue write the 2nd byte array to the stream
            os.write(by2);
             
            // Close the output stream, finish write file.
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// return the current contents of this output stream, as a byte array.
  - byte[] toByteArray();
 
// String decoded from the buffer's contents.
  - String toString() ;
 
// return the number of valid bytes in this output stream.
  - int size();

package org.wikitechy.tutorial.javaio.bytestream;
 
import java.io.ByteArrayInputStream;
import java.io.IOException;
 
public class ByteArrayInputStreamExample {
 
    public static void main(String args[]) throws IOException {
 
        // Byte Array.
        byte[] bytes = new byte[] { 'H', 'e', 'l', 'l', 'o', ' ', 'I', 'O' };
 
        // Using ByteArrayInputStream to read bytes array.
        ByteArrayInputStream bInput = new ByteArrayInputStream(bytes);
 
        System.out.println("Converting characters to Upper case ");
        int c = 0;
 
        // Read the turn of bytes in the stream.
        // Cursor will move from the beginning to the end of the array array.
        // Every time you read a byte pointer will move one step to the end.        
        while ((c = bInput.read()) != -1) {
            char ch = (char) c;
            ch = Character.toUpperCase(ch);
            System.out.println(ch);
        }
 
        // Check whether this stream supports mark or not
        boolean markSupport = bInput.markSupported();
 
        System.out.println("Mark Support? " + markSupport);
        
        // Move the cursor to the default location
        // In this example, it will move to position 0 ..        
        bInput.reset();
 
        char ch = (char) bInput.read();
        System.out.println(ch);
 
         // Read next byte
        ch = (char) bInput.read();
        System.out.println(ch);
 
        System.out.println("Skip 4");
  
        // Skip 4 bytes
        bInput.skip(4);
        ch = (char) bInput.read();
        System.out.println(ch);
 
    }
 
}

package org.wikitechy.tutorial.javaio.bytestream;
 
import java.io.ByteArrayOutputStream;
import java.io.IOException;
 
public class ByteArrayOutputStreamExample {
 
    public static void main(String args[]) throws IOException {
 
 
        // Create ByteArrayOutputStream object.
        // Object contains within it an array of bytes.
        // Array with size 12 elements.
        // If the number of elements to write to stream more than 12, the array will be replaced by
        // new array has more elements, and copy the elements of old array into.        
        ByteArrayOutputStream bOutput = new ByteArrayOutputStream(12);
 
        String s = "Hello ByteArrayOutputStream";
 
        for (int i = 0; i < s.length(); i++) {
 
            char ch = s.charAt(i);
 
            if (ch != 'a' && ch != 'e') {
                bOutput.write(ch);
            }
        }
 
        // Returns the current size of the buffer.
        int size = bOutput.size();
        System.out.println("Size = " + size);
 
        byte[] bytes = bOutput.toByteArray();
 
        String ss = new String(bytes);
 
        System.out.println("New String = " + ss);
    }
}

package org.wikitechy.tutorial.javaio.objstream;
 
import java.io.Serializable;
 
public class Student implements Serializable {
 
   private static final long serialVersionUID = -5074534753977873204L;
 
   private String firstName;
 
   private String lastName;
 
   public Student(String firstName, String lastName) {
       this.firstName = firstName;
       this.lastName = lastName;
   }
 
   public String getFirstName() {
       return firstName;
   }
 
   public void setFirstName(String firstName) {
       this.firstName = firstName;
   }
 
   public String getLastName() {
       return lastName;
   }
 
   public void setLastName(String lastName) {
       this.lastName = lastName;
   }
 
}

package org.wikitechy.tutorial.javaio.objstream;
 
import java.io.Serializable;
 
public class Pupil implements Serializable {
  
   private static final long serialVersionUID = -8501383434011302991L;
    
   private String fullName;
 
   public Pupil(String fullName)  {
       this.fullName= fullName;
   }
    
   public String getFullName() {
       return fullName;
   }
 
   public void setFullName(String fullName) {
       this.fullName = fullName;
   }
 
}

package org.wikitechy.tutorial.javaio.objstream;
 
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Date;
 
public class ObjectOutputStreamExample {
 
    public static void main(String[] args) throws IOException {
        File dir = new File("C:/Test");
 
        // Create directories if not exists.
        dir.mkdirs();
 
 
        // Create stream write to file.
        FileOutputStream fos = new FileOutputStream(
                "C:/Test/testObjectStream.txt");
 
        
        // Create ObjectOutputStream object wrap 'fos'.
        // Data written to this stream will be pushed to 'fos'.
        ObjectOutputStream oos = new ObjectOutputStream(fos);
         
         
        // Write String to Stream.
        oos.writeUTF("This is student, pupil profiles");
     
   
        // Note: Write Serializable object only.
        // Write an Object to stream.
        oos.writeObject(new Date());
 
        Student student1 = new Student("Thanh", "Phan");
        Student student2 = new Student("Ngan", "Tran");
        Pupil pupil1 = new Pupil("Nguyen Van Ba");
 
        oos.writeObject(student1);
        oos.writeObject(pupil1);
        oos.writeObject(student2);
 
        oos.close();
        System.out.println("Write successful");
    }
 
}

package org.wikitechy.tutorial.javaio.objstream;
 
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Date;
 
public class ObjectInputStreamExample {
 
    public static void main(String[] args) throws IOException,
            ClassNotFoundException {
 
        // Create stream to read file.
        FileInputStream fis = new FileInputStream(
                "C:/Test/testObjectStream.txt");
 
        // Create ObjectInputStream object wrap 'fis'.
        ObjectInputStream ois = new ObjectInputStream(fis);
 
        // Read String.
        String s = ois.readUTF();
 
        System.out.println(s);
 
        // Read Object.
        Date date = (Date) ois.readObject();
        System.out.println("Date = " + date);
 
        Student student1 = (Student) ois.readObject();
 
        System.out.println("Student " + student1.getFirstName());
 
        Pupil pupil = (Pupil) ois.readObject();
 
        System.out.println("Pupil " + pupil.getFullName());
 
        Student student2 = (Student) ois.readObject();
 
        System.out.println("Student " + student2.getFirstName());
 
        ois.close();
    }
}