IO流02--毕向东JAVA基础教程视频学习笔记

提要

08 自定义装饰类
09 LineNumberReader
10 MyLineNumberReader
11 字节流File读写操作
12 拷贝图片
13 字节流的缓冲区
14 自定义字节流的缓冲区-read和write的特点
15 读取键盘录入

 

 

08 自定义装饰类

 1 /*自定义装饰设计类*/
 2 import java.io.*;  3 class MyBufferedReader2 extends Reader  4 {  5     private Reader r;  6     public MyBufferedReader2(Reader r)  7  {  8         this.r=r;  9  } 10     public String MyReadLine()throws IOException 11  { 12         int ch; 13         StringBuilder sb=new StringBuilder(); 14         while((ch=r.read())!=-1) 15  { 16             if(ch=='\r') 17                 continue; 18             if(ch=='\n') 19                 return sb.toString(); 20             else
21                 sb.append((char)ch); 22  } 23         if(sb.length()!=0) 24             return sb.toString(); 25         return null; 26  } 27     public void MyClose()throws IOException 28  { 29  r.close(); 30  } 31     //重写父类的抽象方法
32     public void close()throws IOException 33  { 34  r.close(); 35  } 36     public int read(char[] cbuf, int off, int len)throws IOException 37  { 38         return r.read(cbuf,off,len); 39  } 40 } 41 
42 public class MyBufferedReaderDemo2 43 { 44     public static void main(String[] args)throws IOException 45  { 46         FileReader fw=new FileReader("buf.txt"); 47         MyBufferedReader2 mr=new MyBufferedReader2(fw); 48  String line; 49         while((line=mr.MyReadLine())!=null) 50  { 51  System.out.println(line); 52  } 53  mr.MyClose(); 54  } 55 }

 

09 LineNumberReader

 1 /*带行号的缓冲区，lineNumberReader  2 是BufferedReader的直接子类，此类定义了setLineNumber(int)和getLineNumber)(),  3 分别用来设置和获取当前行号。  4 */
 5 import java.io.*;  6 public class LineNumberReaderDemo  7 {  8     public static void main(String[] args)  9  { 10         try
11  { 12            FileReader fw=new FileReader("PersonDemo.java"); 13            LineNumberReader lr=new LineNumberReader(fw); 14  String line; 15            lr.setLineNumber(100); 16            while((line=lr.readLine())!=null) 17  { 18                System.out.println(lr.getLineNumber()+":"+line); 19  } 20  lr.close(); 21             
22  } 23         catch (IOException ie) 24  { 25  ie.printStackTrace(); 26  } 27     
28  } 29 }

 

10 MyLineNumberReader

 1 /*
 2 练习，自定义一个类，实现LineNumberReader的功能  3 
 4 */
 5 import java.io.*;  6 class MyLineNumberReader extends MyBufferedReader2  7 {  8     private int lineNumber;  9     public MyLineNumberReader(Reader r) 10  { 11         super(r); 12  } 13     public String readLine()throws IOException 14  { 15         lineNumber++; 16         return super.MyReadLine(); 17  } 18     //自定义设置行号的方法
19     public void setLineNumber(int lineNumber) 20  { 21         this.lineNumber=lineNumber; 22  } 23     //自定义获取行号的方法
24     public int getLineNumber() 25  { 26         return lineNumber; 27  } 28 
29 } 30 public class MyLineNumberReaderDemo 31 { 32     public static void main(String[] args) 33  { 34         try
35  { 36         FileReader fr=new FileReader("BufferedReaderDemo.java"); 37         MyLineNumberReader mlnr=new MyLineNumberReader(fr); 38         String line=null; 39         mlnr.setLineNumber(99); 40 
41         while((line=mlnr.readLine())!=null) 42  { 43             System.out.println(mlnr.getLineNumber()+"  "+line); 44  } 45  mlnr.close(); 46 
47             
48  } 49         catch (IOException ie) 50  { 51  ie.printStackTrace(); 52  } 53         
54  } 55     
56         
57 
58     
59 }

 

