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 }

void write(byte[] b, int off, int len)

off

len

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 }