Hướng dẫn sử dụng luồng vào ra nhị phân trong Java

// java.io.InputStream là một class trìu tượng (abstract class)
// Không thể khởi tạo trực tiếp đối tượng InputStream thông qua class InputStream
// Nên khởi tạo đối tượng InputStream thông qua các class con của nó ..

InputStream fileStream =new FileInputStream("C:/test.txt");

// Luồng đầu vào từ bàn phím..
InputStream is = System.in;

// java.io.OutputStream là một class trìu tượng (abstract class)
// Không thể khởi tạo trực tiếp đối tượng OutputStream thông qua class OutputStream
// Nên khởi tạo đối tượng OutputStream thông qua các class con của nó ..

// Luồng ghi dữ liệu vào file
OutputStream os=new FileOutputStream("D:/outData.txt");

// Luồng ghi ra màn hình Console.
OutputStream w=System.out;

package org.o7planning.tutorial.javaio.stream;

import java.io.FileInputStream;
import java.io.InputStream;

public class HelloInputStream {

  public static void main(String[] args) {
      try {

          // Tạo một đối tượng InputStream theo class con của nó.
          // Đây là luồng đọc một file.
          InputStream is = new FileInputStream("data.txt");

          int i = -1;

          // Đọc lần lượt các byte trong luồng.
          // Mỗi lần đọc ra 8bit, chuyển nó thành số int.
          // Khi đọc ra giá trị -1 nghĩa là kết thúc luồng.

          while ((i = is.read()) != -1) {
              System.out.println(i + "  " + (char) i);
          }
          is.close();
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
}

package org.o7planning.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");
          // Tao thu muc C:/Test
          dir.mkdirs();
          // Tạo một luồng ký tự đầu ra với mục đích ghi thông tin vào file
          OutputStream w = new FileOutputStream(
                  "C:/Test/test_outputStream.txt");
         
         
          // Tạo một mảng byte ,ta sẽ ghi các byte này vào file nói trên .
          byte[] by = new byte[] { 'H', 'e', 'l', 'l', 'o' };

          // Ghi lần lượt các ký tự vào luồng
          for (int i = 0; i < by.length; i++) {
              byte b = by[i];
              // Ghi ký tự vào luồng
              w.write(b);
          }
          // Đóng luồng đầu ra lại việc ghi xuống file hoàn tất.
          w.close();
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
}

package org.o7planning.tutorial.javaio.stream;

import java.io.FileInputStream;
import java.io.InputStream;

public class InputStreamExample2 {

  public static void main(String[] args) {
      try {
          // Tạo một luồng đầu vào bằng cách đọc một file
          InputStream in = new FileInputStream("data.txt");

          // Mảng để mỗi lần đọc các byte từ luồng thì tạm thời để lên đó
          // Ta dùng mảng 10 byte

          byte[] temp = new byte[10];
          int i = -1;

          // Đọc các byte trong luồng và gán lên các phần tử của mảng.
          // Giá trị i là số đọc được của 1 lần. (i sẽ <= 10).
          // Khi không còn phần tử trong luồng i sẽ = -1
          while ((i = in.read(temp)) != -1) {
              // Tạo String từ các byte đọc được
              String s = new String(temp, 0, i);
              System.out.println(s);
          }
          in.close();
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
}

package org.o7planning.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");
          // Tao thu muc C:/Test
          dir.mkdirs();            
         
          // Tạo một luồng nhị phân đầu ra với mục đích ghi thông tin vào file
          OutputStream os = new FileOutputStream("C:/Test/test_writerOutputStream.txt");
         
          // Tạo một mảng byte ,ta sẽ ghi các byte này vào file nói trên .
          byte[] by = new byte[] { 'H', 'e', 'l', 'l', 'o', ' ', 31, 34, 92 };
          byte[] by2 = new byte[] { 'H', 'e', 'l', 'l', 'o', ' ', 'b', 'o',
                  'y' };
         
          // Ghi cả các byte trong mảng byte[] by vào luồng
          os.write(by);
         
          // Đẩy các byte hiện có trên luồng xuống file .
          os.flush();
         
          // Tiếp tục ghi các byte trong mảng thứ 2 vào luồng
          os.write(by2);
         
          // Đóng luồng vào công việc ghi thành công .
          os.close();
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
}

// Mảng các byte chứa các byte của luồng ..
  - byte[] toByteArray();

// Chuyển về một String mô tả dẫy các byte trong luồng.
  - String toString() ;

// Trả về số vị trí được gán của mảng byte[] buf .
  - int size();

package org.o7planning.tutorial.javaio.bytestream;

import java.io.ByteArrayInputStream;
import java.io.IOException;

public class ByteArrayInputStreamExample {

