Java-IO流总结

IO流：

IO流分为两大类：字节流和字符流

 

IO的作用就是为了读写操作的。

   每种流都分为输入流(Input)、输出流(Output)；站在java程序的角度来说，java程序进行读取操作时，就是输入流；如果java程序向其他地方(硬盘，其他的设备)写入操作时，就是输出流。

IO流只能操作文件，不能操作文件夹，否则会报错。

 

字节流：

字节输入流：InputStream

字节输出流：OutputStream

OutputStream：

可以向文件中写入字节,进行写入常用的是OutputStream的子类：FileOutputStream，常用的写入方法是write(byte[]),传入byte数组。

 

下面将是演示利用FileOutputStream来进行写入文件：

 

package com.xiaoshitou_io;

import java.io.FileOutputStream;
import java.io.IOException;

public class Test {

    /**
     * 使用FileOutputStream来写入文件
     * @throws IOException 
     * 
     */
    public static void main(String[] args) throws IOException {
        // 创建FileOutputStream对象
        // write.txt 文件在项目的根目录下面
        FileOutputStream fos = new FileOutputStream("write.txt");
        // 准备byte数组
        byte[] b = "Hello every body!".getBytes();
        
        // 写入整个数组
        fos.write(b);
        // 写入换行符,System.lineSeparator()方法返回一个字符串，表示跨平台的换行符
        fos.write(System.lineSeparator().getBytes());
        // 写入数组的一部分
        fos.write(b, 0, 5);// 应该写入的是Hello
        
        // 关闭输出流
        fos.close();
        // 文件的内容为：
        /*
        Hello every body!
        Hello
        */
        
        
    }

}

 

   如果写入的文件存在，会被覆盖掉；要想在文件的末尾进行追加内容（保留以前的内容），就需要在创建FileOutputStream对象是，向构造器传入一个true；下面演示向文件中追加内容：

package com.xiaoshitou_io;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {

    /**
     * 使用FileOutputStream来写入文件
     * 直接在Write.txt文件追加内容
     * @throws IOException 
     * 
     */
    public static void main(String[] args) throws IOException {
        // 创建FileOutputStream对象
        // write.txt 文件在项目的根目录下面
        
        File writeFile = new File("write.txt");
        // 在创建对象传入一个true
        FileOutputStream fos = new FileOutputStream(writeFile, true);
        // 准备byte数组
        byte[] b = (System.lineSeparator()+"我是追加的内容,哈哈").getBytes();
        // 写入文件
        fos.write(b);
        
        // 关闭输出流
        fos.close();
        // 文件的内容为：
        /*
        Hello every body!
        Hello
        我是追加的内容,哈哈
        */
        
        
    }

}

InputStream:

　　进行文件的读取经常使用的是InputStream的子类，FileInputStream可以读取任何文件，经常用的方法就是直接读入一个byte数组，这样是为了提高读取效率，不是用一个一个字节的读取。

　　下面演示一个文件的复制，文件的复制，就是利用字节输入流读取文件，然后利用输出流写入文件。下面是复制一个视频文件(同时用了输入流和输出流)：

package com.xiaoshitou_io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {

    /**
     * 将C:UsersBeckDesktop	emp目录下all.avi文件复制到
     * 当前文件中，名字为copy.avi
     */
    public static void main(String[] args){
        // 创建输入输出流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
            File file = new File("C:/Users/Beck/Desktop/temp");
            fis = new FileInputStream(new File(file, "all.avi"));
            fos = new FileOutputStream(new File(file, "copy.avi"));
            // 进行读写操作
            int len = -1;
            // 每次读入1M
            byte[] b = new byte[1024*1024];
            while ((len=fis.read(b)) != -1){
                // 写入
                fos.write(b, 0, len);
            }
            
        }catch (IOException e){
            e.printStackTrace();
            throw new RuntimeException("文件复制失败!");
        }finally{
            // 关闭流对象
            try{
                if (fos != null){
                    fos.close();
                }
            }catch (IOException e){
                e.printStackTrace();
                throw new RuntimeException("释放资源失败!");
            }finally{
                try{
                    if (fis != null){
                        fis.close();
                    }
                }catch (IOException e){
                    e.printStackTrace();
                    throw new RuntimeException("释放资源失败!");
                }
            }
        }
        System.out.println("复制文件完毕!");
        // 输出结果:
        /*复制文件完毕!*/
    }

}

