Đọc và ghi files trong java

Đọc và ghi files trong java

Có nhiều con đường diễn tả dữ liệu trên máy tinh. Bạn sẵn sàng làm việc với tạo objects. Một object bao gồm dữ liệu hình thành trong biến và chuyển đến objects. Nó cũng bao gồm phương thức sử dụng dữ liệu để hoàn thành nhiệm vụ.

Để làm việc với những kiểu dữ liệu khác nhau, giống như những file trên ổ cứng và tài liệu trên web server, bạn seur dụng classes của gói java.io. “io” là một phần tên chuẩn cho “input/output” và classes sử dụng để truy cập vào nguồn dữ liệu, giống như ổ cứng, CD-ROM, hoặc bộ nhớ máy tính.

Bạn có thể mang dữ liệu trong chương trình và gửi dữ liệu ra ngoài sử dụng kết nối hệ thống gọi là streams, hoặc object đưa thông tin từ một nơi này đến nơi khác.

Streams

Để lưu dữ liệu thường xuyên trong một chương trình Java, hoặc nhận dữ liệu sau, bạn phải sử dụng ít nhất một stream.

Một stream là một object đưa thông tin từ một nguồn và gửi nó tới một vài nơi.

Streams kết nói nhiều nguồn khác nhau, bao gồm những chương trình máy tính, ổ đĩa cững, Internet servers, bộ nhớ máy tính, và DVD-ROMs. Sau khi bạn học làm thế nào để làm việc với một kiểu dữ liệu sử dụng streams, bạn có thể làm việc với kiểu khác tương tự.

Ví dụ bạn sử dụng streams để đọc và ghi dữ liệu chứa trong file trên máy tính của bạn.

Có hai kiểu streams:

  • Input streams, đọc dữ liệu từ tài nguyên
  • Output streams, viết dữ liệu tới tài nguyên

Tất cả input và output streams tạo thành bytes, số nguyên với giá trị riêng biệt sắp xếp từ 0 đến 255. Bạn có thể sử dụng định dạng này để đại diện dữ liệu, giống như thực thi chương trình, xử lý tại liệu word, và file nhạc MP3, nhưng đó chỉ là một ví dụ nhỏ bytes có thể đại diện. Một byte stream sử dụng để đọc và ghi kiểu dữ liệu này.

Một cách đặc biệt để làm việc với dữ liệu dưới dạng ký tự -- chữ cái riêng biệt, số, dấu chấm và tương tự. Bạn có thể sự dụng ký tự stream khi bạn đọc và ghi một tài nguyên văn bản (text).

Dù làm việc với một stream của bytes, ký tự hoặc kiểu khác của thông tin, toàn bộ xử lý giống nhau:

  • Tạo một object stream liên kết với dữ liệu
  • Gọi phương thức của stream tới mỗi cái để nhập thông tin vào trong stream hoặc đưa thông tin ra ngoài.
  • Đóng stream bằng cách gọi phương thức close() của object.

 

Files

Trong Java, dữ liệu được đại diện bởi class File, cũng là một phần của gói java.io. Files có thể đọc từ ổ cứng, CD-ROMs, và thiết bị lưu trữ khác.

Một object file có thể đại diện cho files đang tồn tại hoặc file bạn muốn tạo. Để tạo một object File, sử dụng tên của file như kỹ sư, giống như trong ví dụ này:

File bookName = new File(“address.dat”);

Tạo một object với tên là address.dat trong folder hiện tại. Bạn có thể bao gồm đường dẫn tới file:

File bookName = new File(“data\\address.dat”);

Khi bạn có một object File, bạn có thể gọi một vài phương thức hữu dụng trên đối tượng:

