Java API —— IO流小結

 

練習題：

1、復制文本文件

package cn.itcast_01;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
 * 復制文本文件
 * 
 * 分析：
 *         復制數據，如果我們知道用記事本打開並能夠讀懂，就用字符流，否則用字節流。
 *         通過該原理，我們知道我們應該采用字符流更方便一些。
 *         而字符流有5種方式，所以做這個題目我們有5種方式。推薦掌握第5種。
 * 數據源：
 *         c:\\a.txt -- FileReader -- BufferdReader
 * 目的地：
 *         d:\\b.txt -- FileWriter -- BufferedWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        String srcString = "c:\\a.txt";
        String destString = "d:\\b.txt";
        // method1(srcString, destString);
        // method2(srcString, destString);
        // method3(srcString, destString);
        // method4(srcString, destString);
        method5(srcString, destString);
    }
    // 字符緩沖流一次讀寫一個字符串
    private static void method5(String srcString, String destString)
            throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcString));
        BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
        String line = null;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        bw.close();
        br.close();
    }
    // 字符緩沖流一次讀寫一個字符數組
    private static void method4(String srcString, String destString)
            throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcString));
        BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
        char[] chs = new char[1024];
        int len = 0;
        while ((len = br.read(chs)) != -1) {
            bw.write(chs, 0, len);
        }
        bw.close();
        br.close();
    }
    // 字符緩沖流一次讀寫一個字符
    private static void method3(String srcString, String destString)
            throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcString));
        BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
        int ch = 0;
        while ((ch = br.read()) != -1) {
            bw.write(ch);
        }
        bw.close();
        br.close();
    }
    // 基本字符流一次讀寫一個字符數組
    private static void method2(String srcString, String destString)
            throws IOException {
        FileReader fr = new FileReader(srcString);
        FileWriter fw = new FileWriter(destString);
        char[] chs = new char[1024];
        int len = 0;
        while ((len = fr.read(chs)) != -1) {
            fw.write(chs, 0, len);
        }
        fw.close();
        fr.close();
    }
    // 基本字符流一次讀寫一個字符
    private static void method1(String srcString, String destString)
            throws IOException {
        FileReader fr = new FileReader(srcString);
        FileWriter fw = new FileWriter(destString);
        int ch = 0;
        while ((ch = fr.read()) != -1) {
            fw.write(ch);
        }
        fw.close();
        fr.close();
    }
}

 

2、復制圖片

package cn.itcast_01;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 復制圖片
 * 
 * 分析：
 *         復制數據，如果我們知道用記事本打開並能夠讀懂，就用字符流，否則用字節流。
 *         通過該原理，我們知道我們應該采用字節流。
 *         而字節流有4種方式，所以做這個題目我們有4種方式。推薦掌握第4種。
 * 
 * 數據源：
 *         c:\\a.jpg -- FileInputStream -- BufferedInputStream
 * 目的地：
 *         d:\\b.jpg -- FileOutputStream -- BufferedOutputStream
 */
public class CopyImageDemo {
    public static void main(String[] args) throws IOException {
        // 使用字符串作為路徑
        // String srcString = "c:\\a.jpg";
        // String destString = "d:\\b.jpg";
        // 使用File對象做為參數
        File srcFile = new File("c:\\a.jpg");
        File destFile = new File("d:\\b.jpg");
        // method1(srcFile, destFile);
        // method2(srcFile, destFile);
        // method3(srcFile, destFile);
        method4(srcFile, destFile);
    }
    // 字節緩沖流一次讀寫一個字節數組
    private static void method4(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destFile));
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }
        bos.close();
        bis.close();
    }
    // 字節緩沖流一次讀寫一個字節
    private static void method3(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destFile));
        int by = 0;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }
        bos.close();
        bis.close();
    }
    // 基本字節流一次讀寫一個字節數組
    private static void method2(File srcFile, File destFile) throws IOException {
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        fos.close();
        fis.close();
    }
    // 基本字節流一次讀寫一個字節
    private static void method1(File srcFile, File destFile) throws IOException {
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);
        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        fos.close();
        fis.close();
    }
}

  

3、把ArrayList集合中的字符串數據存儲到文本文件

package cn.itcast_02;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
/*
 * 需求：把ArrayList集合中的字符串數據存儲到文本文件
 * 
 * 分析：
 *         通過題目的意思我們可以知道如下的一些內容，
 *             ArrayList集合里存儲的是字符串。
 *             遍歷ArrayList集合，把數據獲取到。
 *             然后存儲到文本文件中。
 *             文本文件說明使用字符流。
 * 
 * 數據源：
 *         ArrayList<String> -- 遍歷得到每一個字符串數據
 * 目的地：
 *         a.txt -- FileWriter -- BufferedWriter
 */