BufferedInputStream&BufferedOutputStream:

　　字符缓冲输入流和字符缓冲输出流，这两个流的作用的是提高输入输出的效率。BufferedInputStream&BufferedOutputStream，接收的参数分别是InputStream，OutputStream,底层还是利用字节的输入输出流，只是对输入输出流进行了封装。

　　下面利用BufferedInputStream&BufferedOutputStream进行文件的复制：

package com.xiaoshitou_io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {

    /**
     * 将C:UsersBeckDesktop	emp目录下all.avi文件复制到
     * 当前文件中，名字为copy.avi
     * 这次使用的是BufferedInputStream 和 BufferedOutputStream来完成
     */
    public static void main(String[] args){
        // 创建缓冲输入输出流
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try{
            File file = new File("C:/Users/Beck/Desktop/temp");
            bis = new BufferedInputStream(new FileInputStream(new File(file, "all.avi")));
            bos = new BufferedOutputStream(new FileOutputStream(new File(file, "copy.avi")));
            // 进行读写操作
            int len = -1;
            // 每次读入1M
            byte[] b = new byte[1024*1024];
            while ((len=bis.read(b)) != -1){
                // 写入
                bos.write(b, 0, len);
            }
            
        }catch (IOException e){
            e.printStackTrace();
            throw new RuntimeException("文件复制失败!");
        }finally{
            // 关闭流对象
            try{
                if (bos != null){
                    bos.close();
                }
            }catch (IOException e){
                e.printStackTrace();
                throw new RuntimeException("释放资源失败!");
            }finally{
                try{
                    if (bis != null){
                        bis.close();
                    }
                }catch (IOException e){
                    e.printStackTrace();
                    throw new RuntimeException("释放资源失败!");
                }
            }
        }
        System.out.println("复制文件完毕!");
        // 输出结果:
        /*复制文件完毕!*/
    }

}

练习:把一个视频文件按照5M的大小切割成多个。

package com.xiaoshitou_io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {

    /**
     * 将C:UsersBeckDesktop	emp目录下all.avi文件复制到
     * 这次是把all.avi视频文件切割成多个文件。按照每个文件5M的大小切割
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException{
        // 这次我把IOException直接抛出去了没有捕获
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("C:/Users/Beck/Desktop/temp/all.avi"));
        // 读取视频文件
        int len = -1;
        // 每次读入5M
        byte[] bytes = new byte[1024*1024*5];
        int flag = 0;
        while ((len=bis.read(bytes)) != -1 ){
            flag++;
            // 把读入的文件写入到一个文件中
            writeToFile(bytes, len, flag);
        }
        // 关闭输入流
        bis.close();
        System.out.println("切割完成!");
        
        
    }

    // 将一个byte数组的内容写入到一个文件中
    private static void writeToFile(byte[] bytes, int len, int flag) throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("C:/Users/Beck/Desktop/temp/copy_"+flag+".avi"));
        bos.write(bytes, 0, len);
        bos.close();
    }
}

　　切割结果：

字符流：

输出流：Writer

输入流：Reader

字符流的底层是字节流+编码表

字符流只能操作文本文件，进行文本文件的读写，如果是为了复制文件的话，最好选择字节流进行复制。

Writer：

Writer下面有两个常用的字符输出流：OutputStreamWriter和FileWriter

 

OutputStreamWriter：接收的参数是一个OutputStream参数，也可以传一个charset编码字符串，这样就可以按照你设置的编码写入文本文件中。

 

以utf-8编码形式向文本文件中写入内容：

 

package com.xiaoshitou_io;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Test {
    /*
     * 以utf8的格式向文件中写入字符串
     */
    public static void main(String[] args) throws IOException{
        // 创建 OutputStreamWriter对象
        OutputStreamWriter osw = new OutputStreamWriter(
                new FileOutputStream("wirter.txt"),"utf-8");
        
        osw.write("我是OutputStreamWriter写入的，");
        osw.write("我的编码是UTF-8格式的。");
        // 字符流需要自己刷新
        osw.flush();
        // 关闭流
        osw.close();
        //输出结果，两句话在一行，因为没有写入换行符
        /*
        我是OutputStreamWriter写入的，我的编码是UTF-8格式的。
        */
        
    }        

}

 

FileWriter：可以接收的参数可以是File对象或者是String类型的；它的编码是系统默认的编码，我们的一般编码是使用的是GBK编码。

