So sánh size của 2 file txt trong java năm 2024

Lớp của Java `BufferedWriter`ghi văn bản vào luồng ký tự đầu ra, đệm các ký tự để ghi các ký tự, mảng và chuỗi một cách hiệu quả. Bạn có thể chuyển kích thước bộ đệm cho hàm tạo làm đối số thứ hai. Nhà xây dựng:

  
BufferedWriter[Writer out] // Create a buffered output character stream that uses the default buffer size.  
BufferedWriter[Writer out, int sz] // Creates a buffered character output stream that uses a buffer with the specified size.  

phương pháp:

  
close[] // Close the stream  
flush[] // Send the data from the buffer to the Writer  
newLine[] // Move to a new line  
write[char[] cbuf, int off, int len] // Write to the buffer  
write[int c] // Write to the buffer  
write[String s, int off, int len] // Write to the buffer  

BufferedReaderĐây là một ví dụ về việc sử dụng các lớp và Java BufferedWriter:

Viết vào một tập tin:

  
import java.io.*;
public class WriteFile {  
    public static void main[String[] args] {  
        String[] list = {"one", "two", "three", "fo"};  
        try {  
            File file = new File["file.txt"];  
            FileWriter fileReader = new FileWriter[file]; // A stream that connects to the text file  
            BufferedWriter bufferedWriter = new BufferedWriter[fileReader]; // Connect the FileWriter to the BufferedWriter
            for [String s : list] {  
                bufferedWriter.write[s + "\n"];  
            }
            bufferedWriter.close []; // Close the stream  
        } catch [Exception e] {  
            e.printStackTrace[];  
        }  
    }  
}  

  
close[] // Close the stream  
mark[int readAheadLimit] // Mark the position in the stream  
markSupported[] // Indicates whether stream marking is supported  
int  read[] // Read the buffer  
int  read[char[] cbuf, int off, int len] // Read the buffer  
String  readLine[] // Next line  
boolean  ready[] // Is the stream ready to read?  
reset[] // Reset the stream  
skip[long n] // Skip characters  

3ngay lập tức ghi dữ liệu vào đĩa. Mỗi khi chúng tôi truy cập nó, bộ đệm bao quanh nó sẽ tăng tốc ứng dụng của chúng tôi. Bộ đệm sẽ ghi dữ liệu bên trong, sau đó ghi các khối tệp lớn vào đĩa. Chúng tôi đọc dữ liệu từ bàn điều khiển và ghi nó vào một tệp:

  
import java.io.*;
class ConsoleRead {  
    public static void main[String[] args] {  
        try {  
            File file = new File["file.txt"];  
            InputStreamReader inputStreamReader = new InputStreamReader[System.in]; // A stream for reading from the console  
            BufferedReader bufferedReader = new BufferedReader[inputStreamReader]; // Connect InputStreamReader to a BufferedReader
            FileWriter fileReader = new FileWriter[file]; // A stream that connects to the text file  
            BufferedWriter bufferedWriter = new BufferedWriter[fileReader]; // Connect the FileWriter to the BufferedWriter
            String line;  
            while[![line = bufferedReader.readLine[]].equals["exit"]] {  
                bufferedWriter.write[line];  
            }
            bufferedReader.close[]; // Close the stream  
            bufferedWriter.close[];  
        } catch [Exception e] {  
            e.printStackTrace[];  
        }  
    }  
}  

John Selawsky

Tại

A senior Java developer and Java tutor at Learning Tree International programming courses. Sometimes I write some stupid programmi ... [Đọc toàn bộ tiểu sử]

Hầu hết các chương trình ứng dụng hoạt động với dữ liệu được lưu trữ trong các tệp cục bộ hoặc đến từ máy tính qua mạng. Java làm việc với luồng dữ liệu. Một luồng là một chuỗi dữ liệu. Nó cũng có thể được định nghĩa là một thực thể logic tạo ra hoặc tiêu thụ thông tin. Một luồng dữ liệu là một kênh thông qua đó dữ liệu di chuyển từ nguồn đến đích. Nguồn hoặc đích này có thể là thiết bị đầu vào hoặc đầu ra, phương tiện lưu trữ hoặc máy tính trên mạng. Một bộ nhớ lưu trữ dữ liệu vật lý được ánh xạ thành một luồng logic và sau đó, một chương trình Java đọc dữ liệu từ luồng này theo chuỗi – một byte sau một byte, hoặc ký tự sau ký tự. Nói cách khác, một tệp vật lý có thể được đọc bằng cách sử dụng các loại luồng khác nhau, ví dụ: FileTnputStream, hoặc Fi leReader. Java sử dụng các luồng như vậy để thực hiện các hoạt động đầu vào và đầu ra khác nhau.

Sự cần thiết của Các Lớp và Giao diện Stream

