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

 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 }

 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 }

 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 }

 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 }

 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 }

 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 }

 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 }

 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 }