使用FileWriter向文本文件中写入字符串：

 

package com.xiaoshitou_io;

import java.io.FileWriter;
import java.io.IOException;

public class Test {
    /*
     * 用FileWriter向文件中写入内容
     */
    public static void main(String[] args) throws IOException{
        // 创建 FileWriter对象
        FileWriter fw = new FileWriter("writer_gbk.txt");
        
        fw.write("我是用FileWriter写的");
        // 写入换行符
        fw.write(System.lineSeparator());
        fw.write("我的编码是用的是默认的，GBK");
        fw.flush();
        
        // 关闭流
        fw.close();
        // 输出结果
        /*
        我是用FileWriter写的
        我的编码是用的是默认的，GBK
        */
                
    }
        

}

 

Reader:

Reader下面有两个常用的字符流：InputStreamReader，FileReader

InputStreamReader：可以按照指定的编码去读取文本文件，接收的参数是InputStream和一个编码字符串。

以utf-8的编码去读取一个文本文件：

 

package com.xiaoshitou_io;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test {
    /*
     * 以UTF-8去读取writer.txt
     * 这个文件是刚才用utf-8的格式写入的，
     * 也只能以utf8的格式去读取，否则会出现乱码
     */
    public static void main(String[] args) throws IOException{
        // 创建InputStreamReader对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("wirter.txt"), "utf-8");
        
        int len = -1;
        // 一次可以读取1024个字符，2*1024个字节，2KB
        char[] ch = new char[1024];
        while ((len=isr.read(ch)) != -1){
            System.out.print(new String(ch, 0, len));
        }
        // 关闭流
        isr.close();
        // 输出结果：
        /*
        我是OutputStreamWriter写入的，我的编码是UTF-8格式的。
        */
    }
        

}

 

FileReader：以系统默认的编码去读取一个文本文件。接收的参数可以是一个File或者String。

用FileReader去读取GBK的文件，系统默认的编码是GBK

 

package com.xiaoshitou_io;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Test {
    /*
     * 用FileReader来读取文件writer_gbk.txt
     * FileReader默认是用的是系统的默认编码
     * 本机的默认编码是GBK
     */
    public static void main(String[] args) throws IOException{
        // 创建FileReader对象
        FileReader fr = new FileReader(new File("writer_gbk.txt"));
        
        int len = -1;
        char[] ch = new char[1024];
        while ((len=fr.read(ch)) != -1){
            System.out.println(new String(ch,0,len));
        }
        
        // 关闭流
        fr.close();
        // 输出结果
        /*
        我是用FileWriter写的
        我的编码是用的是默认的，GBK
        */
        
    }
        

}

 

乱码：

乱码产生的原因：用一个A编码表将字符转成字节, 又用B编码表将字节转回字符. 两个编码表对应的关系不同,因此查到的结果就不同.

保证不乱码的方式 : 编码与解码保持相同.

 

字符流复制文件原理：

BufferedReader&BufferedWriter:

BufferedReader&BufferedWriter：字符缓冲输入输出流，接收的参数分别是：Reader，Writer；作用是提高读写的速度，读写时字符的编码是系统默认的编码：

BufferedReader特有的一个方式读取一行readLine(),不会读取换行符

BufferedWrter特有的一个方法时，newLine()写入一个换行符

在写入的数据之后，需要手动flush。

利用BufferedReader&BufferedWriter进行文本文件的读写：

 

package com.xiaoshitou_io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Test {
    /*
     * 利用BufferedReader&BufferedWriter进行文本文件的读写：
     * 复制文件：test.properties
     */
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new FileReader("test.properties"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("test_copy.properties"));
        
        // 进行读写,缓冲流特有的方法就是可以按照行来读取，如果读取结束返回null
        String line = null;
        while ((line=br.readLine()) != null){
            bw.write(line);
            // 写入换行
            bw.newLine();
            // 刷新
            bw.flush();
        }
        
        // 关闭流
        bw.close();
        br.close();
        
    }
        
}

 

字节流和字符流的总结：

　　IO流只能操作文件”文件”,不能操作文件夹(目录)，否则会出现异常。

打印流：

　　PrintStream,PrintWriter：字节打印流，字符打印流；打印流只有输出流，没有输入流；输出的目的可以是文件，也可以是其他流。PrintStream自带刷新功能，PrintWriter需要手动开启。

