java缓冲流不需要关闭吗

　　字节流

字节输出流OutputStream（抽象类）

常用方法：

代码实例：

1     public static void main(String[] args) throws IOException {
 2         //FileOutputStream的构造方法：如果文件存在，则覆盖，如果不存在，则创建
 3         // \r\n  换行
 4         FileOutputStream fos=new FileOutputStream("x:\\test\\bian.txt",true);
 5         /*fos.write(49);
 6         fos.write(48);
 7         fos.write(48);*/
 8         /*byte[] bytes={-65,-66,-67,-68};
 9         fos.write(bytes,1,2);*/
10         fos.write("xuezhiqian\r\n".getBytes()); //字符串转字节
11         /*new String(bytes);*/    //字节转字符串
12         fos.close();
13     }

 

FileOutputStream类（文件输出流，OutputStream的子类）

FileOutputStream类写入数据到文件中

 

 

代码实现：
 1 public static void main(String[] args){
 2     FileOutputStream fos=null;
 3         try {
 4             fos = new FileOutputStream("x:\\test\\bb.txt");
 5             fos.write(12);
 6         } catch (IOException e) {
 7             throw new RuntimeException("输入失败");
 8         }finally{
 9             try {
10                 if(fos!=null)
11                 fos.close();
12             } catch (IOException e) {
13                 throw new RuntimeException("关闭失败");
14             }
15         }

 给文件中续写和换行

构造方法：

代码实现:

1 public static void main(String[] args) throws IOException {
 2         //FileOutputStream的构造方法：如果文件存在，则覆盖，如果不存在，则创建
 3         // \r\n  换行
 4         FileOutputStream fos=new FileOutputStream("x:\\test\\bian.txt",true);
 5         /*fos.write(49);
 6         fos.write(48);
 7         fos.write(48);*/
 8         /*byte[] bytes={-65,-66,-67,-68};
 9         fos.write(bytes,1,2);*/
10         fos.write("xuezhiqian\r\n".getBytes()); //字符串转字节
11         /*new String(bytes);*/    //字节转字符串
12         fos.close();
13     }

IO异常的处理

代码实现:

 

1 public class FileOutputStreamDemo3 {
 2     public static void main(String[] args) {
 3         File file = new File("c:\\file.txt");
 4         //定义FileOutputStream的引用
 5         FileOutputStream fos = null;
 6         try {
 7             //创建FileOutputStream对象
 8             fos = new FileOutputStream(file);
 9             //写出数据
10             fos.write("abcde".getBytes());
11         } catch (IOException e) {
12             System.out.println(e.toString() + "----");
13 throw new RuntimeException("文件写入失败，重试");
14 
15         } finally {
16             //一定要判断fos是否为null，只有不为null时，才可以关闭资源
17             if (fos != null) {
18                 try {
19                     fos.close();
20                 } catch (IOException e) {
21                     throw new RuntimeException("关闭资源失败");
22                 }
23             }
24         }
25     }
26 }

 

        字节输入流InputStream

常用方法：

FileInputStream类

 

构造方法：

FileInputStream类读取数据read方法

代码实现：

1     public static void main(String[] args) throws IOException {
 2         FileInputStream fis=new FileInputStream("x:\\test\\test.txt");
 3         int len=0;
 4         while((len=fis.read())!=-1){
 5             System.out.println((char)len);
 6         }
 7         /*int a=fis.read();
 8         System.out.println((char)a);
 9         int b=fis.read();
10         System.out.println((char)b);
11         int c=fis.read();
12         System.out.println((char)c);
13         int d=fis.read();
14         System.out.println((char)d);
15         int e=fis.read();
16         System.out.println((char)e);
17         int f=fis.read();
18         System.out.println((char)f);*/
19         /*char ch=97;
20         System.out.println(ch);*/
21         fis.close();
22     }
23 
24 }

   读取数据read(byte[])方法

代码实现：

1 public class InputStreamDemo2 {
 2     public static void main(String[] args) throws IOException {
 3         FileInputStream fis=new FileInputStream("x:\\test\\test.txt");
 4         byte[] bytes=new byte[2];
 5         int len=0;
 6         while((len=fis.read(bytes))!=-1){
 7             System.out.println(new String(bytes,0,len));
 8         }
 9     /*    //第一次读
10         int len=fis.read(bytes);
11         System.out.println(len);
12         System.out.println(new String(bytes));
13         //第二次读
14         len=fis.read(bytes);
15         System.out.println(len);
16         System.out.println(new String(bytes));
17         //第三次读
18         len=fis.read(bytes);
19         System.out.println(len);
20         System.out.println(new String(bytes));
21         //第4次读
22         len=fis.read(bytes);
23         System.out.println(len);
24         System.out.println(new String(bytes));*/
25         fis.close();
26     }
27 
28 }