public class ArrayListToFileDemo {
    public static void main(String[] args) throws IOException {
        // 封裝數據與(創建集合對象)
        ArrayList<String> array = new ArrayList<String>();
        array.add("hello");
        array.add("world");
        array.add("java");
        // 封裝目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
        // 遍歷集合
        for (String s : array) {
            // 寫數據
            bw.write(s);
            bw.newLine();
            bw.flush();
        }
        // 釋放資源
        bw.close();
    }
}

  

4、從文本文件中讀取數據(每一行為一個字符串數據)到集合中，並遍歷集合

package cn.itcast_02;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
/*
 * 需求：從文本文件中讀取數據(每一行為一個字符串數據)到集合中，並遍歷集合
 * 
 * 分析：
 *         通過題目的意思我們可以知道如下的一些內容，
 *             數據源是一個文本文件。
 *             目的地是一個集合。
 *             而且元素是字符串。
 * 
 * 數據源：
 *         b.txt -- FileReader -- BufferedReader
 * 目的地：
 *         ArrayList<String>
 */
public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
        // 封裝數據源
        BufferedReader br = new BufferedReader(new FileReader("b.txt"));
        // 封裝目的地(創建集合對象)
        ArrayList<String> array = new ArrayList<String>();
        // 讀取數據存儲到集合中
        String line = null;
        while ((line = br.readLine()) != null) {
            array.add(line);
        }
        // 釋放資源
        br.close();
        // 遍歷集合
        for (String s : array) {
            System.out.println(s);
        }
    }
}

  

5、隨機獲取文本文件中的姓名案例

package cn.itcast_02;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;
/*
 * 需求：我有一個文本文件中存儲了幾個名稱，請大家寫一個程序實現隨機獲取一個人的名字。
 * 
 * 分析：
 *         A:把文本文件中的數據存儲到集合中
 *         B:隨機產生一個索引
 *         C:根據該索引獲取一個值
 */
public class GetName {
    public static void main(String[] args) throws IOException {
        // 把文本文件中的數據存儲到集合中
        BufferedReader br = new BufferedReader(new FileReader("b.txt"));
        ArrayList<String> array = new ArrayList<String>();
        String line = null;
        while ((line = br.readLine()) != null) {
            array.add(line);
        }
        br.close();
        // 隨機產生一個索引
        Random r = new Random();
        int index = r.nextInt(array.size());
        // 根據該索引獲取一個值
        String name = array.get(index);
        System.out.println("該幸運者是：" + name);
    }
}

 

 6、復制單級文件夾（文件夾下全是文件）

package cn.itcast_03;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：復制單極文件夾
 * 
 * 數據源：e:\\demo
 * 目的地：e:\\test
 * 
 * 分析：
 *         A:封裝目錄
 *         B:獲取該目錄下的所有文本的File數組
 *         C:遍歷該File數組，得到每一個File對象
 *         D:把該File進行復制
 */
public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
        // 封裝目錄
        File srcFolder = new File("e:\\demo");
        // 封裝目的地
        File destFolder = new File("e:\\test");
        // 如果目的地文件夾不存在，就創建
        if (!destFolder.exists()) {
            destFolder.mkdir();
        }
        // 獲取該目錄下的所有文本的File數組
        File[] fileArray = srcFolder.listFiles();
        // 遍歷該File數組，得到每一個File對象
        for (File file : fileArray) {
            // System.out.println(file);
            // 數據源：e:\\demo\\e.mp3
            // 目的地：e:\\test\\e.mp3
            String name = file.getName(); // e.mp3
            File newFile = new File(destFolder, name); // e:\\test\\e.mp3
            copyFile(file, newFile);
        }
    }
    private static void copyFile(File file, File newFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                file));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(newFile));
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }
        bos.close();
        bis.close();
    }
}

 

7、復制單級文件夾中指定文件並修改文件名稱

package cn.itcast_04;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
/*
 * 需求：復制指定目錄下的指定文件，並修改后綴名。
 * 指定的文件是：.java文件。
 * 指定的后綴名是：.jad
 * 指定的目錄是：jad
 * 
 * 數據源：e:\\java\\A.java
 * 目的地：e:\\jad\\A.jad
 * 
 * 分析：
 *         A:封裝目錄
 *         B:獲取該目錄下的java文件的File數組
 *         C:遍歷該File數組，得到每一個File對象
 *         D:把該File進行復制
 *         E:在目的地目錄下改名
 */
