Lớp BufferedInputStream và BufferedOutputStream trong Java

Đây là bài 51/62 bài của series môn học Ngôn ngữ lập trình Java

1. Lớp BufferedInputStream trong Java

Lớp BufferedInputStream trong package java.io được sử dụng với các input stream khác để đọc dữ liệu dạng byte hiệu quả hơn. Lớp BufferedInputStream kế thừa từ lớp abstract InputStream.

Lớp BufferedInputStream trong Java có một bộ nhớ đệm bên trong nó với dung lượng mặc định là 8192 byte. Khi đọc dữ liệu với BufferedInputStream, một đoạn byte được đọc từ nơi lưu trữ (data source) rồi lưu trữ trong bộ nhớ đệm bên trong nó (internal buffer). Do đó, số lần truy xuất dữ liệu đến data source giảm đi. Đó là lý do tại sao đọc dữ liệu với BufferedInputStream hiệu quả hơn.

Tạo ra một BufferedInputStream trong Java

Để sử dụng BufferedInputStream, chúng ta cần import java.io.BufferedInputStream.

//Tạo một FileInputStream
FileInputStream file = new FileInputStream(String path);

//Tạo một BufferedInputStream
BufferedInputStream buffer = new BufferInputStream(file);

Trong ví dụ trên, chúng ta tạo ra một đối tượng BufferdInputStream tên là buffer với một đối tượng FileInputStream tên là file.

Khi tạo một BufferedInputStream thì bộ nhớ đệm mặc định của nó là 8192 byte. Chúng ta có thể thay đổi kích thước bộ nhớ đệm với tham số int size.

//Tạo một BufferedInputStream với size internal buffer
BufferedInputStream buffer = new BufferInputStream(file, int size);

Các phương thức của BufferedInputStream

Phương thức read()

  • read() đọc một byte từ input stream
  • read(byte[] arr) đọc các byte từ input stream và lưu trữ những byte này vào một mảng (array)
  • read(byte[] arr, int start, int length) đọc length byte từ input stream và lưu trữ vào mảng tại vị trí bắt đầu là start của mảng

Giả sử, chúng ta có 1 file input.txt nằm trong phân vùng D với nội dung sau như bên dưới.

This is a line of text inside the file.

Chúng ta có thể đọc file này với BufferedInputStream.

import java.io.BufferedInputStream;
import java.io.FileInputStream;
class Main {
    public static void main(String[] args) {
        try {
            //Tạo một đối tượng FileInputStream
            FileInputStream file = new FileInputStream("D:\\input.txt");
            //Tạo một đối tượng BufferedInputStream
            BufferedInputStream input = new BufferedInputStream(file);
            //Đọc byte đầu tiên trong file
            int i = input .read();
            while (i != -1) {
                System.out.print((char) i);
                //Đọc các byte kế tiếp trong file
                i = input.read();
            }
            input.close();
        }
        catch (Exception e) {
           System.err.println(e.getStackTrace());
        }
    }
}
Kết quả
This is a line of text inside the file.

Phương thức available()

Để lấy số byte chưa được đọc trong input stream, chúng ta có thể sử dụng hàm available().

import java.io.FileInputStream;
import java.io.BufferedInputStream;
public class Main {
    public static void main(String args[]) {
        try {
           FileInputStream file = new FileInputStream("D:\\input.txt");
           BufferedInputStream buffer = new BufferedInputStream(file);
           //Trả về số byte dữ liệu trong file
           System.out.println("Available bytes at the beginning: " + buffer.available());
           //Đọc 3 byte trong file
           buffer.read();
           buffer.read();
           buffer.read();
           //Trả về số byte chưa được đọc
           System.out.println("Available bytes at the end: " + buffer.available());
           buffer.close();
        }
        catch (Exception e) {
           System.err.println(e.getStackTrace());
        }
    }
}
Kết quả
Available bytes at the beginning: 39
Available bytes at the end: 36

Phương thức skip()

Để bỏ qua một số byte không cần đọc, chúng ta có thể sử dụng hàm skip().

import java.io.FileInputStream;
import java.io.BufferedInputStream;
public class Main {
   public static void main(String args[]) {
      try {
         FileInputStream file = new FileInputStream("D:\\input.txt");
         BufferedInputStream buffer = new BufferedInputStream(file);
         //Bỏ qua 5 byte không cần đọc
         buffer.skip(5);
         System.out.println("Input stream after skipping 5 bytes:");
         //Đọc byte đầu tiên từ input stream
         int i = buffer.read();
         while (i != -1) {
            System.out.print((char) i);
            //Đọc byte kế tiếp từ input stream
            i = buffer.read();
         }
         buffer.close();
      }
      catch (Exception e) {
         e.getStackTrace();
      }
   }
}
Kết quả
Input stream after skipping 5 bytes:
is a line of text inside the file.