字节流复制文件

代码实现：

 

1 public class CopyDemo {
 2     public static void main(String[] args) throws IOException {
 3         long time1=System.currentTimeMillis();
 4         //1.明确数据源（要复制哪个文件）
 5         FileInputStream fis=new FileInputStream("C:\\Program Files\\java\\eclipse.zip");
 6         //2.明确目的地（要复制到哪个文件）
 7         FileOutputStream fos=new FileOutputStream("x:\\test\\d\\java.txt");
 8         //3.复制
 9         int len=0;
10         while((len=fis.read())!=-1){
11             fos.write(len);
12         }
13         long time2=System.currentTimeMillis();
14         System.out.println(time2-time1);
15         //4.释放资源
16         fis.close();
17         fos.close();
18     }
19 
20 }

 

缓冲数组方式复制文件

代码实现：

 

1     public static void main(String[] args) throws IOException {
 2         long time1=System.currentTimeMillis();
 3         // 1.明确数据源
 4         FileInputStream fis=new FileInputStream("C:\\Program Files\\java\\eclipse.zip");
 5         //2.明确目的地
 6         FileOutputStream fos=new FileOutputStream("x:\\test\\eclipse.zip");
 7         //3.复制
 8         int len=0;//获取读取字节的有效长度
 9         byte[] bytes=new byte[1024];
10         while((len=fis.read(bytes))!=-1){
11             fos.write(bytes, 0, len);
12         }
13         long time2=System.currentTimeMillis();
14         System.out.println(time2-time1);
15         //4.释放资源
16         fis.close();
17         fos.close();
18     }
19 }

 

　　　　 字符流

      字节流读取字符的问题

代码实现：

 

public class CharStreamDemo {
    public static void main(String[] args) throws IOException {
        //给文件中写中文
        writeCNText();
        //读取文件中的中文
        readCNText();
    }  
    //读取中文
    public static void readCNText() throws IOException {
fis = new FileInputStream("c:\\cn.txt");
        int ch = 0;
        while((ch = fis.read())!=-1){
            System.out.println(ch);
        }
    }
    //写中文
    public static void writeCNText() throws IOException {
        FileOutputStream fos = new FileOutputStream("c:\\cn.txt");
        fos.write("欢迎你".getBytes());
        fos.close();
    }
}

 

          字符输入流Reader

基础方法：

代码实现：

1 public class ReaderDemo {
 2 
 3     public static void main(String[] args) throws IOException {
 4         //通过字符数组的方式读
 5         FileReader fr=new FileReader("x:\\test\\test.txt");
 6         int len=0;
 7         char[] ch=new char[1024];
 8         while((len=fr.read(ch))!=-1){
 9             System.out.println(new String(ch,0,len));
10         }
11         fr.close();
12         //method1(fr);
13     }
14     public static void method1(FileReader fr) throws IOException{
15         //通过一个字符一个字符的方法读
16         int len=0;
17         while((len=fr.read())!=-1){
18             System.out.print((char)len);
19         }
20         fr.close();
21     }
22 
23 }

 

  FileReader类

构造方法：

 

代码实现:

 

       字符输出流Writer

基础方法：

 

    FileWriter类

 构造方法：

代码实现：

1 1 public class WriterDemo {
 2  2 public static void main(String[] args) throws IOException {
 3  3 //写入中文字符 
 4 4 FileWriter fw=new FileWriter("x:\\test\\test.txt"); 
 5 5 fw.write("段子手薛之谦");//被写在缓冲区 
 6 6 fw.flush();//可刷新多次 
 7 7 //fw.close();//具有一次刷新功能 
 8 8     }
 9 9 
10 10 }

flush()和close()的区别

close是在关闭之前刷新一次

flush是一边存一边刷

字符流复制文件

代码实现：