public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
        // 封裝目錄
        File srcFolder = new File("e:\\java");
        // 封裝目的地
        File destFolder = new File("e:\\jad");
        // 如果目的地目錄不存在，就創建
        if (!destFolder.exists()) {
            destFolder.mkdir();
        }
        // 獲取該目錄下的java文件的File數組
        File[] fileArray = srcFolder.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir, name).isFile() && name.endsWith(".java");
            }
        });
        // 遍歷該File數組，得到每一個File對象
        for (File file : fileArray) {
            // System.out.println(file);
            // 數據源：e:\java\DataTypeDemo.java
            // 目的地：e:\\jad\DataTypeDemo.java
            String name = file.getName();
            File newFile = new File(destFolder, name);
            copyFile(file, newFile);
        }
        // 在目的地目錄下改名
        File[] destFileArray = destFolder.listFiles();
        for (File destFile : destFileArray) {
            // System.out.println(destFile);
            // e:\jad\DataTypeDemo.java
            // e:\\jad\\DataTypeDemo.jad
            String name =destFile.getName(); //DataTypeDemo.java
            String newName = name.replace(".java", ".jad");//DataTypeDemo.jad
            
            File newFile = new File(destFolder,newName);
            destFile.renameTo(newFile);
        }
    }
    private static void copyFile(File file, File newFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                file));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(newFile));
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }
        bos.close();
        bis.close();
    }
}

  

8、復制多級文件夾

package cn.itcast_05;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：復制多極文件夾
 * 
 * 數據源：E:\JavaSE\day21\code\demos
 * 目的地：E:\\
 * 
 * 分析：
 *         A:封裝數據源File
 *         B:封裝目的地File
 *         C:判斷該File是文件夾還是文件
 *             a:是文件夾
 *                 就在目的地目錄下創建該文件夾
 *                 獲取該File對象下的所有文件或者文件夾File對象
 *                 遍歷得到每一個File對象
 *                 回到C
 *             b:是文件
 *                 就復制(字節流)
 */
public class CopyFoldersDemo {
    public static void main(String[] args) throws IOException {
        // 封裝數據源File
        File srcFile = new File("E:\\JavaSE\\day21\\code\\demos");
        // 封裝目的地File
        File destFile = new File("E:\\");
        // 復制文件夾的功能
        copyFolder(srcFile, destFile);
    }
    private static void copyFolder(File srcFile, File destFile)
            throws IOException {
        // 判斷該File是文件夾還是文件
        if (srcFile.isDirectory()) {
            // 文件夾
            File newFolder = new File(destFile, srcFile.getName());
            newFolder.mkdir();
            // 獲取該File對象下的所有文件或者文件夾File對象
            File[] fileArray = srcFile.listFiles();
            for (File file : fileArray) {
                copyFolder(file, newFolder);
            }
        } else {
            // 文件
            File newFile = new File(destFile, srcFile.getName());
            copyFile(srcFile, newFile);
        }
    }
    private static void copyFile(File srcFile, File newFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(newFile));
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }
        bos.close();
        bis.close();
    }
}

  

9、鍵盤錄入5個學生信息(姓名,語文成績,數學成績,英語成績),按照總分從高到低存入文本文件

學生類：

