IO流学习笔记(未完)

IO流

1、流的分类

• 按操作数据单位不同分为：字节流(8 bit,byte)，字符流(16 bit,char)。
  • 字节流：相当于字节传输，更适合图片视频传输（0101…）
  • 字符流：相当于字符传输，更适合文本传输（“a”“b”…）
• 按数据流的流向不同分为：输入流，输出流
  • 输入流：自外向程序内流入
  • 输出流：自程序内向外流出
• 按流的角色不同分为：节点流，处理流
  • 节点流：直接作用在文件上，连接作用。
  • 处理流：在节点流基础上包的一层，作为属性出现，可以多次包裹。
• io流大概涉及40多个类但基本上都是由四个抽象基本类派生的（不能实例化）
  • 抽象基类：
  • InputStream
  • OutputStream
  • Reader
  • Writer
• 由这四个类派生出来的子类名称都是以其父亲名作为子类后缀

2、节点流(也叫文件流)

• FileInputStream
• FileOutStream
• FileReader
• FileWriter

前两个一般为文件中图片，视频之类传输，后缀可以是.jdp，.ppt，.doc，.mp4等非文本文件

后两个一般为文件中文本文件传输，后缀可以是.txt，.c，.java等文本文件

FileReader(输入)

        //实例化file类的对象,指明要操作的文件
        File file = new File("hello.txt");
        //提供具体的流
        FileReader fr = new FileReader(file);
		//关闭流
		fr.close();

• read():返回读入的一个字符，如果达到文件末尾，返回-1

  int data = fr.read();
  while(data!=-1){
      System.out.println((char)data);
      data=fr.read();
          }
  

• read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1

  char[] cbuf = new char[15];
  int len = fr.read(cbuf);
  System.out.println(len);//结果为文件中字符的个数（长度）
  
  
  //若要打出文件中的内容可以：
  方法一：
  char[] cbuf = new char[15];
  int len;
  while((len =fr.read(cbuf))!=-1){
      for(int i=0;i<len;i++){
          System.out.print(cbuf[i]);
                  }
              }
  方法二：
  char[] cbuf = new char[15];
  int len;
  while((len =fr.read(cbuf))!=-1){
      String str = new String(cbuf,0,len);//从0开始取，每次取len个
      System.out.println(str);
  }
  