  public static void main(String args[]) throws IOException {

      // Một mảng byte.
      byte[] bytes = new byte[] { 'H', 'e', 'l', 'l', 'o', ' ', 'I', 'O' };

      // Sử dụng ByteArrayInputStream để đọc dữ liệu mảng trên.
      ByteArrayInputStream bInput = new ByteArrayInputStream(bytes);

      System.out.println("Converting characters to Upper case ");
      int c = 0;

      // Đọc lần lượt các byte trong luồng.
      // Con trỏ sẽ di chuyển từ đầu mảng tới cuối mảng.
      // Mỗi lần đọc một byte con trỏ sẽ tiến 1 bước về cuối.
      while ((c = bInput.read()) != -1) {
          char ch = (char) c;
          ch = Character.toUpperCase(ch);
          System.out.println(ch);
      }

      // Kiểm tra xem stream này có hỗ trợ đánh dấu (mark) không.
      boolean markSupport = bInput.markSupported();

      System.out.println("Mark Support? " + markSupport);

      // Đưa con trỏ về vị trí mặc định
      // Trong ví dụ này nó sẽ đưa về vị trí 0.
      bInput.reset();

      char ch = (char) bInput.read();
      System.out.println(ch);

      // Đọc byte kế tiếp
      ch = (char) bInput.read();
      System.out.println(ch);

      System.out.println("Skip 4");
      // Nhẩy qua 4 vị trí
      bInput.skip(4);
      ch = (char) bInput.read();
      System.out.println(ch);

  }
}

package org.o7planning.tutorial.javaio.bytestream;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ByteArrayOutputStreamExample {

  public static void main(String args[]) throws IOException {

      // Tạo một đối tượng ByteArrayOutputStream.
      // Đối tượng chứa bên trong nó một mảng các byte.
      // Khởi tạo mảng các byte 12 phần tử.
      // Nếu số phẩn tử ghi vào luồng nhiều hơn 12 mảng sẽ được thay thế bằng
      // mảng mới có nhiều phần tử hơn, và copy các phần tử mảng cũ sang.
      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);
          }
      }

      // Kiểm tra độ dài của luồng
      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.o7planning.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.o7planning.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.o7planning.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");
      // Tao thu muc C:/Test.
      dir.mkdirs();

      // Tao mot luong ghi vào file ...
      FileOutputStream fos = new FileOutputStream(
              "C:/Test/testObjectStream.txt");

      // Tạo đối tượng ObjectOutputStream bao lấy 'fos'.
      // Những gì ghi vào luồng này sẽ được đẩy xuống 'fos'.
      ObjectOutputStream oos = new ObjectOutputStream(fos);
     
     
      // Ghi một String vào luồng.
      oos.writeUTF("This is student, pupil profiles");
     
      // Chú ý: Các đối tượng ghi được vào luồng phải
      // là kiểu Serializable.
     
      // Ghi một đối tượng Date vào luồng.
      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.o7planning.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 {

      // Tạo một luồng đọc file..
      FileInputStream fis = new FileInputStream(
              "C:/Test/testObjectStream.txt");

      // Tạo đối tượng ObjectInputStream bao lấy 'fis'.
      ObjectInputStream ois = new ObjectInputStream(fis);

      // Đọc ra đối tượng String:
      String s = ois.readUTF();

      System.out.println(s);

      // Đọc ra đối tượng Date.
      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();
  }
}

// Cấu tử
public DataOutputStream(OutputStream out)

// Ghi một ký tự 16 bit (2 byte)
public void writeChar(int val)
// Ghi một số double 64 bit (8-byte)
public void writeDouble(double val)
// Ghi một số float 32 bit (4-byte)
public void writeFloat(float val)
// Ghi một số tự nhiên 32 bit  (4-byte)
public void writeInt(int val)
// Ghi một String mã hóa dạng UTF-8.
public void writeUTF(String obj)
....

