* 查看FileOutputStream的构造方法:
*
* FileOutputStream(File file)
* FileOutputStream(String name)
*
* 字节输出流操作步骤:
* A:创建字节输出流对象
* B:写数据
* C:释放资源
1 // 创建字节输出流对象 2 // FileOutputStream(File file) 3 // File file = new File("fos.txt"); 4 // FileOutputStream fos = new FileOutputStream(file); 5 // FileOutputStream(String name) 6 FileOutputStream fos = new FileOutputStream("fos.txt"); 7 /* 8 * 创建字节输出流对象了做了几件事情: 9 * A:调用系统功能去创建文件 10 * B:创建fos对象 11 * C:把fos对象指向这个文件 12 */ 13 14 //写数据 15 fos.write("hello,IO".getBytes()); 16 fos.write("java".getBytes()); 17 18 //释放资源 19 //关闭此文件输出流并释放与此流有关的所有系统资源。 20 fos.close(); 21 /* 22 * 为什么一定要close()呢? 23 * A:让流对象变成垃圾,这样就可以被垃圾回收器回收了 24 * B:通知系统去释放跟该文件相关的资源 25 */ 26 //java.io.IOException: Stream Closed 27 //fos.write("java".getBytes());
* 字节输出流操作步骤:
* A:创建字节输出流对象
* B:调用write()方法
* C:释放资源
*
* public void write(int b):写一个字节
* public void write(byte[] b):写一个字节数组
* public void write(byte[] b,int off,int len):写一个字节数组的一部分
1 // 创建字节输出流对象 2 // OutputStream os = new FileOutputStream("fos2.txt"); // 多态 3 FileOutputStream fos = new FileOutputStream("fos2.txt"); 4 5 // 调用write()方法 6 //fos.write(97); //97 -- 底层二进制数据 -- 通过记事本打开 -- 找97对应的字符值 -- a 7 // fos.write(57); 8 // fos.write(55); 9 10 //public void write(byte[] b):写一个字节数组 11 byte[] bys={97,98,99,100,101}; 12 fos.write(bys); 13 14 //public void write(byte[] b,int off,int len):写一个字节数组的一部分 15 fos.write(bys,1,3); 16 17 //释放资源 18 fos.close();
* 如何实现数据的换行?
* 为什么现在没有换行呢?因为你值写了字节数据,并没有写入换行符号。
* 如何实现呢?写入换行符号即可呗。
* 刚才我们看到了有写文本文件打开是可以的,通过windows自带的那个不行,为什么呢?
* 因为不同的系统针对不同的换行符号识别是不一样的?
* windows:
* linux:
* Mac:
* 而一些常见的个高级记事本,是可以识别任意换行符号的。
*
* 如何实现数据的追加写入?
* 用构造方法带第二个参数是true的情况即可
1 // 创建字节输出流对象 2 // FileOutputStream fos = new FileOutputStream("fos3.txt"); 3 // 创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为 true,则将字节写入文件末尾处,而不是写入文件开始处。 4 FileOutputStream fos = new FileOutputStream("fos3.txt", true); 5 6 // 写数据 7 for (int x = 0; x < 10; x++) { 8 fos.write(("hello" + x).getBytes()); 9 fos.write(" ".getBytes()); 10 } 11 12 // 释放资源 13 fos.close();
FileOutPutStream写出数据加入异常处理:
1 // 改进版 2 // 为了在finally里面能够看到该对象就必须定义到外面,为了访问不出问题,还必须给初始化值 3 FileOutputStream fos = null; 4 try { 5 // fos = new FileOutputStream("z:\fos4.txt"); 6 fos = new FileOutputStream("fos4.txt"); 7 fos.write("java".getBytes()); 8 } catch (FileNotFoundException e) { 9 e.printStackTrace(); 10 } catch (IOException e) { 11 e.printStackTrace(); 12 } finally { 13 // 如果fos不是null,才需要close() 14 if (fos != null) { 15 // 为了保证close()一定会执行,就放到这里了 16 try { 17 fos.close(); 18 } catch (IOException e) { 19 e.printStackTrace(); 20 } 21 } 22 }
* 字节输入流操作步骤:
* A:创建字节输入流对象
* B:调用read()方法读取数据,并把数据显示在控制台
* C:释放资源
*
* 读取数据的方式:
* A:int read():一次读取一个字节
* B:int read(byte[] b):一次读取一个字节数组
1 FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java"); 2 3 // 最终版代码 4 int by = 0; 5 // 读取,赋值,判断 6 while ((by = fis.read()) != -1) { 7 System.out.print((char) by); 8 } 9 10 // 释放资源 11 fis.close();
* 一次读取一个字节数组:int read(byte[] b)
* 返回值其实是实际读取的字节个数。
1 // 创建字节输入流对象 2 FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java"); 3 4 // 最终版代码 5 // 数组的长度一般是1024或者1024的整数倍 6 byte[] bys = new byte[1024]; 7 int len = 0; 8 while ((len = fis.read(bys)) != -1) { 9 System.out.print(new String(bys, 0, len)); 10 } 11 12 // 释放资源 13 fis.close();
* 计算机是如何识别什么时候该把两个字节转换为一个中文呢?
* 在计算机中中文的存储分两个字节:
* 第一个字节肯定是负数。
* 第二个字节常见的是负数,可能有正数。但是没影响。
1 String s = "我爱你中国"; 2 // [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6] 3 4 byte[] bys = s.getBytes(); 5 System.out.println(Arrays.toString(bys));
* 通过定义数组的方式确实比以前一次读取一个字节的方式快很多,所以,看来有一个缓冲区还是非常好的。
* 既然是这样的话,那么,java开始在设计的时候,它也考虑到了这个问题,就专门提供了带缓冲区的字节类。
* 这种类被称为:缓冲区类(高效类)
* 写数据:BufferedOutputStream
* 读数据:BufferedInputStream
*
* 构造方法可以指定缓冲区的大小,但是我们一般用不上,因为默认缓冲区大小就足够了。
*
* 为什么不传递一个具体的文件或者文件路径,而是传递一个OutputStream对象呢?
* 原因很简单,字节缓冲区流仅仅提供缓冲区,为高效而设计的。但是呢,真正的读写操作还得靠基本的流对象实现。
1 // BufferedInputStream(InputStream in) 2 BufferedInputStream bis = new BufferedInputStream(new FileInputStream( 3 "bos.txt")); 4 5 // 读取数据 6 byte[] bys = new byte[1024]; 7 int len = 0; 8 while ((len = bis.read(bys)) != -1) { 9 System.out.print(new String(bys, 0, len)); 10 } 11 12 // 释放资源 13 bis.close();
1 BufferedOutputStream bos = new BufferedOutputStream( 2 new FileOutputStream("bos.txt")); 3 4 // 写数据 5 bos.write("hello".getBytes()); 6 7 // 释放资源 8 bos.close();
* 字节流四种方式复制文件:
* 基本字节流一次读写一个字节: 共耗时:117235毫秒
* 基本字节流一次读写一个字节数组: 共耗时:156毫秒
* 高效字节流一次读写一个字节: 共耗时:1141毫秒
* 高效字节流一次读写一个字节数组: 共耗时:47毫秒
1 public static void main(String[] args) throws IOException { 2 long start = System.currentTimeMillis(); 3 // method1("e:\哥有老婆.mp4", "copy1.mp4"); 4 // method2("e:\哥有老婆.mp4", "copy2.mp4"); 5 // method3("e:\哥有老婆.mp4", "copy3.mp4"); 6 method4("e:\哥有老婆.mp4", "copy4.mp4"); 7 long end = System.currentTimeMillis(); 8 System.out.println("共耗时:" + (end - start) + "毫秒"); 9 } 10 11 // 高效字节流一次读写一个字节数组: 12 public static void method4(String srcString, String destString) 13 throws IOException { 14 BufferedInputStream bis = new BufferedInputStream(new FileInputStream( 15 srcString)); 16 BufferedOutputStream bos = new BufferedOutputStream( 17 new FileOutputStream(destString)); 18 19 byte[] bys = new byte[1024]; 20 int len = 0; 21 while ((len = bis.read(bys)) != -1) { 22 bos.write(bys, 0, len); 23 } 24 25 bos.close(); 26 bis.close(); 27 } 28 29 // 高效字节流一次读写一个字节: 30 public static void method3(String srcString, String destString) 31 throws IOException { 32 BufferedInputStream bis = new BufferedInputStream(new FileInputStream( 33 srcString)); 34 BufferedOutputStream bos = new BufferedOutputStream( 35 new FileOutputStream(destString)); 36 37 int by = 0; 38 while ((by = bis.read()) != -1) { 39 bos.write(by); 40 41 } 42 43 bos.close(); 44 bis.close(); 45 } 46 47 // 基本字节流一次读写一个字节数组 48 public static void method2(String srcString, String destString) 49 throws IOException { 50 FileInputStream fis = new FileInputStream(srcString); 51 FileOutputStream fos = new FileOutputStream(destString); 52 53 byte[] bys = new byte[1024]; 54 int len = 0; 55 while ((len = fis.read(bys)) != -1) { 56 fos.write(bys, 0, len); 57 } 58 59 fos.close(); 60 fis.close(); 61 } 62 63 // 基本字节流一次读写一个字节 64 public static void method1(String srcString, String destString) 65 throws IOException { 66 FileInputStream fis = new FileInputStream(srcString); 67 FileOutputStream fos = new FileOutputStream(destString); 68 69 int by = 0; 70 while ((by = fis.read()) != -1) { 71 fos.write(by); 72 } 73 74 fos.close(); 75 fis.close(); 76 }
* 复制文本文件
*
* 分析:
* 复制数据,如果我们知道用记事本打开并能够读懂,就用字符流,否则用字节流。
* 通过该原理,我们知道我们应该采用字符流更方便一些。
* 而字符流有5种方式,所以做这个题目我们有5种方式。推荐掌握第5种。
* 数据源:
* c:\a.txt -- FileReader -- BufferdReader
* 目的地:
* d:\b.txt -- FileWriter -- BufferedWriter
1 // 字符缓冲流一次读写一个字符串 2 private static void method5(String srcString, String destString) 3 throws IOException { 4 BufferedReader br = new BufferedReader(new FileReader(srcString)); 5 BufferedWriter bw = new BufferedWriter(new FileWriter(destString)); 6 7 String line = null; 8 while ((line = br.readLine()) != null) { 9 bw.write(line); 10 bw.newLine(); 11 bw.flush(); 12 } 13 14 bw.close(); 15 br.close(); 16 } 17 18 // 字符缓冲流一次读写一个字符数组 19 private static void method4(String srcString, String destString) 20 throws IOException { 21 BufferedReader br = new BufferedReader(new FileReader(srcString)); 22 BufferedWriter bw = new BufferedWriter(new FileWriter(destString)); 23 24 char[] chs = new char[1024]; 25 int len = 0; 26 while ((len = br.read(chs)) != -1) { 27 bw.write(chs, 0, len); 28 } 29 30 bw.close(); 31 br.close(); 32 } 33 34 // 字符缓冲流一次读写一个字符 35 private static void method3(String srcString, String destString) 36 throws IOException { 37 BufferedReader br = new BufferedReader(new FileReader(srcString)); 38 BufferedWriter bw = new BufferedWriter(new FileWriter(destString)); 39 40 int ch = 0; 41 while ((ch = br.read()) != -1) { 42 bw.write(ch); 43 } 44 45 bw.close(); 46 br.close(); 47 } 48 49 // 基本字符流一次读写一个字符数组 50 private static void method2(String srcString, String destString) 51 throws IOException { 52 FileReader fr = new FileReader(srcString); 53 FileWriter fw = new FileWriter(destString); 54 55 char[] chs = new char[1024]; 56 int len = 0; 57 while ((len = fr.read(chs)) != -1) { 58 fw.write(chs, 0, len); 59 } 60 61 fw.close(); 62 fr.close(); 63 } 64 65 // 基本字符流一次读写一个字符 66 private static void method1(String srcString, String destString) 67 throws IOException { 68 FileReader fr = new FileReader(srcString); 69 FileWriter fw = new FileWriter(destString); 70 71 int ch = 0; 72 while ((ch = fr.read()) != -1) { 73 fw.write(ch); 74 } 75 76 fw.close(); 77 fr.close(); 78 }
* 复制图片
*
* 分析:
* 复制数据,如果我们知道用记事本打开并能够读懂,就用字符流,否则用字节流。
* 通过该原理,我们知道我们应该采用字节流。
* 而字节流有4种方式,所以做这个题目我们有4种方式。推荐掌握第4种。
*
* 数据源:
* c:\a.jpg -- FileInputStream -- BufferedInputStream
* 目的地:
* d:\b.jpg -- FileOutputStream -- BufferedOutputStream
1 // 字节缓冲流一次读写一个字节数组 2 private static void method4(File srcFile, File destFile) throws IOException { 3 BufferedInputStream bis = new BufferedInputStream(new FileInputStream( 4 srcFile)); 5 BufferedOutputStream bos = new BufferedOutputStream( 6 new FileOutputStream(destFile)); 7 8 byte[] bys = new byte[1024]; 9 int len = 0; 10 while ((len = bis.read(bys)) != -1) { 11 bos.write(bys, 0, len); 12 } 13 14 bos.close(); 15 bis.close(); 16 } 17 18 // 字节缓冲流一次读写一个字节 19 private static void method3(File srcFile, File destFile) throws IOException { 20 BufferedInputStream bis = new BufferedInputStream(new FileInputStream( 21 srcFile)); 22 BufferedOutputStream bos = new BufferedOutputStream( 23 new FileOutputStream(destFile)); 24 25 int by = 0; 26 while ((by = bis.read()) != -1) { 27 bos.write(by); 28 } 29 30 bos.close(); 31 bis.close(); 32 } 33 34 // 基本字节流一次读写一个字节数组 35 private static void method2(File srcFile, File destFile) throws IOException { 36 FileInputStream fis = new FileInputStream(srcFile); 37 FileOutputStream fos = new FileOutputStream(destFile); 38 39 byte[] bys = new byte[1024]; 40 int len = 0; 41 while ((len = fis.read(bys)) != -1) { 42 fos.write(bys, 0, len); 43 } 44 45 fos.close(); 46 fis.close(); 47 } 48 49 // 基本字节流一次读写一个字节 50 private static void method1(File srcFile, File destFile) throws IOException { 51 FileInputStream fis = new FileInputStream(srcFile); 52 FileOutputStream fos = new FileOutputStream(destFile); 53 54 int by = 0; 55 while ((by = fis.read()) != -1) { 56 fos.write(by); 57 } 58 59 fos.close(); 60 fis.close(); 61 }
* 需求:把ArrayList集合中的字符串数据存储到文本文件
1 // 封装数据与(创建集合对象) 2 ArrayList<String> array = new ArrayList<String>(); 3 array.add("hello"); 4 array.add("world"); 5 array.add("java"); 6 7 // 封装目的地 8 BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt")); 9 10 // 遍历集合 11 for (String s : array) { 12 // 写数据 13 bw.write(s); 14 bw.newLine(); 15 bw.flush(); 16 } 17 18 // 释放资源 19 bw.close();
* 需求:从文本文件中读取数据(每一行为一个字符串数据)到集合中,并遍历集合
1 // 封装数据源 2 BufferedReader br = new BufferedReader(new FileReader("b.txt")); 3 // 封装目的地(创建集合对象) 4 ArrayList<String> array = new ArrayList<String>(); 5 6 // 读取数据存储到集合中 7 String line = null; 8 while ((line = br.readLine()) != null) { 9 array.add(line); 10 } 11 12 // 释放资源 13 br.close(); 14 15 // 遍历集合 16 for (String s : array) { 17 System.out.println(s); 18 }
* 需求:复制指定目录下的指定文件,并修改后缀名。
* 指定的文件是:.java文件。
* 指定的后缀名是:.jad
* 指定的目录是:jad
1 // 封装目录 2 File srcFolder = new File("e:\java"); 3 // 封装目的地 4 File destFolder = new File("e:\jad"); 5 // 如果目的地目录不存在,就创建 6 if (!destFolder.exists()) { 7 destFolder.mkdir(); 8 } 9 10 // 获取该目录下的java文件的File数组 11 File[] fileArray = srcFolder.listFiles(new FilenameFilter() { 12 @Override 13 public boolean accept(File dir, String name) { 14 return new File(dir, name).isFile() && name.endsWith(".java"); 15 } 16 }); 17 18 // 遍历该File数组,得到每一个File对象 19 for (File file : fileArray) { 20 // System.out.println(file); 21 // 数据源:e:javaDataTypeDemo.java 22 // 目的地:e:\jadDataTypeDemo.java 23 String name = file.getName(); 24 File newFile = new File(destFolder, name); 25 copyFile(file, newFile); 26 } 27 28 // 在目的地目录下改名 29 File[] destFileArray = destFolder.listFiles(); 30 for (File destFile : destFileArray) { 31 // System.out.println(destFile); 32 // e:jadDataTypeDemo.java 33 // e:\jad\DataTypeDemo.jad 34 String name =destFile.getName(); //DataTypeDemo.java 35 String newName = name.replace(".java", ".jad");//DataTypeDemo.jad 36 37 File newFile = new File(destFolder,newName); 38 destFile.renameTo(newFile); 39 } 40 } 41 42 private static void copyFile(File file, File newFile) throws IOException { 43 BufferedInputStream bis = new BufferedInputStream(new FileInputStream( 44 file)); 45 BufferedOutputStream bos = new BufferedOutputStream( 46 new FileOutputStream(newFile)); 47 48 byte[] bys = new byte[1024]; 49 int len = 0; 50 while ((len = bis.read(bys)) != -1) { 51 bos.write(bys, 0, len); 52 } 53 54 bos.close(); 55 bis.close(); 56 }
* 需求:复制多极文件夹
1 public static void main(String[] args) throws IOException { 2 // 封装数据源File 3 File srcFile = new File("E:\JavaSE\day21\code\demos"); 4 // 封装目的地File 5 File destFile = new File("E:\"); 6 7 // 复制文件夹的功能 8 copyFolder(srcFile, destFile); 9 } 10 11 private static void copyFolder(File srcFile, File destFile) 12 throws IOException { 13 // 判断该File是文件夹还是文件 14 if (srcFile.isDirectory()) { 15 // 文件夹 16 File newFolder = new File(destFile, srcFile.getName()); 17 newFolder.mkdir(); 18 19 // 获取该File对象下的所有文件或者文件夹File对象 20 File[] fileArray = srcFile.listFiles(); 21 for (File file : fileArray) { 22 copyFolder(file, newFolder); 23 } 24 } else { 25 // 文件 26 File newFile = new File(destFile, srcFile.getName()); 27 copyFile(srcFile, newFile); 28 } 29 } 30 31 private static void copyFile(File srcFile, File newFile) throws IOException { 32 BufferedInputStream bis = new BufferedInputStream(new FileInputStream( 33 srcFile)); 34 BufferedOutputStream bos = new BufferedOutputStream( 35 new FileOutputStream(newFile)); 36 37 byte[] bys = new byte[1024]; 38 int len = 0; 39 while ((len = bis.read(bys)) != -1) { 40 bos.write(bys, 0, len); 41 } 42 43 bos.close(); 44 bis.close(); 45 }
* 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低存入文本文件
*
* 分析:
* A:创建学生类
* B:创建集合对象
* TreeSet<Student>
* C:键盘录入学生信息存储到集合
* D:遍历集合,把数据写到文本文件
1 public static void main(String[] args) throws IOException { 2 // 创建集合对象 3 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() { 4 @Override 5 public int compare(Student s1, Student s2) { 6 int num = s2.getSum() - s1.getSum(); 7 int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num; 8 int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2; 9 int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3; 10 int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName()) 11 : num4; 12 return num5; 13 } 14 }); 15 16 // 键盘录入学生信息存储到集合 17 for (int x = 1; x <= 5; x++) { 18 Scanner sc = new Scanner(System.in); 19 System.out.println("请录入第" + x + "个的学习信息"); 20 System.out.println("姓名:"); 21 String name = sc.nextLine(); 22 System.out.println("语文成绩:"); 23 int chinese = sc.nextInt(); 24 System.out.println("数学成绩:"); 25 int math = sc.nextInt(); 26 System.out.println("英语成绩:"); 27 int english = sc.nextInt(); 28 29 // 创建学生对象 30 Student s = new Student(); 31 s.setName(name); 32 s.setChinese(chinese); 33 s.setMath(math); 34 s.setEnglish(english); 35 36 // 把学生信息添加到集合 37 ts.add(s); 38 } 39 40 // 遍历集合,把数据写到文本文件 41 BufferedWriter bw = new BufferedWriter(new FileWriter("students.txt")); 42 bw.write("学生信息如下:"); 43 bw.newLine(); 44 bw.flush(); 45 bw.write("姓名,语文成绩,数学成绩,英语成绩"); 46 bw.newLine(); 47 bw.flush(); 48 for (Student s : ts) { 49 StringBuilder sb = new StringBuilder(); 50 sb.append(s.getName()).append(",").append(s.getChinese()) 51 .append(",").append(s.getMath()).append(",") 52 .append(s.getEnglish()); 53 bw.write(sb.toString()); 54 bw.newLine(); 55 bw.flush(); 56 } 57 // 释放资源 58 bw.close(); 59 System.out.println("学习信息存储完毕"); 60 }
* 用Reader模拟BufferedReader的readLine()功能
*
* readLine():一次读取一行,根据换行符判断是否结束,只返回内容,不返回换行符
1 public class MyBufferedReader { 2 private Reader r; 3 4 public MyBufferedReader(Reader r) { 5 this.r = r; 6 } 7 8 /* 9 * 思考:写一个方法,返回值是一个字符串。 10 */ 11 public String readLine() throws IOException { 12 /* 13 * 我要返回一个字符串,我该怎么办呢? 我们必须去看看r对象能够读取什么东西呢? 两个读取方法,一次读取一个字符或者一次读取一个字符数组 14 * 那么,我们要返回一个字符串,用哪个方法比较好呢? 我们很容易想到字符数组比较好,但是问题来了,就是这个数组的长度是多长呢? 15 * 根本就没有办法定义数组的长度,你定义多长都不合适。 所以,只能选择一次读取一个字符。 16 * 但是呢,这种方式的时候,我们再读取下一个字符的时候,上一个字符就丢失了 所以,我们又应该定义一个临时存储空间把读取过的字符给存储起来。 17 * 这个用谁比较和是呢?数组,集合,字符串缓冲区三个可供选择。 18 * 经过简单的分析,最终选择使用字符串缓冲区对象。并且使用的是StringBuilder 19 */ 20 StringBuilder sb = new StringBuilder(); 21 22 // 做这个读取最麻烦的是判断结束,但是在结束之前应该是一直读取,直到-1 23 24 25 /* 26 hello 27 world 28 java 29 30 104101108108111 31 119111114108100 32 1069711897 33 */ 34 35 int ch = 0; 36 while ((ch = r.read()) != -1) { //104,101,108,108,111 37 if (ch == ' ') { 38 continue; 39 } 40 41 if (ch == ' ') { 42 return sb.toString(); //hello 43 } else { 44 sb.append((char)ch); //hello 45 } 46 } 47 48 // 为了防止数据丢失,判断sb的长度不能大于0.就是怕最后一行没有换行,那就没有换行符. 49 if (sb.length() > 0) { 50 return sb.toString(); 51 } 52 53 return null; 54 } 55 56 /* 57 * 先写一个关闭方法 58 */ 59 public void close() throws IOException { 60 this.r.close(); 61 } 62 }
* 测试MyBufferedReader的时候,你就把它当作BufferedReader一样的使用
1 public class MyBufferedReaderDemo { 2 public static void main(String[] args) throws IOException { 3 MyBufferedReader mbr = new MyBufferedReader(new FileReader("my.txt")); 4 5 String line = null; 6 while ((line = mbr.readLine()) != null) { 7 System.out.println(line); 8 } 9 10 mbr.close(); 11 } 12 }
* BufferedReader
* |--LineNumberReader
* public int getLineNumber()获得当前行号。
* public void setLineNumber(int lineNumber)
1 LineNumberReader lnr = new LineNumberReader(new FileReader("my.txt")); 2 3 // 从10开始才比较好 4 // lnr.setLineNumber(10); 5 6 // System.out.println(lnr.getLineNumber()); 7 // System.out.println(lnr.getLineNumber()); 8 // System.out.println(lnr.getLineNumber()); 9 10 String line = null; 11 while ((line = lnr.readLine()) != null) { 12 System.out.println(lnr.getLineNumber() + ":" + line); 13 } 14 15 lnr.close();
自定义LineNumberReader:
1 public class MyLineNumberReader { 2 private Reader r; 3 private int lineNumber = 0; 4 5 public MyLineNumberReader(Reader r) { 6 this.r = r; 7 } 8 9 public int getLineNumber() { 10 // lineNumber++; 11 return lineNumber; 12 } 13 14 public void setLineNumber(int lineNumber) { 15 this.lineNumber = lineNumber; 16 } 17 18 public String readLine() throws IOException { 19 lineNumber++; 20 21 StringBuilder sb = new StringBuilder(); 22 23 int ch = 0; 24 while ((ch = r.read()) != -1) { 25 if (ch == ' ') { 26 continue; 27 } 28 29 if (ch == ' ') { 30 return sb.toString(); 31 } else { 32 sb.append((char) ch); 33 } 34 } 35 36 if (sb.length() > 0) { 37 return sb.toString(); 38 } 39 40 return null; 41 } 42 43 public void close() throws IOException { 44 this.r.close(); 45 } 46 }
或者:
1 public class MyLineNumberReader2 extends MyBufferedReader { 2 private Reader r; 3 4 private int lineNumber = 0; 5 6 public MyLineNumberReader2(Reader r) { 7 super(r); 8 } 9 10 public int getLineNumber() { 11 return lineNumber; 12 } 13 14 public void setLineNumber(int lineNumber) { 15 this.lineNumber = lineNumber; 16 } 17 18 @Override 19 public String readLine() throws IOException { 20 lineNumber++; 21 return super.readLine(); 22 } 23 }