数据结构使用三：IO

流可以理解为char[]或byte[]数据结构和对应的一组操作，区别string串，流处理数据量更大，操作(数据交换/传输)更单一！

字节文件操作流：

    //转 https://blog.csdn.net/qq_33642117/article/details/52074796
    public void ioFile()throws FileNotFoundException, IOException {
        // 创建文件对象
        File file = new File("C:\\a.txt");
        // 创建文件输出流
        FileOutputStream fos = new FileOutputStream(file);
        fos.write('a');
        //fos.write("a");    //Stream只能按照字节读写！
        fos.close();

        // 创建文件输入流
        FileInputStream fis = new FileInputStream(file);
        // 有对多长，就读多少字节。
        for (int i = 0; i < file.length(); i++) {
            System.out.print((char) fis.read());    //Stream只能按照字节读写
        }
        fis.close();
    }

    //转 https://blog.csdn.net/zhaoyanjun6/article/details/54292148
    public void copyFile(){
        String filePath_old = "C:\\Users\\liu_bin\\Desktop\\金宝贝.png";
        String filePath_new = "C:\\Users\\liu_bin\\Desktop\\b.png";
        FileInputStream fis=null ;
        FileOutputStream fout = null ;
        try {
            // 根据path路径实例化一个输入流的对象
            fis  = new FileInputStream( filePath_old );
            //2. 返回这个输入流中可以被读的剩下的bytes字节的估计值；
            int size =  fis.available() ;
            //3. 根据输入流中的字节数创建byte数组；
            byte[] array = new byte[size];
            //4.把数据读取到数组中；
            fis.read(array) ;        //Stream流 字节读取

            //5、根据文件路径创建输出流
            fout = new FileOutputStream(filePath_new) ;
            //5、把byte数组输出；
            fout.write( array );    //Stream流 字节输出
        }catch(FileNotFoundException e) {
            e.printStackTrace();
        }catch(IOException e) {
            e.printStackTrace();
        }finally{
            if ( fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if ( fout != null ) {
                try {
                    fout.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

import java.io.FileInputStream;
import java.io.FileOutputStream;

class FileInputStream extends InputStream (字节流抽象类)   implements Closeable
构造方法：
    // 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的File对象file指定
    FileInputStream(File file)
    // 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的路径name指定
    FileInputStream(String name)
 常用方法：覆盖和重写了父类的的常用方法。


class FileOutputStream extends OutputStream (字节流抽象类)  implements Closeable
 构造方法：
    // 创建一个向指定File对象表示的文件中写入数据的文件输出流
    FileOutputStream(File file)
    // 创建一个向指定File对象表示的文件中写入数据的文件输出流
    FileOutputStream(File file, boolean append)
    // 创建一个向具有指定名称的文件中写入数据的输出文件流
    FileOutputStream(String name)
    // 创建一个向具有指定name的文件中写入数据的输出文件流
    FileOutputStream(String name, boolean append)
 常用方法：覆盖和重写了父类的的常用方法。

字节缓冲流

InputStream in = new FileInputStream("test.txt");
// 字节缓存流，在字节节点流继承上构造
BufferedInputStream bis = new BufferedInputStream(in);
byte[] bs = new byte[20];
int len = 0;
while ((len = bis.read(bs)) != -1) {
    System.out.print(new String(bs, 0, len));
    // ABCD
    // hello
}
// 关闭流
bis.close();

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt", true));
// 输出换行符
bos.write("\r\n".getBytes());
// 输出内容
bos.write("Hello Android".getBytes());
// 刷新此缓冲的输出流
bos.flush();
// 关闭流
bos.close();

 

文件字符流

 FileReader：InputStreamReader类的直接子类，用来读取字符文件的便捷类，使用默认字符编码。
 class FileReader extends InputStreamReader extends Reader
 
 FileWriter：OutputStreamWriter类的直接子类，用来写入字符文件的便捷类，使用默认字符编码.
 class FileWriter extends OutputStreamWriter extends Writer

字节流转字符流：使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

       //使用默认编码        
        InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"));
        int len;
        while ((len = reader.read()) != -1) {
            System.out.print((char) len);//爱生活，爱Android
        }
        reader.close();
         
       //指定编码 
        InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"),"utf-8");
        int len;
        while ((len = reader.read()) != -1) {
            System.out.print((char) len);//????????Android
        }
        reader.close();


 构造方法：
    // 创建一个使用默认字符集的 InputStreamReader
    InputStreamReader(InputStream in)
    // 创建使用给定字符集的 InputStreamReader
    InputStreamReader(InputStream in, Charset cs)
    // 创建使用给定字符集解码器的 InputStreamReader
    InputStreamReader(InputStream in, CharsetDecoder dec)
    // 创建使用指定字符集的 InputStreamReader
    InputStreamReader(InputStream in, String charsetName)
 特有方法：
    //返回此流使用的字符编码的名称 
    String getEncoding() 

 构造方法：
    // 创建使用默认字符编码的 OutputStreamWriter
    OutputStreamWriter(OutputStream out)
    // 创建使用给定字符集的 OutputStreamWriter
    OutputStreamWriter(OutputStream out, Charset cs)
    // 创建使用给定字符集编码器的 OutputStreamWriter
    OutputStreamWriter(OutputStream out, CharsetEncoder enc)
    // 创建使用指定字符集的 OutputStreamWriter
    OutputStreamWriter(OutputStream out, String charsetName)
 特有方法：
    //返回此流使用的字符编码的名称 
    String getEncoding() 

字符缓冲流（高效流）

      //生成字符缓冲流对象
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
        String str;
        //一次性读取一行
        while ((str = reader.readLine()) != null) {
            System.out.println(str);// 爱生活，爱Android
        }
        //关闭流
        reader.close();

 构造方法：
    // 创建一个使用默认大小输入缓冲区的缓冲字符输入流
    BufferedReader(Reader in)
    // 创建一个使用指定大小输入缓冲区的缓冲字符输入流
    BufferedReader(Reader in, int sz)
 特有方法：
    // 读取一个文本行
    String readLine()

 构造方法：
    // 创建一个使用默认大小输出缓冲区的缓冲字符输出流
    BufferedWriter(Writer out)
    // 创建一个使用给定大小输出缓冲区的新缓冲字符输出流
    BufferedWriter(Writer out, int sz)
 特有方法：
    // 写入一个行分隔符
    void newLine() 

总结：

import java.io.InputStream;
import java.io.OutputStream;

//转换流：用于字节数据到字符数据之间的转换,仅有字符流
import java.io.InputStreamReader;   //需要与InputStream“套接”
import java.io.OutputStreamWriter;  //需要与OutputStream“套接”

//数据流：提供了读写Java中的基本数据类型的功能。
import java.io.DataInputStream;     //需要“套接”在InputStream和OutputStream类型的节点流之上
import java.io.DataOutputStream;

//对象流：用于直接将对象写入写出
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

//缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写效率。
//对于输出地缓冲流，写出的数据，会先写入到内存中，再使用flush方法将内存中的数据刷到硬盘
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
//字符缓冲流分别提供了读取和写入一行的方法ReadLine和NewLine方法
import java.io.BufferedReader;
import java.io.BufferedWriter;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;

File类

File类是对文件系统中文件以及文件夹进行封装的对象，可以通过对象的思想来操作文件和文件夹。 File类保存文件或目录的各种元数据信息，包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名，判断指定文件是否存在、获得当前目录中的文件列表，创建、删除文件和目录等方法。