　　PrintStream：打印出来的字符的编码使用的是系统默认编码。

package com.xiaoshitou_io;

import java.io.IOException;
import java.io.PrintStream;

public class Test {
    /*
     * 使用打印流：PrintStream
     */
    public static void main(String[] args) throws IOException{
        
        PrintStream ps = new PrintStream("print.txt");
        ps.println("旺旺");
        ps.println("欢欢");
        ps.println("乐乐");
        ps.close();
        // 结果：
        /*
        旺旺
        欢欢
        乐乐
        */
    }
        

}

　　PrintWriter:

package com.xiaoshitou_io;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class Test {
    /*
     * 使用打印流：PrintWriter
     */
    public static void main(String[] args) throws IOException{
        // 创建PrintWriter对象时，开启自动刷新功能
        PrintWriter pw = new PrintWriter(new FileWriter("print.txt"), true);
        
        pw.println("我是PrintWriter");
        pw.println("出来的");
        
        pw.close();
        // 结果：
        /*
        我是PrintWriter
        出来的
        */
    }
        

}

序列化&反序列化:

序列化：就是将对象写入文件的过程

反序列化：从文件读入对象的过程

ObjectOutputStream&ObjectInputStream：需要序列化的对象必须去实现Serializable接口，否则在序列化的时候会出错。

序列化的注意点：

1、static修饰的成员不能被序列化

2、要想成员变量不被序列化，可以用transient关键字修饰

3、为了不发生序列号冲突，设置：serialVersionUID

下面就进行序列化和反序列化：

 

package com.xiaoshitou_io;

import java.io.Serializable;

public class Student implements Serializable{
    private static final long serialVersionUID = -5214244848175027425L;
    private String name;
    private String id;
    private transient String phone;
    
    
    public Student(String name, String id, String phone) {
        super();
        this.name = name;
        this.id = id;
        this.phone = phone;
    }
    public Student() {
        super();
        
    }
    
    @Override
    public String toString() {
        return "Student [name=" + name + ", id=" + id + ", phone=" + phone
                + "]";
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    
}

package com.xiaoshitou_io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
    /*
     * 进行序列化和反序列化
     * 对Student对象序列化
     */
    public static void main(String[] args) throws IOException, ClassNotFoundException{
        // 创建ObjectOutputStream对象,绑定目的地
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tmp.txt"));
        // 创建Student对象
        Student stu = new Student("张三", "T001", "15522223333");
        // 写入对象
        oos.writeObject(stu);
        // 关闭流
        oos.close();
        System.out.println("序列化成功!");
        System.out.println("==============分割==============");
        
        // 进行反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("tmp.txt"));
        // 读取对象
        Object obj = ois.readObject();
        if (obj instanceof Student){
            Student s = (Student)obj;
            System.out.println(s);
        }
        // 关闭流
        ois.close();
        System.out.println("反序列化成功!");
        // 结果：phone是transient关键字修饰的，所以没有被序列化
        /*
        序列化成功!
        ==============分割==============
        Student [name=张三, id=T001, phone=null]
        反序列化成功!
        */
        
        
    }
        

}

Properties：

Properties类是HashTable的一个子类，实现了Map接口，所以里面保存的是键值对，元素的存取是无序的，这个类经常被用来处理配置文件。

利用Properties来读写文件：

 

package com.xiaoshitou_io;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;



public class Test {
    /*
     * 利用Properties来读写文件
     */
    public static void main(String[] args) throws IOException{
        // 读取Properties文件：pro.properties
        Properties pro = new Properties();
        // 加载文件
        pro.load(new FileReader("pro.properties"));
        // 根据key来读取值
        String key = pro.getProperty("key");
        System.out.println(key);
        String value = pro.getProperty("匿名");
        System.out.println(value);
        System.out.println("=============================");
        
        // 修改Properties内的值，或者添加新的值
        pro.setProperty("key", "我是修改的值");
        pro.setProperty("add", "我是新添加的值");
        // 保存进文件
        pro.store(new FileWriter("pro.properties"),"");
        System.out.println("修改完成");
        // 控制台打印结果:
        /*
        姥姥阿里
        娇娇
        =============================
        修改完成
        */
        // pro.properties 文件中的内容：
        /*
        #
        #Sun Jun 11 08:53:22 CST 2017
        key=我是修改的值
        张嘴=监控
        匿名=娇娇
        add=我是新添加的值
        */
    }
}