Trong Java, luồng là bắt buộc để thực hiện tất cả các hoạt động đầu vào/đầu ra [I/O]. Một luồng đầu vào nhận dữ liệu từ một nguồn vào chương trình và một luồng đầu ra gửi dữ liệu đến một đích từ chương trình.

Do đó, các lớp và giao diện luồng giúp hữu ích trong các tác vụ:

• Đọc dữ liệu từ một luồng
• Ghi đầu ra vào một luồng.
• Quản lý tệp đĩa
• Chia sẻ dữ liệu với mạng máy tính

Mục lục

Các Lớp và Giao diện Luồng

Luồng đầu/ra tiêu chuẩn trong Java được biểu diễn bởi ba trường của lớp System:

• in

Luồng đầu vào tiêu chuẩn được sử dụng để đọc ký tự dữ liệu. Luồng này phản hồi đến đầu vào bàn phím hoặc bất kỳ nguồn đầu vào nào được chỉ định bởi môi trường hoặc người dùng. Nó đã được định nghĩa như sau:

public static final InputStream in;

• out

Luồng đầu ra tiêu chuẩn được sử dụng để hiển thị đầu ra trên màn hình hoặc bất kỳ phương tiện đầu ra nào khác. Nó đã được định nghĩa như sau:

public static final PrintStream out;

• err

Đây là luồng lỗi tiêu chuẩn. Theo mặc định, đây là console của người dùng. Nó đã được định nghĩa như sau:

public static final PrintStream err;

Để đọc hoặc ghi dữ liệu bằng cách sử dụng các luồng Đầu vào/Đầu ra, cần thực hiện các bước sau:

• Mở một luồng trỏ vào một nguồn dữ liệu cụ thể: một tệp, một socket, URL, và nhiều hơn nữa.
• Đọc hoặc ghi dữ liệu từ/đến luồng này.
• Đóng luồng.

InputStream và OutputStream là các lớp trừu tượng và được sử dụng để đọc và ghi các chuỗi byte không có cấu trúc. Các luồng đầu vào và đầu ra khác là các lớp con của các lớp trừu tượng này và được sử dụng để đọc và ghi vào tệp. Các loại luồng byte khác nhau có thể được sử dụng có thể sử dụng chung vì chúng kế thừa cấu trúc của lớp Input/OutputStream. Để đọc hoặc ghi byte, phải sử dụng một lớp con của lớp InputStream hoặc OutputStream tương ứng.

Luồng Phản ứng [Reactive Stream]

Lập trình phản ứng là một mô hình lập trình, tương tự như cách lập trình hướng đối tượng hoặc lập trình hàm là các mô hình lập trình.

Theo Chương trình phản ứng [một hướng dẫn xây dựng kiến trúc hiện đại, linh hoạt và có quy mô lớn], bất kỳ ứng dụng phản ứng nào phải tuân theo bốn đặc điểm chính:

• Responsive: Hệ thống tập trung vào việc cung cấp thời gian phản hồi nhanh chóng và nhất quán và đáp ứng một cách kịp thời.
• Resilient: Hệ thống là có khả năng phục hồi và vẫn giữ được tính phản ứng ngay cả khi gặp sự cố.
• Elastic: Hệ thống là linh hoạt và có thể điều chỉnh tùy theo công việc biến đổi.
• Message-driven: Hệ thống phụ thuộc vào các hoạt động điều khiển bất đồng bộ dựa trên tin nhắn.

Trong Java, Reactive Streams cung cấp một API chung để triển khai lập trình phản ứng.

RxJava và Akka Streams là hai phiên bản phổ biến của Reactive Streams.

RxJava

RxJava giúp thực hiện multithreading trong ứng dụng. RxJava là một trong những API được sử dụng cho Java. RxJava là một hiện thực Java của Reactive Extensions, là một thư viện cho các chương trình không đồng bộ và dựa trên sự kiện. Điều này được thực hiện bằng cách sử dụng mẫu Iterator, quan sát và lập trình hàm.

Trong thế giới Rx [lập trình phản ứng], có hai loại chính:

• Observables: Được gọi là các đối tượng phát ra một chuỗi sự kiện hoặc dữ liệu,
• Observers/Subscribers: Được gọi là các đối tượng thực hiện trên dữ liệu được phát ra.

Akka Concepts

Akka là một thư viện mã nguồn mở giúp phát triển dễ dàng các ứng dụng đồng thời và phân tán với Java, Akka là cả một nguyên tắc thiết kế và một nền tảng đồng thời.

Akka sử dụng mô hình Actor, mô hình/thiết kế trong đó “một actor” đại diện cho một thực thể tính toán độc lập. Actor tương tác chỉ thông qua các tin nhắn không đồng bộ và không tương tác thông qua các cuộc gọi phương thức trực tiếp. Không có phương thức nào có thể được gọi trên các đối tượng bên ngoài, nhưng việc truyền các actor dưới dạng đối tượng là có thể. Trong hầu hết các trường hợp, một trường hợp lớp được sử dụng cho điều này.