11 字节流File读写操作

 1 /*
 2 字符流：  3 FileReader  4 FileWriter  5 
 6 BufferedReader  7 BufferedWriter  8 
 9 字节流： 10 InputStream 读 11 OutPutStream 写 12 
13 需求：想要操作图片数据，这就需要用到字节流。 14 
15 */
16 import java.io.*; 17 public class FileStream 18 { 19     public static void main(String[] args)throws IOException 20  { 21  writeFile(); 22  readFile_1(); 23  readFile_2(); 24  readFile_3(); 25 
26 
27     
28  } 29     //把读到的存放到一个字节数组中，然后一起输出
30     public static void readFile_3()throws IOException 31  { 32         FileInputStream fis=new FileInputStream("fos.txt"); 33        //int num=fis.available(); 34        //使用avaliable方法，定义一个刚刚好的缓冲区，不用再循环了 35        //如果文件太大，不建议使用，会出现内存溢出
36        byte[] buf=new byte[fis.available()]; 37  fis.read(buf); 38        System.out.println(new String(buf)); 39 
40  fis.close(); 41  } 42     //把读到的存放到一个字节数组中，然后一起输出
43     public static void readFile_2()throws IOException 44  { 45         FileInputStream fis=new FileInputStream("fos.txt"); 46        byte[] buf=new byte[1024]; 47        int len=0; 48        while((len=fis.read(buf))!=-1) 49  { 50            System.out.println(new String(buf,0,len)); 51  } 52  fis.close(); 53  } 54     //一个一个地读
55     public static void readFile_1()throws IOException 56  { 57         FileInputStream fis=new FileInputStream("fos.txt"); 58         int ch=0; 59         while((ch=fis.read())!=-1) 60  { 61             System.out.println((char)ch); 62  } 63  fis.close(); 64  } 65     public static void writeFile()throws IOException 66  { 67         FileOutputStream fos=new FileOutputStream("fos.txt"); 68         fos.write("abcde".getBytes()); 69         //对最小单位字节操作，不需要刷新
70  fos.close(); 71  } 72 }

 

12 拷贝图片

void write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。

int read(byte[] b) 从此输入流中，将最多b.length个字节的数据读入byte数组中。返回读入缓冲区的字节总数，如果达到文件末尾没有更多数据，则返回-1.
          

 1 /*
 2 复制一个图片  3 思路：  4 1.用字节读取流对象和图片相关联  5 2.用字节写入流对象创建一个图片文件，用于存储获取到的图片数据  6 3.通过循环读写，完成数据的存储  7 4.关闭资源  8 */
 9 import java.io.*; 10 public class CopyPic 11 { 12     public static void main(String[] args) 13  { 14         FileOutputStream fos=null; 15         FileInputStream fis=null; 16         try
17  { 18             fis=new FileInputStream("d:\\十字路口.bmp"); 19             fos=new FileOutputStream("d:\\路口.bmp"); 20 
21             byte[] buf=new byte[1024]; 22             int len=0; 23             while((len=fis.read(buf))!=-1) 24  { 25                 fos.write(buf,0,len); 26  } 27 
28 
29  } 30         catch (IOException e) 31  { 32             throw new RuntimeException("复制文件失败！"); 33  } 34         finally
35  { 36             try
37  { 38                 if(fis!=null) 39  fis.close(); 40                 
41  } 42             catch (IOException e) 43  { 44             throw new RuntimeException("读取关闭失败！"); 45  } 46            try
47  { 48                 if(fos!=null) 49  fos.close(); 50                 
51  } 52             catch (IOException e) 53  { 54             throw new RuntimeException("写入关闭失败！"); 55  } 56  } 57  } 58 }

 

13 字节流的缓冲区

 1 /*
 2 演示mp3的复制，通过缓冲区  3 BufferedOutputStream  4 BufferedInputStream  5 */
 6 import java.io.*;  7 public class CopyMp3  8 {  9     public static void main(String[] args)throws IOException 10  { 11         long start=System.currentTimeMillis(); 12  copy(); 13         long end=System.currentTimeMillis(); 14 
15         System.out.println((end-start)+"毫秒"); 16 
17  } 18     //通过字节流的缓冲区完成复制
19     public static void copy()throws IOException 20  { 21         BufferedInputStream bufis=new BufferedInputStream(new FileInputStream("D:\\安又琪-那你呢.mp3")); 22         BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("d:\\那你呢.mp3")); 23 
24         int by=0; 25         while((by=bufis.read())!=-1) 26  { 27  bufos.write(by); 28  } 29  bufis.close(); 30  bufos.close(); 31 
32  } 33 }

 