1 public class JpgCopy1 {
 2     //字符流复制文件
 3     public static void main(String[] args) throws IOException {
 4         //1.明确数据源
 5         FileReader fr=new FileReader("X:\\test\\img1.jpg");
 6         //2.明确目的地
 7         FileWriter fw=new FileWriter("x:\\test\\a\\img1.jpg");
 8         //3.复制
 9         int len=0;
10         char[] ch=new char[1024];
11         while((len=fr.read(ch))!=-1){
12             fw.write(ch, 0, len);
13         }
14         //4.释放资源
15         fr.close();
16         fw.close();
17     }
18 
19 }

 

 

转换流

 OutputStreamWriter类（OutputStreamWriter 是字符流通向字节流的桥梁）

代码实现：

1 public class OutputStreamWriterDemo {
2     public static void main(String[] args) throws IOException {
3         FileOutputStream fos=new FileOutputStream("x:\\test\\utf8.txt",true);
4         OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");
5         osw.write("这是utf-8编码");
6         osw.close();
7     }
8 
9 }

    InputStreamReader类（InputStreamReader 是字节流通向字符流的桥梁）

代码实现：

1 public class InputStreamReaderDemo {
 2 
 3     public static void main(String[] args) throws IOException {
 4         FileInputStream fis=new FileInputStream("x:\\test\\utf8.txt");
 5         InputStreamReader isr=new InputStreamReader(fis,"utf-8");
 6         char[] ch=new char[1024];
 7         int len=0;
 8         while((len=isr.read(ch))!=-1){
 9             System.out.println(new String(ch,1,len-1));
10         }
11         isr.close();
12     }
13 
14 }

    转换流和子类区别

OutputStreamWriter:

            |--FileWriter:

InputStreamReader:

　　　|--FileReader;

 

OutputStreamWriter和InputStreamReader是字符和字节的桥梁：也可以称之为字符转换流。字符转换流原理：字节流+编码表。

 

FileWriter和FileReader：作为子类，仅作为操作字符文件的便捷类存在。当操作的字符文件，使用的是默认编码表时可以不用父类，

而直接用子类就完成操作了，简化了代码。

 

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));//默认字符集。

 

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");//指定GBK字符集。

 

FileReader fr = new FileReader("a.txt");

 

这三句代码的功能是一样的，其中第三句最为便捷。

 

注意：一旦要指定其他编码时，绝对不能用子类，必须使用字符转换流。什么时候用子类呢？

 

条件：

 

1、操作的是文件。2、使用默认编码。

 

总结：

 

字节--->字符 ： 看不懂的--->看的懂的。  需要读。输入流。 InputStreamReader

 

字符--->字节 ： 看的懂的--->看不懂的。  需要写。输出流。 OutputStreamWriter

 

 

     缓冲流

      字节缓冲流

{ 

字节缓冲输出流BufferedOutputStream

　字节缓冲输入流 BufferedInputStream

　使用基本的流与高效的流完成复制文件

　}

　　字符缓冲流

{

    字符缓冲输出流 BufferedWriter

    字符缓冲输入流 BufferedReader

    使用字符缓冲流完成文本文件的复制

}

整体代码实现：

1 public class Demo01 {
 2     public static void main(String[] args) throws IOException {
 3         //method1();
 4         //method2();
 5         copy();
 6     }
 7     //缓冲字符输出流
 8     //bw.newLine();可以实现平台无关性
 9     //win 换行 \r\n
10     //Linux 换行 \n
11     public static void method1() throws IOException{
12         FileWriter fw=new FileWriter("x:\\test\\test.txt",true);
13         BufferedWriter bw=new BufferedWriter(fw);
14         bw.write("你好吗".toCharArray());
15         bw.flush();
16         bw.newLine();//换行
17         bw.write("我不好");
18         bw.flush();
19         bw.newLine();
20         bw.write(100);
21         bw.close();
22     }
23     //缓冲字符输入流
24     public static void method2() throws IOException{
25         FileReader fr=new FileReader("x:\\test\\test.txt");
26         BufferedReader bfr=new BufferedReader(fr);
27         String line=null;
28         int count=0;
29         while((line=bfr.readLine())!=null){
30             count++;
31             System.out.println(count+"    "+line);
32         }
33         /*System.out.println(bfr.readLine());
34         System.out.println(bfr.readLine());
35         System.out.println(bfr.readLine());
36         System.out.println(bfr.readLine());*/
37         
38         bfr.close();
39     }
40     //缓冲字符流的复制
41     public static void copy() throws IOException{
42         //1.明确数据源
43         FileReader fr=new FileReader("x:\\test\\test.txt");
44         BufferedReader br=new BufferedReader(fr);
45         //2.确定目的地
46         FileWriter fw=new FileWriter("x:\\test\\d\\copy.txt");
47         BufferedWriter bw=new BufferedWriter(fw);
48         //3.复制
49         String line=null;
50         while((line=br.readLine())!=null){
51             bw.write(line);
52             bw.newLine();
53             bw.flush();
54             
55         }
56         br.close();
57         bw.close();
58     }
59 
60 }