Hỗ trợ Reactive Streams được giới thiệu trong Java 9 thông qua java.util.concurrent.Flow API.

Luồng Phản ứng Java 9

Reactive Streams liên quan đến việc xử lý luồng theo cách không đồng bộ. Nó yêu cầu một nhà xuất bản để xuất bản luồng dữ liệu và một người đăng ký để tiêu thụ dữ liệu. Đôi khi dữ liệu được chuyển đổi giữa nhà xuất bản[publisher] và người đăng ký [subcriber]. Cuối cùng, bộ xử lý chuyển đổi dữ liệu nhận được từ nhà xuất bản để người đăng ký hiểu được. Do đó, có thể có một loạt các bộ xử lý.

Triển khai Luồng Phản ứng bằng Flow API

Java Flow API từ phiên bản 9 trở đi triển khai đặc tả Reactive Streams. Sự kết hợp giữa mẫu Iterator và Observer tạo nên Flow API. Nếu một ứng dụng rút các mục từ nguồn, đó được gọi là mô hình rút theo Iterator. Nếu nguồn đẩy một mục đến ứng dụng, đó được gọi là mô hình đẩy theo Observer. Trong quá trình đăng ký, người đăng ký Java Flow API có thể yêu cầu N mục. Sau đó, các mục được đẩy đến người đăng ký cho đến khi tất cả các mục được thực hiện hoặc một lỗi xuất hiện.

Các lớp và giao diện của Flow API

Dưới đây là các lớp và giao diện của Flow API:

java.util.concurrent.Flow

Lớp này của Flow API là lớp chính và bao gồm các giao diện quan trọng của Flow API được lồng trong lớp này. Nó là một lớp cuối cùng và không thể được mở rộng.

java.util.concurrent.Flow.Publisher

Đây là một giao diện chức năng và mọi nhà xuất bản phải triển khai phương thức subscribe [] để thêm người đăng ký để nhận thông điệp.

java.util.concurrent.Flow.Subscriber

Mỗi người đăng ký phải thực hiện giao diện này. Các phương thức của người đăng ký được thực hiện theo thứ tự tuần tự nghiêm ngặt. Bốn phương thức trong giao diện này được mô tả trong Bảng dưới.

Phương thứcMô tảsubscribeNhư người đăng ký, đăng ký để nhận thông điệp, phương thức này được khởi tạo bởi nhà xuất bản. Để bắt đầu nhận các mục từ bộ xử lý, subscription.request[] được gọi trong cài đặt của phương thức này, nơi subscription là một trường hợp của giao diện Flow.Subscription.onContextSau khi nhận được một mục từ một nhà xuất bản, logic nghiệp vụ được triển khai để xử lý luồng. Phương thức onContext được triển khai để yêu cầu thêm dữ liệu từ nhà xuất bản.onErrorKhi xảy ra lỗi không thể phục hồi, phương thức onError được khởi chạy. Phương thức này cho phép các công việc dọn dẹp, chẳng hạn như kết thúc/đóng kết nối cơ sở dữ liệu trước khi kết thúc nhiệm vụ.onCompleteSau khi sản xuất tất cả các mục, nhà xuất bản sẽ được đóng. Sau đó, cuối cùng, phương thức onComplete được khởi chạy. Nó cũng được sử dụng để gửi thông báo khi luồng được xử lý một cách hiệu quả.Các phương thức của giao diện Subscriber

java.util.concurrent.Flow.Subscription

Người đăng ký sử dụng giao diện này để đăng ký vào một nhà xuất bản. Giao diện này xây dựng các liên kết không đồng bộ không chặn giữa một nhà xuất bản và người đăng ký. Nó cung cấp một phương thức request để người đăng ký yêu cầu các mục từ nhà xuất bản. Nó cũng cung cấp một phương thức hủy bỏ để kết thúc việc đăng ký.

java.util.concurrent.Flow.Processor

Giao diện này giúp biến đổi tin nhắn giữa nhà xuất bản và người đăng ký và mở rộng đến cả hai.

java.util.concurrent.SubmissionPublisher

Nó sử dụng khung Executor để phát hành các mục được gửi đến người đăng ký hiện tại một cách không đồng bộ cho đến khi nó được đóng. Ví dụ, người ta nên sử dụng lớp này trong các ví dụ luồng phản ứng để thêm một người đăng ký và sau đó, gửi các mục.

Ghi chú: Phát triển bằng cách sử dụng luồng Phản ứng được khuyến nghị chỉ trong các ứng dụng Java tiên tiến và phức tạp.

takeWhile[], dropWhile[], ofNullable[], và iterate với Condition

Trong Java, có thể thực hiện các hoạt động toàn diện với mẫu đối tượng khi sử dụng luồng [streams]. Các phương thức sau đây làm tinh chỉnh luồng:

takeWhile[Predicate Interface]

Cú pháp:

default Stream takeWhile[Predicate