// Cấu tử
public DataInputStream(InputStream in)

// Đọc ra một ký tự (16 bit)
public char readChar()
// Đọc ra một số double (64 bit)
public double readDouble()
// Đọc ra một số float (32 bit)
public float readFloat()
// Đọc ra một số int (16 bit)
public int readInt()
// Đọc ra một String (mã hóa dạng UTF-8).
public String readUTF()
....

package org.o7planning.tutorial.javaio.datastream;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOutputStreamExample {

  public static void main(String[] args) throws IOException {
      int cityIdA = 1;
      String cityNameA = "Green Lake City";
      int cityPopulationA = 500000;
      float cityTempA = 15.50f;

      int cityIdB = 2;
      String cityNameB = "Salt Lake City";
      int cityPopulationB = 250000;
      float cityTempB = 10.45f;

      File dir = new File("C:/Test");
      dir.mkdirs();

      //
      // Tạo đối tượng FileOutputStream để ghi xuống file.
      //
      FileOutputStream fos = new FileOutputStream("C:/Test/cities.txt");

      // Tạo đối tượng DataOutputStream bao lấy 'fos'.
      // Dữ liệu ghi vào 'dos' sẽ được đẩy sang 'fos'.
      DataOutputStream dos = new DataOutputStream(fos);

      //
      // Ghi các dữ liệu vào luồng.
      //
      dos.writeInt(cityIdA);
      dos.writeUTF(cityNameA);
      dos.writeInt(cityPopulationA);
      dos.writeFloat(cityTempA);

      dos.writeInt(cityIdB);
      dos.writeUTF(cityNameB);
      dos.writeInt(cityPopulationB);
      dos.writeFloat(cityTempB);

      dos.flush();
      dos.close();
  }

}

package org.o7planning.tutorial.javaio.datastream;

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DataInputStreamExample {
 
 
 
  public static void main(String[] args) throws IOException {
     
       // Luồng đọc dữ liệu từ file.
       FileInputStream fis = new FileInputStream("C:/Test/cities.txt");
       // Tạo đối tượng DataInputStream bao lấy 'fis'.
       DataInputStream dis = new DataInputStream(fis);

       //
       // Đọc dữ liệu.
       //
       int cityId1 = dis.readInt();
       System.out.println("Id: " + cityId1);
       String cityName1 = dis.readUTF();
       System.out.println("Name: " + cityName1);
       int cityPopulation1 = dis.readInt();
       System.out.println("Population: " + cityPopulation1);
       float cityTemperature1 = dis.readFloat();
       System.out.println("Temperature: " + cityTemperature1);

       //
       // Đọc dữ liệu.
       //
       int cityId2 = dis.readInt();
       System.out.println("Id: " + cityId2);
       String cityName2 = dis.readUTF();
       System.out.println("Name: " + cityName2);
       int cityPopulation2 = dis.readInt();
       System.out.println("Population: " + cityPopulation2);
       float cityTemperature2 = dis.readFloat();
       System.out.println("Temperature: " + cityTemperature2);
     
       dis.close();
  }
}

// Cấu tử :

  // Tạo một luồng đầu vào từ việc ghép luồng s2 nối tiếp với s1  
   public SequenceInputStream(InputStream s1,InputStream s2)  
   
   // Tạo một luồng đầu vào từ việc ghép một tập hợp các luồng đầu vào khác.
   public SequenceInputStream(Enumeration<? extends InputStream> e)

// Một vài method :
   // - Không có gì mới so với danh sách các method thấy trong class cha InputStream .

// Một luồng nhị phân đầu vào đọc từ một file File1.txt .
InputStream is1=new FileInputStream("File1.txt");
// Luồng mới đọc từ file File2.txt  
InputStream is2=new FileInputStream("File2.txt");
// Nối luồng is2 nối tiếp với luồng is1 thành một luồng nhị phân mới .
SequenceInputStream sis=new SequenceInputStream(is1,is2);
// Thao tác trên luồng đầu vào nhị phân SequenceInputStream sis như bình thường ...

package org.o7planning.tutorial.javaio.pipestream;

