16种IO流初入门

流的概念：一组有序的数据序列

IO流–四大底层抽象类：

注：输出流不flush可能造成丢失数据！

常用的16个流

一、文件专属：（节点流（基础流），直接对文件进行一个一个字节/字符的读取和写入，读取效率低下）

1. java.io.FileInputStream
2. java.io.FIleOutputStream
3. java.io.FileReader（只适用于普通文本）
4. java.io.FileWriter（只适用于普通文本）

文件的拷贝：使用文件输入/输出流

示例代码：

package filestream;

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

/**
 * 使用FileInputStream + FileOutputStream完成文件的拷贝
 * 拷贝的过程是：一边读一边写
 * 使用以上的字节流拷贝文件的时候，文件类型随意，万能的：什么样的文件都能拷贝
 */
public class Copy01 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("text.txt");//输入流，此处是被拷贝文件的目录，可以使用绝对路径
            fos = new FileOutputStream("textcopy.txt");//输出流，此处是拷贝文件的目录，可以使用绝对路径

            //核心： 一边读、一边写
            byte[] bytes = new byte[1024 * 1024];//一次最多拷贝1MB
            int readCount = 0; //设定当前字读取节长度默认值
            while (-1 != (readCount = fis.read(bytes))) {
                fos.write(bytes,0,readCount);//写入指定长度readCount的字节数组
            }
            System.out.println("拷贝成功！");
            //刷新，输出流最后需要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != fos) {
                try {
                    fos.close();

                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if (null != fis) {
                try {
                    fis.close();

                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

使用字符流拷贝纯文本文件（只能是普通文本文件）

/**
 * 只能拷贝普通文本文件
 */
public class Copy02 {
    public static void main(String[] args) {
        FileReader in = null;
        FileWriter out = null;
        try {
            in = new FileReader("temp.txt");
            out = new FileWriter("ttt.txt");
            char[] chars = new char[1024*1024];//1MB
            int readCount = 0;
            while (-1 != (readCount = in.read(chars))){
                out.write(chars,0,readCount);
            }
            out.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null!=in){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != out) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

二、转换流：（将字节流转换成字符流，包装流（高级流））

1. java.io.InputStreamReader
2. java.io.OutputStreamWriter

  //字节流
        FileInputStream in = new FileInputStream("text.txt");
        //通过转换流转换（InputStreamReader将字节流转换成字符流）
        //in是节点流，reader是包装流
        InputStreamReader reader = new InputStreamReader(in);

        BufferedReader br = new BufferedReader(reader);

三、缓冲流：利用缓存区临时存储数据（内存），减少对文件的直接读取\写入次数，提高读写的效率，是包装流（高级流）

1. java.io.BufferedReader
2. java.io.BufferedWriter
3. java.io.BufferedInputStream
4. java.io.BufferedOutputStream

利用缓存流拷贝数据

public class Test {
    public static void main(String[] args) throws IOException {

        //创建文件夹
//        File dir = new File("C:\\Users\\99779\\Desktop\\Study\\javaJob\\practice\\file");
//        if (!dir.exists()) {
//            if (dir.createN) {
//                System.out.println("文件夹创建成功");
//                System.out.println(dir.getAbsolutePath());
//            }else {
//                System.out.println("创建失败");
//            }
//        }

        File src = new File("C:\\Users\\99779\\Desktop\\Study\\jx\\CentOS-7-x86_64-DVD-1908.iso");
        File dest = new File("file\\" + src.getName());
        final int M8 = 8*1024*1024;//设置读取单位8Mb
        final int M64 = 64*1024*1024;//设置缓存空间64Mb

        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src),M64);//缓存读取写入过程：磁盘空间->缓存空间->磁盘空间
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest),M64);

        byte[] bs = new byte[M8];
        int len = -1;

        while (-1 != (len = bis.read(bs))) {
            bos.write(bs,0,len);
        }
        bos.flush();
        System.out.println("文件复制成功");
        bis.close();
        bos.close();
    }
}

四、数据流专属：

1. java.io.DataInputSteam（把数据及其数据的类型一并读取）
2. java.io.DataOutputStream（把数据及其数据的类型一并写入）
   注：数据流写入的文件，只能由数据流正确读取

五、标准输出流（System.out.println(输出)）：

1. java.io.PrintWriter
2. java.io.PrintStream

public class PrintStreamTest {
    public static void main(String[] args) {
        //就是System.out.println("xxx")
        System.out.println("hello world");

        //分开写
        PrintStream ps = System.out;
        ps.println("你好");
        ps.println("555");

        //注：标准输出流不需要手动close()关闭


        //标准输出流不再指向控制台，指向“log"文件
        try {
            PrintStream pri = new PrintStream(new FileOutputStream("log"));
            //修改输出方向，叫输出方向改变为"log"文件
            System.setOut(pri);
            //在输出
            System.out.println("hello");
            System.out.println("666");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

六、对象专属流：

1. java.io.ObjectInputStream
2. java.io.ObjectOutputStream