14 自定义字节流的缓冲区-read和write的特点

 1 /*
 2 通过自定义的缓冲区，拷贝Mp3  3 
 4 注意，把myRead方法的返回值设为int型，而不是byte型  5 因为当连续读取8个1时，可能错误结束main函数中的读取循环，  6 提升了一个int型(byte型1个字节，int型32位，4个字节)，还是-1的原因是因为在8个1前面补1造成的。  7  那么如果能在前面补0，既可以保留原字节数据不变，又可以避免-1的出现。  8 
 9  补0的方法： 10  和255相与 11 
12 最后文件大小并没有变成原来的4倍的原因是，write方法只写入后8位，对int型又做了强制转换 13 
14 运行发现，自定义的缓冲区的拷贝时间比原来的提高了大约200毫秒 15 
16 */
17 import java.io.*; 18 class MyBufferedInputStream 19 { 20     private InputStream in; 21     private byte[] buf=new byte[1024]; 22     private int pos=0,count=0; 23     public MyBufferedInputStream(InputStream in) 24  { 25         this.in=in; 26  } 27     //一次读一个字节，从缓冲区（字节数组）获取。
28     public int myRead()throws IOException 29  { 30         //通过in对象读取硬盘上数据，并存储在buf中。
31         if(count==0) 32  { 33             count=in.read(buf); 34             pos=0; 35             byte b=buf[pos]; 36 
37             count--; 38             pos++; 39             return b&255; 40  } 41         else if(count>0) 42  { 43             byte b=buf[pos]; 44             count--; 45             pos++; 46             return b&255; 47  } 48         return -1; 49 
50  } 51     public void myClose()throws IOException 52  { 53  in.close(); 54  } 55 } 56 public class CopyMp3_2 57 { 58     public static void main(String[] args)throws IOException 59  { 60         long start=System.currentTimeMillis(); 61  copy_1(); 62         long end=System.currentTimeMillis(); 63 
64         System.out.println((end-start)+"毫秒"); 65 
66  } 67     //通过字节流的缓冲区完成复制
68     public static void copy_1()throws IOException 69  { 70         MyBufferedInputStream bufis=new MyBufferedInputStream(new FileInputStream("D:\\安又琪-那你呢.mp3")); 71         BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("d:\\那你呢.mp3")); 72 
73         int by=0; 74         while((by=bufis.myRead())!=-1) 75  { 76             
77  bufos.write(by); 78  } 79  bufis.myClose(); 80  bufos.close(); 81 
82  } 83 }

 

15 读取键盘录入

需求：
通过键盘录入数据
当录入一行数据后，就将该行数据转变为大写形式再进行打印
如果录入的数据是over,则停止录入。

 1 /*
 2 字符流：  3 FileReader  4 FileWriter  5 
 6 BufferedReader  7 BufferedWriter  8 
 9 字节流： 10 FileInputStream 11 FileOutputStream 12 
13 BufferedInputStream 14 BufferedOutputStream 15 
16 
17 读取键盘录入： 18 System.out :对应的是标准输出设备，控制台 19 System.in :对应的标准输入设备：键盘 20 
21 
22 */
23 import java.io.*; 24 public class ReadIn 25 { 26     public static void main(String[] args) throws IOException 27  { 28         InputStream in=System.in; 29         //建立一个读入数据的缓冲区
30         StringBuilder sb=new StringBuilder(); 31 
32         while(true) 33  { 34             //read方法是阻塞式方法，没有录入，就会一直等待
35         int ch=in.read(); 36         if(ch=='\r') 37             continue; 38         else if(ch=='\n') 39  { 40             String s=sb.toString(); 41             if("over".equals(s)) 42                 break; 43  System.out.println(s.toUpperCase()); 44             //清空缓冲区
45             sb.delete(0,sb.length()); 46 
47  } 48         else 
49             sb.append((char)ch); 50 
51  } 52     
53  } 54 }