import java.io.IOException;
import java.io.InputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipeStreamExample1 {

	private InputStream pipedInputStream;

	public static void main(String[] args) throws IOException, InterruptedException {
		new PipeStreamExample1().test();
	}

	private void test() throws IOException, InterruptedException {
		// Tạo một 'pipedOutputStream',
		PipedOutputStream pipedOutputStream = new PipedOutputStream();

		// Dữ liệu ghi vào 'pipedOutputStream'
		// sẽ tự động xuất hiện tại 'pipedInputStream'.
		pipedInputStream = new PipedInputStream(pipedOutputStream);

		new ThreadRead().start();

		char[] chs = new char[] { 'a', 'a', 'b', 'c' , 'e' };

		// Ghi dữ liệu vào 'pipedOutputStream'.
		for (char ch : chs) {
			pipedOutputStream.write(ch);
			Thread.sleep(1000);
		}
		pipedOutputStream.close();
	}

	// Một Thread đọc dữ liệu xuất hiện trên 'pipedInputStream'.
	class ThreadRead extends Thread {

		@Override
		public void run() {
			try {
				int data = 0;
				while ((data = pipedInputStream.read()) != -1) {
					System.out.println((char) data);
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				closeQuietly(pipedInputStream);
			}
		}
	}

	private void closeQuietly(InputStream is) {
		if (is != null) {
			try {
				is.close();
			} catch (IOException e) {
			}
		}
	}

}

// PrintStream là class con trực tiếp của FilterOutputStream .
// Nó có thể bao bọc một luồng đầu ra nhị phân (OutputStream) , ..
// Cấu tử :

   // Bao bọc một luồng nhị phân
   public PrintStream(OutputStream out)

   public PrintStream(OutputStream out,boolean autoFlush)
   // Ghi thông tin vào file ..
   public PrintStream(String fileName)
   // ...(Xem javadoc) .

// Một số method
   public void println(String s)
   public void print(char ch)
   // Ghi một đối tượng vào luồng .
   public void print(Object obj)
   // Ghi một số tự nhiên 64 bit vào luồng .  
   public void print(long n)
   public PrintStream append(java.lang.CharSequence csq) .
   // ... (chi tiết xem javadoc) .

try {    
 // Làm một điều gì đó trong khối try ...  
 // Lỗi chia cho 0
 int i=10/0;
}
// Có điều gì đó sai xót trong khi chạy khối try khối catch được chạy
catch(Exception e) {  
 // In ra lý do sai xót trong khi chạy    
 System.out.println("Error on try..."+e.getMessage());
 // In ra thông tin quá trình chạy lỗi xuất hiện ở các vị trí nào ra màn hình Console
 // Làm sao để lấy được đoạn text "stack trace" ?
 e.printStackTrace();
}

package org.o7planning.tutorial.javaio.printstream;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;

public class GetStackTraceString {

  private static String getStackTraceString(Exception e) {
      // Tạo một đối tượng ByteArrayOutputStream.
      ByteArrayOutputStream baos = new ByteArrayOutputStream();

      // Những gì ghi vào 'printStream' sẽ được ghi sang 'baos'.
      PrintStream printStream = new PrintStream(baos);

      // Ghi thông tin lỗi sang 'printStream'
      e.printStackTrace(printStream);

      printStream.close();
     
      byte[] bytes = baos.toByteArray();

      String s = new String(bytes);
      return s;
  }

  public static void main(String[] args) {

      try {
          // Làm một điều gì đó trong khối try ...
          // Lỗi chia cho 0
          int i = 10 / 0;
      }
      // Có điều gì đó sai xót trong khi chạy khối try khối catch được chạy
      catch (Exception e) {
          // In ra lý do sai xót trong khi chạy
          System.out.println("Error on try..." + e.getMessage());
          // In ra thông tin quá trình chạy lỗi xuất hiện ở các vị trí nào ra
          // màn hình Console
          // Lấy được đoạn text "stack trace":
          String s = getStackTraceString(e);

          System.out.println("Stack Trace String " + s);
      }
  }
}

// Luồng PrintStream ghi ra màn hình Console.
PrintStream os = System.out;
// Exception e ..
// Ghi thông tin dò lỗi vào luồng PrintStream os .Hay nói cách khác ghi ra màn hình Console.
e.printStackTrace(os);

// Về bản chất nó tương đương với gọi:
e.printStackTrace();