exists(0 – đúng nếu file tồn tại, sai nếu không

getName() – Tên của file, là ký tự.

length() – cỡ của file, như giá trị long

createNewFile() – Tạo một file với tên, nếu một file được tạo không tồn tại.

delete() – xóa file, nếu nó tồn tại

renameTo(File) – Đổi tên file, sử dụng tên của object File đặc biết giống như đối số.

Bạn cũng có thể sử dụng object File đại diện cho một folder trên hệ thống của bạn hơn là một file. Tên folder đặc biệt trong File constructor, cái mà có thể tuyệt đối (“C:\\MyDocuments\\”) hoắc tương đối (“java\\database”).

Sau khi bạn có một object đại điện một folder, bạn có thể gọi phương thức listFiles() để xem bên trong folder có gì. Phương thức này trả về một mảng của object File đại điện cho mọi file và folder con nó chứa.

Đọc dữ liệu từ một Stream

Bạn có thể sử dụng class FileInputStream, đại diện input stream là đọc bytes từ một file.

Bạn có thể tạo một file input stream bằng tên file hoặc một object File như đối số bằng phương thức FileInputStream().

File phải tồn tại trước khi file input stream đã tạo. Nếu nó không một IOException được tạo ra khi bạn cố gắng tạo stream. Nhiều phương thức liên quan đến đọc và ghi file tạo ngoại lệ này, như vậy nó thường thuận lợi để đặt tất cả nhứng câu lệnh bao hàm file trong block try-catch, như ví dụ bên dưới:

 

try {

                File cookie = new File(“cookie.web”);

                FileInputStream stream = new FileInputStream(cookie);

                System.out.println(“Length of file: “ + cookie.length());

} catch (IOException e) {

                System.out.println(“Could not read file. “);

}

File input streams đọc dữ liệu trong bytes. Bạn có thể đọc single byte bằng cách gọi phương thức read() không cần đối số. Nếu không có bytes biến trong stream bạn kết thúc file, một giá trị trả về là -1.

Khi bạn đọc một input stream, nó bắt đầu với byte đầu tiên trong stream, giống như byte đầu tiên trong một file. Bạn có thể bỏ qua một vài byte trong stream bằng cách gọi phương thức skip() với một đối số: một int đang đại diện của bytes được bỏ qua. Câu lệnh tiếp theo bỏ qua 1024 bytes trong stream tên scanData.

scanData.skip(1024);

Nếu bạn muốn đọc nhiều hơn một byte ở một thời điểm, làm các bước sau:

  • Tạo một mảng byte chính xác sơ của số byte bạn muốn đọc
  • Gọi phương thức read() của stream với mảng đó giống một đối số. Mảng thì được lấp đầy  (fill) với bytes đọc từ stream.

Bạn tạo một ứng dụng đọc dữ liệu ID3 từ một file MP3. Bởi vì MP3 là định dạng phổ biến cho file nhạc, 128 bytes thường đã được thêm để kết thúc một ID3 file cho những thông tin về bài hát, giống như title, artist, và album.

Ứng dụng ID3Reader  đọc một file MP3 sử dụng một input stream file, bỏ qua mọi thứ trừ bytes 128 cuối. Những bytes còn lại đã được kiểm tra để xem nếu chúng chứa dữ liệu ID3. Nếu chạy ba bytes đầu tiên có số là 84, 65, và 71.

Tạo một java file ID3Reader:

import java.io.*;

 

public class ID3Reader {

    public static void main(String[] arguments) {

        try {

            File song = new File(arguments[0]);

            FileInputStream file = new FileInputStream(song);

            int size = (int) song.length();

            file.skip(size - 128);

            byte[] last128 = new byte[128];

            file.read(last128);

            String id3 = new String(last128);

            String tag = id3.substring(0,3);

            if (tag.equals("TAG")) {

                System.out.println("Title: " + id3.substring(3, 32));

                System.out.println("Artist: " + id3.substring(33, 62));

                System.out.println("Title: " + id3.substring(63, 91));

                System.out.println("Year: " + id3.substring(93, 97));               

            } else {

                System.out.println(arguments[0] + " does not contain" + " ID3 info.");

                }

            file.close();

        } catch (Exception e) {

            System.out.println("Error -- " + e.toString());

            }

        }

}

Trước khi chạy class giống như một ứng dụng, bạn phải chỉ định một file MP3 giống như một đối số dòng lệnh. Chương trình có thể chạy với một vài file MP3, giống như Come On và Gettit.mp3, đừng quên 1973 thể loại classic bơi Marion Black. Nếu bạn có bài hát Come On và Gettit.mp3 trên hệ thống. Ứng dụng sẽ hiển thị như bên dưới.

Ứng dụng đọc bytes 128 cuối từ MP3 trong dòng 10-11, chứa chúng trong một mảng byte. Mảng này được sử dụng trong dong 12 để tạo một object String chứa ký tự đại diện bởi những bytes đó.

Nếu ba ký tự đầu thiên trong chuỗi là “TAG”, file MP3 đã được kiểm tra chưa thông tin ID3 trong định dạng ứng dụng hiểu.

Trong dòng 15-18, phương thức substring() được gọi để hiển thị lựa chọn chuỗi. Ký tự để hiển thị là từ định dạng ID3, luôn đặt thông tin artist, song, title, và year  trong cùng vị trị ở bytes 128 cuối cùng của một file MP3.

Một vài file MP3 khác không chứa thông tin ID3 ở tất cả hoặc chứa thông tin ID3 trong định dạng khác với ứng dụng có thể đọc.

File Come on and Gettit.mp3 chứa thông tin ID3 có thể đọc nếu bạn tạo nó từ một CD Eccentric bạn mua bởi vì chương trình đó tạo file MP3 từ việc đọc thông tin bài hát CD audio từ một ngành công nghiệp âm nhạc được gọi là CDDB.

Sau khi mọi thứ liên quan đến thông tin ID3 có thể đọc từ imput stream của file MP3, tream được đống trong dòng 23. Bạn nên luôn luôn đóng stream khi kết thục làm việc với chúng để bao toàn tài nguyên trong biên dịch Java.

 

Bộ đệm của Input Streams

Một cách để cái thiện thực thi (performance) của chương trình đọc input stream là đặt input tới bộ đệm. Đệm là xử lý lưu dũ liệu trong bộ nhớ cho việc sử dụng sau khi chương trình cần nó. Khi một chương trình Java cần dữ liệu từ bộ đệm input stream, nó tìm trong bộ đệm đầu tiên, nó thì nhanh hơn đọc từ tài nguyên giống như file.

Để sử dụng đệm input stream, bạn tạo một input stream giống nhuwlaf một object FileInputStream, và sau đó sự dụng object để tạo bộ đệm stream. Gọi BufferedInputStram(InputStream) với input stream như đối số. Dữ liệu là bộ đêm nó đọc từ input stream.

Để đọc từ một đệm stream, gọi phương thức read() không đối số. Một số nguyên từ 0 đến 255 được trả về và đại diện byte tiếp của dữ liệu trong stream. Nếu không có byte nó trả về -1.

Để chứng minh đệm stream, chương trình tiếp theo bạn tạo them một tính năng cho Java mà nhiều lập trình viên lỗi từ ngôn ngũ khác họ có sử dụng: console input.

Console input có thể đọc ký tự từ console trong khi đang chạy một ứng dụng.

Class System chứa biến out sự dụng trong câu lệnh System.out.print() và System.out.println() , có một lớp biến được gọi đại diện một object InputStream. Object nay nhận input từ bàn phám và tạo thành biến giống một stream.

Bạn có thể làm việc với input stream này giống như với một vài cái khác. Câu lệnh tạo đệm input stream liên kết với System.in input stream:

BuffedInputStream bin = new BufferedInputStream(System.in);

Dự án tiếp theo, class Console, chưa một phương thức bạn có thể sử dụng để nhận input console trong một vài ứng dụng Java của bạn.

import java.io.*;

 

public class Console {

    public static String readLine() {

        StringBuffer response = new StringBuffer();

        try {

            BufferedInputStream bin = new BufferedInputStream(System.in);

            int in = 0;

            char inChar;

            do {

                in = bin.read();

                inChar = (char) in;

                if (in != -1) {

                    response.append(inChar);

                    }               

                } while ((in != 1) & (inChar != '\n'));

            bin.close();

            return response.toString();   

        } catch (IOException e) {

            System.out.println("Exception: " + e.getMessage());

            return null;

            }

        }

   

    public static void main(String[] arguments) {

        System.out.print("You are standing at the end of the road ");

        System.out.print("before a small brick building. Around you ");

        System.out.print("is a forest. A small stream flows out of ");

        System.out.println("the building and down a gully. \n");

        System.out.print(">");

        String input = Console.readLine();

        System.out.println("That's not a verb I recognize.");

    }

}

Ghi dữ liệu tới một Stream

Trong gói java.io, class làm việc với stream đến thiết lập phù hợp. Đó là class FileInputStream và FileOutputStream làm việc với byte streames, class FileReader và FileWriter làm việc với stream ký tự, và nhiều cái thiết lập khác cho dữ liệu stream kiểu khác.

Để bắt đầu ghi dữ liệu, đâu tiên bạn tọa một object File liên kết với output stream. File này không phải tồn tại trên hệ thống của bạn.

Bạn có thể tạo một FileOutputStream bằng hai cách. Nếu bạn muốn gắn vào byte trên một file đã tồn tại, gọi phương thức FileOutputStream() với hai đối số: a object File đại diện cho file và Boolean là true. Bytes bạn viết tới stream thì đã được thay đổi trên kết thúc của file.

Sauk hi bạn có một output stream, bạn có thể gọi phương thức khác để viết byte tới nó:

  • Gọi write() với một byte giống như là đối số đối số để viết byte đó tới stream.
  • Gọi write() với mảng byte giống như là đối số duy nhật để viết tất cả mảng byte tới stream.
  • Ghi rõ ba đối số tới phương thức write(byte[], int, int) một mảng byte, một đại diện số nguyên cho thành phần đầu tiên của mảng để viết tới stream, và một số của bytes để viết.

Ví dụ:

File dat = new File(“data.dat”);

FileOutputStream datStream = new FileOutputStream(dat);

byte[] data = new byte[] {5, 36 , 23, 9, 78, 6, 14, 9, 25, 1};

datStream.write(data, 5, 5);

Khi bạn viết byte tới stream, bạn có thể chuyển đổi text tới một mảng của byte gọi phương thức getByte() của object String.

Ex:

String name = “Puddin N. Tane”;

byte[] nameBytes = name.getBytes();

Sau khi bạn kết thúc viết byte tới stream, bạn đóng gọi stream bằng phương thức close().

// Viết một ứng dụng đơn giản, ConfigWriter lưu một vài dòng text tới một file viết byte tới file output stream.

import java.io.*;

 

public class ConfigWriter {

    String newline = System.getProperty("line.separator");

    ConfigWriter() {

        try {

            File file = new File("program.properties");

            FileOutputStream fileStream = new FileOutputStream(file);

            write(fileStream, "username=max");

            write(fileStream, "score=12550");

            write(fileStream, "level=5");

        } catch (IOException ioe) {

            System.out.println("Could not write file");

            }

        }

    void write(FileOutputStream stream, String output)

    throws IOException {

        output = output + newline;

        byte[] data = output.getBytes();

        stream.write(data, 0, data.length);

        }

   

    public static void main(String[] arguments) {

        ConfigWriter cw = new ConfigWriter();

        }

}

Khi chương trình này chạy, nọt tạo một file gọi là program.properties chứa ba dòng text.

username=max

score=12550

level=5

 

Đọc và ghi cấu hình thuộc tính

Một chương trình java rất nhiều linh hoạt khi chúng có thể cấu hình sử dụng đối số command-line, giống như bạn chứng minh một vài ứng dụng đã tạo bên trên. Gói java.util bao gồm một class, Properties cho phép thiết lập cấu hình để load từ tài nguyên khác: một file text.

File có thể đọc như các nguồn khác trong Java: 

  • Tạo một object file đại diện cho file
  • Tạo một object FileInputStream từ object File đó..
  • Gọi load() nhận thuộc tính (properties) từ input stream đó.

Một properties file được thiết lập một thuộc tính tên bằng cách gán bằng (=) cho giá trị của nó.

username=lepton

lastCommand=open database

windowSize=32

Mỗi thuộc tính có một dòng, như vậy theiets lập thuộc tính này tên username, lastCommand, và windowSize với giá trị “lepton”, “open database”, và “32”,  tương ứng. ( Giống định dạng đã sử dụng bởi class ConfigWriter)

Dưới đây là code load một file thuộc tính properties gọi là config.dat:

File configFile = new File(“config.dat”);

FileInputStream inStream = new FileInputStream(configFile);

Properties config = new Properties();

Config.load(inStream);

Thiết lập cấu hình, cái được gọi là properties, chứa chuối trong object Properties. Mỗi thuộc tình định nghĩa bởi một key giống tham số applet. Phương thức getProperty() nhận một thuộc tính đang sử dụng key đó, giống câu lệnh dưới:

String username = config.getProperty(“username”);

Bởi vì thuộc tính chứa giống như chuỗi, bạn phải chuyển đổi chúng trong một vài cánh sử dụng giá trị số, giống code bên dưới:

String windowProp = config.getProperty(“windowSize”);

Int windowSize = 24;

try {

                windowSize = Integer.parseInt(windowProp);

} catch  (NumberFormatException exception) {

                // do nothing

}

Thuộc tính có thể đã được lưu trữ đang gọi phương thức setProperty() với hai đối số:

config.setProperty(“username”, “max”);

Bạn có thể hiển thị tất cả các phương thức bằng cách gọi phương thức list(PrintStream) của object Properties. PrintStream là class biến ngoài của class System, cái mà bạn đang sử dụng để hiện thị ra ngoài trong câu lệnh System.out.println().

config.list(System.out);

Sauk hi bạn thay đổi thuộc tính bạn có thể chứa chúng trở lại file:

  • Tạo một object File đại diện cho file.
  • Tạo một object FileOutputStream từ object File.
  • Gọi store(OutputStream, String) để  lưu thuộc tính tới thiết kế stream ngoài với miêu tả thuộc tinh file giống chuỗi.

Ví du:

import java.io.*;

import java.util.*;

 

class Configurator {

    Configurator() {

        try {

            // load the properties file

            File configFile = new File("program.properties");

            FileInputStream inStream = new FileInputStream(configFile);

            config.load(inStream);

            // create a new property

            Date current = new Date();

            config.setProperty("runtime", current.toString());

            // save the properties file

            FileOutputStream outStream = new FileOutputStream(configFile);

            config.store(outStream, "Properties settings");

            inStream.close();

            config.list(System.out);

        } catch (IOException ioe) {

            System.out.println("IO error " + ioe.getMessage());

            }

        }

    public static void main(String[] arguments) {

        Configurator con = new Configurator();

        }

}

 

Translate: java 24h