• 异常处理(用read()为例，以后的抛出异常以此类推)

  package com.wangluo.study01.io;
  
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileReader;
  import java.io.IOException;
  
  public class demo1 {
      public static void main(String[] args){
          FileReader fr = null;
          try {  //try捕获异常，解决中间出错无法关闭流导致内存泄漏
              //实例化file类的对象,指明要操作的文件
              File file = new File("src/com/wangluo/study01/io/hello.txt");
              //提供具体的流
              fr = new FileReader(file);
              //数据的读入
              int data = fr.read();
              while(data!=-1){
                  System.out.print((char)data);
                  data=fr.read();
              }
          } catch (IOException e) {
              e.printStackTrace();
          } finally {
              try {
                  if(fr!=null)//解决还未实例化就已出现问题导致无法实例化流的关闭问题
                      fr.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
  }
  
  

FileWriter(输出)

        //提供File类的对象，指明写出到的文件
File file = new File("src/com/wangluo/study01/io/hello.txt");
        //提供FileWriter的对象，用于数据的写出
        FileWriter fw = new FileWriter(file);//file后可以添加true或false，表示文件覆盖或追加
        //流的关闭
        fw.close();

• write()

  fw.write("i have a dream");
  //可以加/n换行
  

FileReader和FileWriter结合使用

package com.wangluo.study01.io;

import java.io.*;

public class demo1 {
    public static void main(String[] args){
        FileReader fr = null;
        FileWriter fw = null;
        //使用try catch finally抛出异常
        try {
            //实例化两次，指定两个将要操作的文件
            File file1 = new File("src/com/wangluo/study01/io/hello.txt");
            File file2 = new File("src/com/wangluo/study01/io/hello2.txt");
            //实例化想要进行的操作
            fr = new FileReader(file1);
            fw = new FileWriter(file2);
            //创建一个char类型数组用于放置内容
            char[] fc = new char[5];
            int len;
            //内容每五个循环输入数组中同时从数组中输出到文件中，长度为len可以允许不够五个的情况
            while ((len=fr.read(fc))!=-1){
                //可以直接将内容输出，数组中内容，从0个开始，长度为len
                fw.write(fc,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //判断是否已经实例化
            if(fr!=null) {
                //抛出异常，放置无法正常关闭流
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fw!=null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileInputStream和FileOutputStream

• FileInputStream使用和FileReader大体一致

• FileOutputStream使用和FileWriter大体一致

所以这里就实现两者的统一使用

package com.wangluo.study01.io;

import java.io.*;

public class demo1 {
    public static void main(String[] args){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //实例化指定文件
            File file1 = new File("src/com/wangluo/study01/io/图片.jpg");
            File file2 = new File("src/com/wangluo/study01/io/图片1.jpg");
            //实例化要进行的具体操作
            fis = new FileInputStream(file1);
            fos = new FileOutputStream(file2);
            //复制过程(字节流创建byte数组存储)
            byte[] buffer = new byte[5];
            int len;
            while((len=fis.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis!=null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos!=null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2、缓冲流(处理流的一种)

• BufferedInputStream

• BufferedOutputStream

• BufferedReader

• BufferedWriter

分别对应节点流，套接到已有的流的基础上

作用：提高流的读取，写入速度

原因：提供内部的缓冲区

BufferedStream(缓冲流与字节流)

此处直接引入案例

package com.wangluo.study01.io;

import java.io.*;

public class demo1 {
    public static void main(String[] args){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //造文件
            File srcfile = new File("src/com/wangluo/study01/io/图片.jpg");
            File destfile= new File("src/com/wangluo/study01/io/图片1.jpg");
            //造流
            //先造节点流
            FileInputStream fis = new FileInputStream(srcfile);
            FileOutputStream fos = new FileOutputStream(destfile);
            //再造缓冲流、
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //复制：读取和写入
            byte[] buffer = new byte[10];
            int len;
            while((len=bis.read(buffer))!=-1){
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //资源关闭：要求先关外层流，再关闭内层流（先关缓冲流，再关节点流）
            try {
                if(bos!=null)
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(bis!=null)
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            //说明：关闭外层流的同时，内层流也会自动进行关闭
        }
    }
}

总的来说，缓冲流便是在节点流上添加一层流，还要先造节点流，使用的时候也要使用缓冲流实例化的名字，关闭先关闭外层的流，但因为在关闭外层流的同时会自动关闭内层流，所以只需关闭外层流即可。

缓冲流与字符流

• 这里和前面的一样，就不多做演示

这里有一种缓冲流的简易写法（熟练后可以使用）

BufferedReader br = new BufferedReader(new FileReader(new File("地址")));

除了char方式的读写操作还有一种：

String：

String data;
//readLine读一行，返回一行内容
while((data=br.readLine())!=null){
    bw.write(data);//这里不包含换行符
    bw.newLine();//加入换行符，也可加"\n"
}

3、转换流(处理流的一种)

属于字符流

• InputStreamReader：将一个字节的输入流转换为字符的输入流

• OutputStreamWriter：讲一个字符的输出流转换为字节的输出流

作用：提供字节流与字符流之间的转换

解码：字节，字节数组–>字符，字符数组

编码：字符，字符数组–>字节，字节数组

字节转字符

FileInputStream fis = new FileInputStream("src/com/wangluo/study01/io/hello.txt");
//指明了字符集为utf-8，具体使用那个字符集，取决于文件保存时使用的字符集，不写为默认
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
        char[] cbuf = new char[5];
        int len;
        while((len=isr.read(cbuf))!=-1){
            String str = new String(cbuf,0,len);
            System.out.print(str);
        }
        isr.close();

4、对象流(处理流的一种)

• ObjectInputStream
• ObjectOutputStream

用于存储和读取基本数据类型数据或对象的处理流。

可以将Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

• 序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
• 反序列化：用ObjectInputStream类读取基本类型数据或对象的机制
• ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

此处未完，后序补充。。。。。。