package cn.itcast_06;
public class Student {
    // 姓名
    private String name;
    // 語文成績
    private int chinese;
    // 數學成績
    private int math;
    // 英語成績
    private int english;
    public Student() {
        super();
    }
    public Student(String name, int chinese, int math, int english) {
        super();
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getChinese() {
        return chinese;
    }
    public void setChinese(int chinese) {
        this.chinese = chinese;
    }
    public int getMath() {
        return math;
    }
    public void setMath(int math) {
        this.math = math;
    }
    public int getEnglish() {
        return english;
    }
    public void setEnglish(int english) {
        this.english = english;
    }
    public int getSum() {
        return this.chinese + this.math + this.english;
    }
}

測試類：

package cn.itcast_06;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
/*
 * 鍵盤錄入5個學生信息(姓名,語文成績,數學成績,英語成績),按照總分從高到低存入文本文件
 * 
 * 分析：
 *         A:創建學生類
 *         B:創建集合對象
 *             TreeSet<Student>
 *         C:鍵盤錄入學生信息存儲到集合
 *         D:遍歷集合，把數據寫到文本文件
 */
public class StudentDemo {
    public static void main(String[] args) throws IOException {
        // 創建集合對象
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s2.getSum() - s1.getSum();
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
                int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3;
                int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName())
                        : num4;
                return num5;
            }
        });
        // 鍵盤錄入學生信息存儲到集合
        for (int x = 1; x <= 5; x++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("請錄入第" + x + "個的學習信息");
            System.out.println("姓名：");
            String name = sc.nextLine();
            System.out.println("語文成績：");
            int chinese = sc.nextInt();
            System.out.println("數學成績：");
            int math = sc.nextInt();
            System.out.println("英語成績：");
            int english = sc.nextInt();
            // 創建學生對象
            Student s = new Student();
            s.setName(name);
            s.setChinese(chinese);
            s.setMath(math);
            s.setEnglish(english);
            // 把學生信息添加到集合
            ts.add(s);
        }
        // 遍歷集合，把數據寫到文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("students.txt"));
        bw.write("學生信息如下：");
        bw.newLine();
        bw.flush();
        bw.write("姓名,語文成績,數學成績,英語成績");
        bw.newLine();
        bw.flush();
        for (Student s : ts) {
            StringBuilder sb = new StringBuilder();
            sb.append(s.getName()).append(",").append(s.getChinese())
                    .append(",").append(s.getMath()).append(",")
                    .append(s.getEnglish());
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        // 釋放資源
        bw.close();
        System.out.println("學習信息存儲完畢");
    }
}

  

10、已知s.txt文件中有這樣的一個字符串：“hcexfgijkamdnoqrzstuvwybpl”。請編寫程序讀取數據內容，把數據排序后寫入ss.txt中。

package cn.itcast_07;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
/*
 * 已知s.txt文件中有這樣的一個字符串：“hcexfgijkamdnoqrzstuvwybpl”
 * 請編寫程序讀取數據內容，把數據排序后寫入ss.txt中。
 * 
 * 分析：
 *         A:把s.txt這個文件給做出來
 *         B:讀取該文件的內容，存儲到一個字符串中
 *         C:把字符串轉換為字符數組
 *         D:對字符數組進行排序
 *         E:把排序后的字符數組轉換為字符串
 *         F:把字符串再次寫入ss.txt中
 */
public class StringDemo {
    public static void main(String[] args) throws IOException {
        // 讀取該文件的內容，存儲到一個字符串中
        BufferedReader br = new BufferedReader(new FileReader("s.txt"));
        String line = br.readLine();
        br.close();
        // 把字符串轉換為字符數組
        char[] chs = line.toCharArray();
        // 對字符數組進行排序
        Arrays.sort(chs);
        // 把排序后的字符數組轉換為字符串
        String s = new String(chs);
        // 把字符串再次寫入ss.txt中
        BufferedWriter bw = new BufferedWriter(new FileWriter("ss.txt"));
        bw.write(s);
        bw.newLine();
        bw.flush();
        bw.close();
    }
}

 

11、用Reader模擬BufferedReader的readLine()功能

自定義類：

package cn.itcast_08;
import java.io.IOException;
import java.io.Reader;
/*
 * 用Reader模擬BufferedReader的readLine()功能
 * 
 * readLine():一次讀取一行，根據換行符判斷是否結束，只返回內容，不返回換行符
 */
public class MyBufferedReader {
    private Reader r;
    public MyBufferedReader(Reader r) {
        this.r = r;
    }
    /*
     * 思考：寫一個方法，返回值是一個字符串。
     */
    public String readLine() throws IOException {
        /*
         * 我要返回一個字符串，我該怎么辦呢? 我們必須去看看r對象能夠讀取什么東西呢? 兩個讀取方法，一次讀取一個字符或者一次讀取一個字符數組
         * 那么，我們要返回一個字符串，用哪個方法比較好呢? 我們很容易想到字符數組比較好，但是問題來了，就是這個數組的長度是多長呢?
         * 根本就沒有辦法定義數組的長度，你定義多長都不合適。 所以，只能選擇一次讀取一個字符。
         * 但是呢，這種方式的時候，我們再讀取下一個字符的時候，上一個字符就丟失了 所以，我們又應該定義一個臨時存儲空間把讀取過的字符給存儲起來。
         * 這個用誰比較和是呢?數組，集合，字符串緩沖區三個可供選擇。
         * 經過簡單的分析，最終選擇使用字符串緩沖區對象。並且使用的是StringBuilder
         */
        StringBuilder sb = new StringBuilder();
        // 做這個讀取最麻煩的是判斷結束，但是在結束之前應該是一直讀取，直到-1
        
        
        /*
        hello
        world
        java    
        
        104101108108111
        119111114108100
        1069711897
         */
        
        int ch = 0;
        while ((ch = r.read()) != -1) { //104,101,108,108,111
            if (ch == '\r') {
                continue;
            }
            if (ch == '\n') {
                return sb.toString(); //hello
            } else {
                sb.append((char)ch); //hello
            }
        }
        // 為了防止數據丟失，判斷sb的長度不能大於0
        if (sb.length() > 0) {
            return sb.toString();
        }
        return null;
    }
    /*
     * 先寫一個關閉方法
     */
    public void close() throws IOException {
        this.r.close();
    }
}

