I/O流

• 流的概念

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象，即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

根据处理数据类型的不同，流分为：字符流和字节流

字符流的由来： 因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。字节流和字符流的区别：

（1）读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

（2）处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

（3）字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的；而字符流在操作的时候下后是会用到缓冲区的，是通过缓冲区来操作文件，我们将在下面验证这一点。

结论：优先选用字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的，包括图片等内容。但是字符只是在内存中才会形成的，所以在开发中，字节流使用广泛。

流的类图结构

 

 

 

 

• 字节流

  • 字节输入流

　　　　 public void m1() throws IOException {
        
        //1.创建文件字节输入流对象
        InputStream in = new FileInputStream("G:\\testInWord.txt");
        
        //2.创建一个字节数组来存放读取到的数据
        byte []buf = new byte[10];//读10个字节
        
        //3..通过输入流对象读取数据
        in.read(buf);
        
        //4.将字节流转为字符串显示
        String string= new String(buf);
        System.out.println(string);
        
        //5.关闭流
        in.close();
    }

 

• • 字节输出流

　　　　 public void m1() throws IOException {

        //1.创建文件字节输出流对象
        //第一个参数表示输出的路径
        //第二个参数表示文本的追加方式，如果为ture，那这次输出的数据追加在目标文件里的数据的后面，如果没有会覆盖文件中原来的数据
        OutputStream out = new FileOutputStream("G:\\testOutWord.txt",true);
        
        //2准备输出的数据
        String str = "这是要输出的数据";
        
        //3.通过输出流对象输出数据
        out.write( str.getBytes());
        
        //4.将数据刷出
        out.flush();
        
        //关闭数据
        out.close();
    }
    

 

• • 缓冲字节输入流

　　　　  //带缓存的输入流
   　　  public void m2() throws IOException {
        //1.创建文件输入流对象
        InputStream in = new FileInputStream("G:\\testWord.txt");
        
        //2.堆输入流对象进行封装
        BufferedInputStream bin = new BufferedInputStream(in);
        
        //3.创建一个字节数组用于装每一字读取到的数据
        byte []buf = new byte[10];
        String str = "";
        
        //循环读取数据直到文件中的数据被读取完
        while(bin.read(buf) != -1 ) {//判断是否以读取到末尾
            str += new String(buf); //将每一次到到的连接到上一次的末尾
        }
        
        System.out.println(str);
        
        bin.close();//先关闭内部打开的
        in.close();//先开的最后关
    }

 

• • 缓冲字节输出流

　　　　 //带缓存的字节输出流，用于大文件
    　　public void m2() throws InterruptedException, IOException {
        
        //1.创建一个文件字节输出流对象
        OutputStream out = new FileOutputStream("G:\\testOutWord.txt",true);
        
        //对象输出流进行封装
        BufferedOutputStream bout = new BufferedOutputStream(out);
        
        //准备要封装的数据
        byte []buf = {'a','b','c'};
        
        //每隔一秒输出一个字节
        for( int i = 0; i < buf.length; i++ ) {
            Thread.sleep(1000);
            bout.write(buf[i]);//输出数据
        }
        
        //将数据刷出
        bout.flush();
        
        //关闭流
        bout.close();
        out.close();
    }

 

• 字符流

  • 字符输入流

   　　 public void m1() throws IOException {
        
        //创建一个字符输入流对象
        Reader in = new FileReader("G:\\testOutWord.txt");
        
        //准备一个字符数组
        char[] cbur = new char[10];
        
        String str ="";
        //循环读取数据直到末尾
        while( in.read(cbur) != -1) {
            str += new String(cbur);
        }
        //读取数据并转到数组中
//        in.read(cbur);//这是有限读取
        
        //显示读取到的数据
//        String str = new String(cbur);
        System.out.println(str);
        
        in.close();
                
    }

 

• • 字符输出流

　　　　 public void m1() throws IOException {
        
        //创建文件字符输出流对象
        Writer out = new FileWriter("G:\\testOutWord.txt",true);
        
        //2.准备数据 
        String str = "nihao dfjh skdj";
        
        //通过数据流输出对象数据流
        out.write(str);
        
        out.flush();
        
        out.close();
    }

 

• • 缓存字符输入流

 1　　　　  public void m1() throws IOException {
        //1.创建一个字符串输入对象
        Reader in = new FileReader("G:\\testOutWord.txt");
        
        //2.封装符串输入流对象
        BufferedReader bin = new BufferedReader(in);
        String str = "";
        StringBuffer buffer = new StringBuffer();
        
        //3.循环读取文件中的数据
        while( (str = bin.readLine()) != null ) {
            buffer.append(str);
            buffer.append("\n");//每读取一行数据添加一个换行符
        }
        
        //4.使用数据
        System.out.println(buffer.toString());
        
        //5.
        bin.close();
        in.close();
    }
    

 

 

• 对象流

首先建立一个用于序列化和反序列化的类，这里建立一个People类如下：

import java.io.Serializable;

/**
 * javabean  :符合某种规范的类
 * 1.私有化成员变量
 * 2.提供get/set方法
 * 3.实现Serializable接口
 * 4.必须有共有无参构造器
 * @author me
 *
 */
public class People implements Serializable{

    private String name;
    private int age;
    private char sex;
    
    
    public People() {
        super();
    }

    public People(String name, int age, char sex) {
        super();
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "People [name=" + name + ", age=" + age + ", sex=" + sex + "]";
    }
      
}

 

• • 对象序列化（对象输出流）

　　//对象序列化
    public void m1() throws IOException {
        
        //创建文件字节输出流对象
        OutputStream out = new FileOutputStream("G:\\testOutWord.txt");
        
        //创建对象输出流
        ObjectOutputStream obj = new ObjectOutputStream(out);
        
        //创建实现了Seri接口的类来创建
        People people = new People("Jake",15,'男');
        
        //输出到文件
        obj.writeObject(people);
        
        //关闭
        obj.close();
        out.close();
    }

 

• • 对象反序列化（对象输入流）

　　//反序列化
    public void m2() throws IOException, ClassNotFoundException {
        
        InputStream in = new FileInputStream("G:\\testOutWord.txt");
        
        ObjectInputStream obj = new ObjectInputStream(in);
        
        People people = (People) obj.readObject();
        
        obj.close();
    }

 

• • 序列化反序列化的另外一个例子

public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
    
        Person person = new Person("小黑",25);//Person类的代码省略
        
        //序列化Person
        ObjectOutputStream oo = new ObjectOutputStream( new FileOutputStream( new File("E:\\newF\\testword.txt")));
        oo.writeObject(person);
        oo.close();
        System.out.println("serializa successed!");
        
        //反序列化Person
        ObjectInputStream oi = new ObjectInputStream( new FileInputStream( new File("E:\\newF\\testword.txt")));
        Person person2 = (Person) oi.readObject();//需要强转
        System.out.println(person2);
    }