Xử lý tập tin và đọc ghi dữ liệu trong Java

2022-11-18

4 minute read

backend developer

java

IV. Xử lý tập tin và đọc ghi dữ liệu trong Java:

A. Đọc và ghi tập tin văn bản:

Trong Java, để đọc và ghi dữ liệu từ tập tin văn bản, chúng ta sử dụng các lớp File, FileReader, FileWriter, BufferedReader, và BufferedWriter.

Đọc từ tập tin văn bản:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadFile {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("filename.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Ghi vào tập tin văn bản:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class WriteFile {
    public static void main(String[] args) {
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter("filename.txt"));
            writer.write("Hello, world!");
            writer.newLine(); // Thêm dòng mới
            writer.write("This is a new line.");
            writer.close();
            System.out.println("File written successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Trong các ví dụ trên:

BufferedReader được sử dụng để đọc từ tập tin dòng một cách hiệu quả.
BufferedWriter được sử dụng để ghi dữ liệu vào tập tin một cách hiệu quả, có thể ghi dữ liệu dưới dạng từng dòng một bằng cách sử dụng phương thức newLine().

Cần lưu ý rằng cả hai ví dụ trên đều sử dụng cú pháp try-with-resources để tự động đóng tài nguyên sau khi sử dụng. Điều này đảm bảo rằng tài nguyên sẽ được giải phóng một cách an toàn sau khi không còn được sử dụng nữa.

B. Đọc và ghi đối tượng vào tập tin

Để đọc và ghi đối tượng vào tập tin trong Java, chúng ta cần sử dụng kỹ thuật gọi là “serialization” (tuần tự hóa) và “deserialization” (phiên dịch ngược). Điều này cho phép chúng ta lưu trữ các đối tượng Java vào tập tin và sau đó khôi phục chúng khi cần thiết. Để thực hiện việc này, chúng ta cần sử dụng các luồng đối tượng như ObjectInputStream và ObjectOutputStream.

Dưới đây là một ví dụ minh họa:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


import java.io.*;

// Lớp đối tượng cần được lưu trữ vào tập tin
class Person implements Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getters và setters
    // ...

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class ObjectFileIO {
    public static void main(String[] args) {
        // Đường dẫn của tập tin
        String fileName = "person.ser";

        // Ghi đối tượng vào tập tin
        try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(fileName))) {
            Person person = new Person("John", 30);
            outputStream.writeObject(person);
            System.out.println("Object written to file successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Đọc đối tượng từ tập tin
        try (ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(fileName))) {
            Person person = (Person) inputStream.readObject();
            System.out.println("Object read from file: " + person);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Trong ví dụ trên:

Lớp Person được triển khai để đại diện cho một đối tượng cần được lưu trữ.
Lớp ObjectOutputStream được sử dụng để ghi đối tượng vào tập tin.
Lớp ObjectInputStream được sử dụng để đọc đối tượng từ tập tin.
Đối tượng Person được ghi vào tập tin và sau đó được đọc ra và hiển thị.

C. Xử lý luồng dữ liệu (InputStream và OutputStream):

Trong Java, InputStream và OutputStream là hai lớp trừu tượng cơ sở cho việc đọc và ghi dữ liệu từ các nguồn khác nhau như tập tin, mảng byte, kết nối mạng, v.v.

InputStream:

InputStream là lớp trừu tượng đại diện cho một luồng đầu vào của dữ liệu byte.
Các lớp con của InputStream có thể được sử dụng để đọc dữ liệu từ nhiều nguồn khác nhau như tập tin, mảng byte, hoặc kết nối mạng.

Ví dụ:

1
2
3
4
5
6
7


InputStream inputStream = new FileInputStream("input.txt");
int data = inputStream.read();
while (data != -1) {
    // Xử lý dữ liệu
    data = inputStream.read();
}
inputStream.close();

OutputStream:
- OutputStream là lớp trừu tượng đại diện cho một luồng đầu ra của dữ liệu byte.
- Các lớp con của OutputStream có thể được sử dụng để ghi dữ liệu ra nhiều nguồn như tập tin, mảng byte, hoặc kết nối mạng.
- Ví dụ:
  1 2 3 4
  
  OutputStream outputStream = new FileOutputStream("output.txt"); byte[] data = "Hello, world!".getBytes(); outputStream.write(data); outputStream.close();

Xử lý dữ liệu với BufferedInputStream và BufferedOutputStream:

BufferedInputStream và BufferedOutputStream là hai lớp con của InputStream và OutputStream tương ứng.
Chúng cung cấp một bộ nhớ đệm để tăng hiệu suất đọc và ghi dữ liệu từ và đến các nguồn dữ liệu như tập tin.

Ví dụ:

1
2
3


InputStream inputStream = new BufferedInputStream(new FileInputStream("input.txt"));
OutputStream outputStream = new BufferedOutputStream(new FileOutputStream("output.txt"));
// Đọc và ghi dữ liệu từng byte hoặc từng mảng byte

Việc sử dụng InputStream và OutputStream cho phép bạn thực hiện các thao tác đọc và ghi dữ liệu từ và đến nhiều nguồn khác nhau trong Java. Bằng cách sử dụng các lớp con và phương thức của chúng, bạn có thể xử lý dữ liệu hiệu quả và linh hoạt.