測試類：

package cn.itcast_08;
import java.io.FileReader;
import java.io.IOException;
/*
 * 測試MyBufferedReader的時候，你就把它當作BufferedReader一樣的使用
 */
public class MyBufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        MyBufferedReader mbr = new MyBufferedReader(new FileReader("my.txt"));
        String line = null;
        while ((line = mbr.readLine()) != null) {
            System.out.println(line);
        }
        mbr.close();
        // System.out.println('\r' + 0); // 13
        // System.out.println('\n' + 0);// 10
    }
}

  

12、自定義類模擬LineNumberReader的特有功能：獲取每次讀取數據的行號

LineNumberReader 類測試：

package cn.itcast_09;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
/*
 * BufferedReader
 *         |--LineNumberReader
 *             public int getLineNumber()獲得當前行號。 
 *             public void setLineNumber(int lineNumber)
 */
public class LineNumberReaderDemo {
    public static void main(String[] args) throws IOException {
        LineNumberReader lnr = new LineNumberReader(new FileReader("my.txt"));
        // 從10開始才比較好
        // lnr.setLineNumber(10);
        // System.out.println(lnr.getLineNumber());
        // System.out.println(lnr.getLineNumber());
        // System.out.println(lnr.getLineNumber());
        String line = null;
        while ((line = lnr.readLine()) != null) {
            System.out.println(lnr.getLineNumber() + ":" + line);
        }
        lnr.close();
    }
}

 自定義LineNumberReader類版本一：

package cn.itcast_09;

import java.io.IOException;
import java.io.Reader;

public class MyLineNumberReader {
    private Reader r;
    private int lineNumber = 0;

    public MyLineNumberReader(Reader r) {
        this.r = r;
    }

    public int getLineNumber() {
        // lineNumber++;
        return lineNumber;
    }

    public void setLineNumber(int lineNumber) {
        this.lineNumber = lineNumber;
    }

    public String readLine() throws IOException {
        lineNumber++;

        StringBuilder sb = new StringBuilder();

        int ch = 0;
        while ((ch = r.read()) != -1) {
            if (ch == '\r') {
                continue;
            }

            if (ch == '\n') {
                return sb.toString();
            } else {
                sb.append((char) ch);
            }
        }

        if (sb.length() > 0) {
            return sb.toString();
        }

        return null;
    }

    public void close() throws IOException {
        this.r.close();
    }
}

 自定義LineNumberReader類改進版：

package cn.itcast_09;

import java.io.IOException;
import java.io.Reader;

import cn.itcast_08.MyBufferedReader;

public class MyLineNumberReader2 extends MyBufferedReader {
    private Reader r;

    private int lineNumber = 0;

    public MyLineNumberReader2(Reader r) {
        super(r);
    }

    public int getLineNumber() {
        return lineNumber;
    }

    public void setLineNumber(int lineNumber) {
        this.lineNumber = lineNumber;
    }

    @Override
    public String readLine() throws IOException {
        lineNumber++;
        return super.readLine();
    }
}

 測試類：

package cn.itcast_09;

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

public class MyLineNumberReaderTest {
    public static void main(String[] args) throws IOException {
        // MyLineNumberReader mlnr = new MyLineNumberReader(new FileReader(
        // "my.txt"));

        MyLineNumberReader2 mlnr = new MyLineNumberReader2(new FileReader(
                "my.txt"));

        // mlnr.setLineNumber(10);

        // System.out.println(mlnr.getLineNumber());
        // System.out.println(mlnr.getLineNumber());
        // System.out.println(mlnr.getLineNumber());

        String line = null;
        while ((line = mlnr.readLine()) != null) {
            System.out.println(mlnr.getLineNumber() + ":" + line);
        }

        mlnr.close();
    }
}