1 public class Demo02 {
 2     public static void main(String[] args) throws IOException {
 3          //method1();
 4          method2();
 5     }
 6     //缓冲字节输出流
 7     public static void method1() throws IOException{
 8         FileOutputStream fos=new FileOutputStream("x:\\test\\test.txt",true);
 9         BufferedOutputStream bos=new BufferedOutputStream(fos);
10         //bos.write(100);
11         bos.write("你好啊".getBytes());
12         bos.close();
13     }
14     //缓冲字节输入流
15     public static void method2() throws IOException{
16         FileInputStream fis=new FileInputStream("x:\\test\\test.txt");
17         BufferedInputStream bis=new BufferedInputStream(fis);
18         int len=0;
19         while((len=bis.read())!=-1){
20             System.out.print((char)len);
21         }
22         bis.close();
23     }
24 
25 }

整体练习：

 

1 public class Demo01 {
 2     public static void main(String[] args) throws IOException {
 3         method1();//31159
 4         method2();//52
 5         method3();//105
 6         method4();//3
 7     }
 8     public static void method1() throws IOException {
 9         //字节流read() 
10         long time1=System.currentTimeMillis();
11         FileInputStream fis=new FileInputStream("x:\\test\\mysql-connector-java-5.1.37-bin.jar");
12         FileOutputStream fos=new FileOutputStream("x:\\test\\a\\mysql-connector-java-5.1.37-bin.jar");
13         int len=0;
14         while((len=fis.read())!=-1){
15             fos.write(len);
16         }
17         long time2=System.currentTimeMillis();
18         System.out.println(time2-time1);
19         fis.close();
20         fos.close();
21     }
22     public static void method2() throws IOException{
23         //字节流read(byte[])
24         long time1=System.currentTimeMillis();
25         FileInputStream fis=new FileInputStream("x:\\test\\mysql-connector-java-5.1.37-bin.jar");
26         BufferedInputStream bis=new BufferedInputStream(fis);
27         FileOutputStream fos=new FileOutputStream("x:\\test\\kkk.jar");
28         BufferedOutputStream bos=new BufferedOutputStream(fos);
29         int len=0;
30         byte[] bytes=new byte[1024];
31         while((len=fis.read(bytes))!=-1){
32             fos.write(bytes, 0, len);
33         }
34         long time2=System.currentTimeMillis();
35         System.out.println(time2-time1);
36         fis.close();
37         fos.close();
38     }
39     //缓冲字节输出流
40         public static void method3() throws IOException{
41         
42             long time1=System.currentTimeMillis();
43             FileInputStream fis=new FileInputStream("x:\\test\\mysql-connector-java-5.1.37-bin.jar");
44             BufferedInputStream bis=new BufferedInputStream(fis);
45             FileOutputStream fos=new FileOutputStream("x:\\test\\ggg.jar");
46             BufferedOutputStream bos=new BufferedOutputStream(fos);
47             int len=0;
48             while((len=bis.read())!=-1){
49                 bos.write(len);
50             }
51             long time2=System.currentTimeMillis();
52             System.out.println(time2-time1);
53             bis.close();
54             bos.close();
55         }
56         //缓冲字节输入流
57         public static void method4() throws IOException{
58             long time1=System.currentTimeMillis();
59             FileInputStream fis=new FileInputStream("x:\\test\\mysql-connector-java-5.1.37-bin.jar");
60             BufferedInputStream bis=new BufferedInputStream(fis);
61             FileOutputStream fos=new FileOutputStream("x:\\test\\mysql-connector-java-5.1.37-bin.jar");
62             BufferedOutputStream bos=new BufferedOutputStream(fos);
63             int len=0;
64             byte[] bytes=new byte[1024];
65             while((len=bis.read(bytes))!=-1){
66                 bos.write(bytes, 0, len);
67             }
68             long time2=System.currentTimeMillis();
69             System.out.println(time2-time1);
70             bis.close();
71             bos.close();
72         }
73     
74     }