Trong ví dụ trên, chúng ta bỏ qua 5 byte đầu tiên không đọc từ file input stream. Do đó, các byte lưu trữ các ký tự ‘T’, ‘h’, ‘i’, ‘s’ và ‘ ‘ bị bỏ qua nên không hiển thị lúc xuất ra màn hình.

Phương thức close()

Nên đóng kết nối BufferedInputStream với hàm close() khi không sử dụng để đọc dữ liệu nữa.

2. Lớp BufferedOutputStream trong Java

Lớp BufferedOutputStream nằm trong package java.io được sử dụng với các output stream khác để ghi dữ liệu dạng byte hiệu quả hơn. Lớp BufferedOutputStream kế thừa từ lớp abstract OutputStream. Lớp BufferedOutputStream có bên trong nó một bộ nhớ đệm có dung lượng 8192 byte.

Trong suốt quá trình ghi dữ liệu, các byte được ghi vào bộ nhớ bên trong thay vì ghi trực tiếp vào nơi cần lưu trữ (data destination). Khi bộ nhớ đệm đã đầy hoặc output stream đóng thì toàn bộ bộ nhớ đềm sẽ được ghi vào data destination. Do đó, số lần ghi dữ liệu vào data destination được giảm đi. Đó là lý do tại sao ghi dữ liệu với BufferedOutputStream hiệu quả hơn.

Tạo một BufferedOutputStream

Để sử dụng BuffferedOutputStream, chúng ta cần import java.io.BufferedOutputStream.

//Tạo một đối tượng FileOutputStream
FileOutputStream file = new FileOutputStream(String path);

//Tạo một đối tượng BufferedOutputStream
BufferedOutputStream buffer = new BufferOutputStream(file);

Trong ví dụ trên, chúng ta đã tạo ra một đối tượng của lớp BufferdOutputStream có tên là buffer với một đối tượng của lớp FileOutputStream có tên là file.

Bộ nhớ đệm mặc định để ghi dữ liệu của lớp BufferdOutputStream8192 byte. Chúng ta có thể thay thế kích thước bộ nhớ đệm với tham số int size.

//Tạo một đối tượng BufferedOutputStream với size internal buffer
BufferedOutputStream buffer = new BufferOutputStream(file, int size);

Các phương thức của lớp BufferedOutputStream

Phương thức write()

  • write() ghi một byte vào bộ nhớ đệm bên trong của output stream
  • write(byte[] array) ghi các byte từ một mảng (array) đến output stream
  • write(byte[] arr, int start, int length) ghi length byte đến output stream từ một mảng bắt đầu tại vị trí start của mảng
import java.io.FileOutputStream;
import java.io.BufferedOutputStream;
public class Main {
    public static void main(String[] args) {
        String data = "This is a line of text inside the file";
        try {
            //Tạo đối tượng FileOutputStream
            FileOutputStream file = new FileOutputStream("D:\\output.txt");
            //Tạo đối tượng BufferedOutputStream
            BufferedOutputStream output = new BufferedOutputStream(file);
           //đổi string thành mảng byte để ghi vào file
            byte[] array = data.getBytes();
            //Ghi dữ liệu đến output stream
            output.write(array);
            output.close();
        }
        catch (Exception e) {
            System.err.println(e.getStackTrace());
        }
    }
}

Phương thức flush()

Để xóa bộ nhớ đệm bên trong cuar BufferedOutputStream, chúng ta có thể sử dụng hàm flush(). Phương thức này bắt buộc ghi tất cả dữ liệu trong bộ nhớ đệm của output stream đến data destination.

import java.io.FileOutputStream;
import java.io.BufferedOutputStream;
public class Main {
    public static void main(String[] args) {
        String data = "This is a demo of the flush method";
        try {
            //Tạo một đối tượng FileOutputStream
            FileOutputStream file = new FileOutputStream(" flush.txt");
            //Tạo một đối tượng BufferedOutputStream
            BufferedOutputStream buffer = new BufferedOutputStream(file);
            //Ghi dữ liệu đến output stream
            buffer.write(data.getBytes());
            //Bắt buộc ghi dữ liệu vào data destination
            buffer.flush();
            System.out.println("Data is flushed to the file.");
            buffer.close();
        }
        catch(Exception e) {
            System.err.println(e.getStackTrace());
        }
    }
}

Các bạn nhớ sử dụng hàm close() để đóng kết nối BufferedOutputStream khi không sử dụng để ghi dữ liệu nữa.

5/5 - (5 bình chọn)
Bài trước và bài sau trong môn học<< Lớp ObjectInputStream và ObjectOutputStream trong JavaLớp Reader và Writer trong Java >>
Chia sẻ trên mạng xã hội:

Tác giả Vinh Lê

Vinh Lê hiện đang là biên tập viên tại Góc Học IT.

Bài viết của Vinh Lê

Trả lời

Lưu ý:

1) Vui lòng bình luận bằng tiếng Việt có dấu.

2) Khuyến khích sử dụng tên thật và địa chỉ email chính xác.

3) Mọi bình luận trái quy định sẽ bị xóa bỏ.