java IO 流复盘，总结笔记

File类：

通过File类在程序中操作文件和目录。File类可以新建，删除，重命名文件或者目录 但是该路径的文件或者文件夹不一定在磁盘真的存在!!!， File不能访问文件本身。（需要使用输入输出流）

 

file类可以使用文件文件路径字符串创建file对象。（可以是绝对路径或者相对路径）

 

主要方法： String getName（）{}  返回此File对象的文件名或者路径名（如路径，则返回最后一级子路径名）。

String getPath（）{}返回此File对象所对应的路径名。

文件目录操作的相关方法：

boolean mkdir(),创建File对象对应的目录，创建成功返回true，调用该方法的File对象必须对应一个路径，而不是一个文件

String【】 list（）：列出File文件的所有子文件名和路径名 返回一个String数组

file.exists().如果当前file对象存在（磁盘中有，则返回true）。

 

Windows的路径分隔符用“\”,java的“\”是转义字符，起冲突，若需要在windows路径下包括\分隔符，需要两个"\\"

eg:D:\\test\\app.txt

 

下面使用FileInputStream来执行输入，并使用FileOutputStream 来执行输出，用来实现复制“File.txt”文件的功能

package com.ztb.entity;

import java.io.*;

public class FileOutPutStreamTest {

  public static void main(String[] args) {

       try(
            FileInputStream fils=new FileInputStream("File.txt");//创建一个字节输入流，输入源为File.txt文件
            FileOutputStream fos=new FileOutputStream("objects.txt")) {//创建字节输出流，输出源为（objects.txt文件）

              byte[] b = new byte[32];
             int hashRead = 0;

            while ((hashRead = fils.read(b)) > 0) {//循环从流中拿数据32个字节
            fos.write(b, 0, hashRead);//每读取一次，即写入文件输出流，读多少写多少
      }
      }catch (IOException ioException) {
         ioException.printStackTrace();
           }
       }
}  
//注意：这里源文件都是在根目录下真实存在的，否则会报ioexception错误。目标文件可以不存在，会自动在项目的根目录下创建

java中的IO流分类

一.字节流

1，字节缓冲流（高效流）

1）.BufferedInputStream：字节缓冲输入流，提高了读取效率。

构造方法：

// 创建一个 BufferedInputStream并保存其参数，即输入流 in ，以便将来使用。

BufferedInputStream(InputStream in )

// 创建具有指定缓冲区大小的 BufferedInputStream并保存其参数，即输入流 in 以便将来使用

BufferedInputStream(InputStream in , int size)

 

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();

 

2）.BufferedOutputStream:字节缓冲输出流，提高了写出效率。

构造方法：

// 创建一个新的缓冲输出流，以将数据写入指定的底层输出流

BufferedOutputStream(OutputStream out )

// 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流

BufferedOutputStream(OutputStream out , int size)

 

常用方法：

// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流

void write ( byte [] b, int off, int len )

// 将指定的字节写入此缓冲的输出流

void write ( int b )

// 刷新此缓冲的输出流

void flush ()

 

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

read()这个方法完成的事情就是从数据源中读取8个二进制位，并将这8个0或1转换成十进制的整数，然后将其返回(1字符=2字符=2*8个二进制位）

 

2.字节文件操作流

1）.FileInputStream：字节文件输入流，从文件系统中的某个文件中获得输入字节，用于读取诸如图像数据之类的原始字节流。

构造方法：

// 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的File对象file指定

FileInputStream( File file )

// 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的路径name指定

FileInputStream( String name )

 

常用方法：覆盖和重写了父类的的常用方法。

 

// 读取f盘下该文件f://hell/test.txt
        //构造方法1
        InputStream inputStream = new FileInputStream(new File("f://hello//test.txt"));
        int i = 0;
        //一次读取一个字节
        while ((i = inputStream.read()) != -1) {
            // System.out.print(i + " ");// 65 66 67 68
            //为什么会输出65 66 67 68？因为字符在底层存储的时候就是存储的数值。即字符对应的ASCII码。
            System.out.print((char) i + " ");// A B C D
        }
        //关闭IO流
        inputStream.close();

        // 读取f盘下该文件f://hell/test.txt
        //构造方法2
        InputStream inputStream2 = new FileInputStream("f://hello/test.txt");
        // 字节数组
        byte[] b = new byte[2];
        int i2 = 0;
        //  一次读取一个字节数组
        while ((i2 = inputStream2.read(b)) != -1) {
            System.out.print(new String(b, 0, i2) + " ");// AB CD
        }
        //关闭IO流
        inputStream2.close();

注： 一次读取一个字节数组，提高了操作效率,IO流使用完毕一定要关闭

2）.FileOutputStream：字节文件输出流是用于将数据写入到File，从程序中写入到其他位置。

构造方法：

// 创建一个向指定File对象表示的文件中写入数据的文件输出流

FileOutputStream( File file )

// 创建一个向指定File对象表示的文件中写入数据的文件输出流

FileOutputStream( File file , boolean append)

// 创建一个向具有指定名称的文件中写入数据的输出文件流

FileOutputStream( String name )

// 创建一个向具有指定name的文件中写入数据的输出文件流

FileOutputStream( String name , boolean append)

 

常用方法：覆盖和重写了父类的的常用方法。

 

 OutputStream outputStream = new FileOutputStream(new File("test.txt"));
        // 写出数据
        outputStream.write("ABCD".getBytes());
        // 关闭IO流
        outputStream.close();


        // 内容追加写入
        OutputStream outputStream2 = new FileOutputStream("test.txt", true);
        // 输出换行符
        outputStream2.write("\r\n".getBytes());
        // 输出追加内容
        outputStream2.write("hello".getBytes());
        // 关闭IO流
        outputStream2.close();

注；输出的目的地文件不存在，则会自动创建，不指定盘符的话，默认创建在项目目录下;输出换行符时一定要写\r\n不能只写\n,因为不同文本编辑器对换行符的识别存在差异性。

二.字符流

（1）.字符转换流

1）.InputStreamReader

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

构造方法：

// 创建一个使用默认字符集的 InputStreamReader

InputStreamReader(InputStream in )

// 创建使用给定字符集的 InputStreamReader

InputStreamReader(InputStream in , Charset cs)

// 创建使用给定字符集解码器的 InputStreamReader

InputStreamReader(InputStream in , CharsetDecoder dec)

// 创建使用指定字符集的 InputStreamReader

InputStreamReader(InputStream in , String charsetName)

特有方法：

//返回此流使用的字符编码的名称

String getEncoding()

 //使用默认编码        
        InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"));
        int len;
        while ((len = reader.read()) != -1) {
            System.out.print((char) len);//


        }
        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();

 

2）.OutputStreamWriter

OutputStreamWriter：字节流转字符流。

构造方法：

// 创建使用默认字符编码的 OutputStreamWriter

OutputStreamWriter(OutputStream out )

// 创建使用给定字符集的 OutputStreamWriter

OutputStreamWriter(OutputStream out , Charset cs)

// 创建使用给定字符集编码器的 OutputStreamWriter

OutputStreamWriter(OutputStream out , CharsetEncoder enc)

// 创建使用指定字符集的 OutputStreamWriter

OutputStreamWriter(OutputStream out , String charsetName)

特有方法：

//返回此流使用的字符编码的名称

String getEncoding()

 

（3）.字符缓冲流（高效流）

1)BufferedReader：字符缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取.

 

构造方法：

// 创建一个使用默认大小输入缓冲区的缓冲字符输入流

BufferedReader(Reader in )

// 创建一个使用指定大小输入缓冲区的缓冲字符输入流

BufferedReader(Reader in , int sz)

特有方法：

// 读取一个文本行

String readLine()

 

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

2）.BufferedWriter :字符缓冲流，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

构造方法：

// 创建一个使用默认大小输出缓冲区的缓冲字符输出流

BufferedWriter(Writer out)

// 创建一个使用给定大小输出缓冲区的新缓冲字符输出流

BufferedWriter(Writer out, int sz)

特有方法：

// 写入一个行分隔符

void newLine()

（4）.FileReader、FileWriter.

FileReader：InputStreamReader类的直接子类，用来读取字符文件的便捷类，使用默认字符编码。

FileWriter：OutputStreamWriter类的直接子类，用来写入字符文件的便捷类，使用默认字符编码。

5.高效流效率比对

在E盘下读取4M大小的MP4文件。

方法一：用字节输入输出流，一次读取一个字节

 

FileInputStream inputStream = new FileInputStream("E:\\PR\\剪辑成品\\LX.mp4");
  FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
    int len;
   / / 开始时间
        long begin = System.currentTimeMillis();
        // 一次读取一个字节
            while ((len = inputStream.read()) != -1) {
            outputStream.write(len);
        }
           //这里有两点需要注意：一是这个方法的返回值是int类型；二是在这个方法每次从数据源中读取一个byte并返回。
       // 很多初次接触Java的读者在看到这里时都会产生下面的疑问，就是这个方法读取的byte是如何以int的形式返回的。
          // 用时毫秒
            System.out.println(System.currentTimeMillis() - begin);//  耗费时间223195
        / /关闭流释放资源
           inputStream.close();
           outputStream.close();

方法二：用字节输入流，一次读取一个字节数组的数据

/**
* 一次读取一个字节数组,还是使用字节输入输出流
*/
FileInputStream inputStream = new FileInputStream("E:\\PR\\剪辑成品\\LX.mp4");
FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
int len;
byte[] bs = new byte[1024];
// 开始时间
long begin = System.currentTimeMillis();
// 一次读取一个字节数组
while ((len = inputStream.read(bs)) != -1) {
outputStream.write(bs, 0, len);
}
// 用时毫秒
System.out.println(System.currentTimeMillis() - begin);// 75秒就够

inputStream.close();
outputStream.close();

方法三：使用字 符缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

FileInputStream inputStream = new FileInputStream("E:\\PR\\剪辑成品\\LX.mp4");
BufferedInputStream bis = new BufferedInputStream(inputStream);
FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP1.mp4");
BufferedOutputStream bos = new BufferedOutputStream(outputStream);
int len;
byte[] bs = new byte[1024];
// 开始时间
long begin = System.currentTimeMillis();
while ((len = bis.read(bs)) != -1) {
bos.write(bs, 0, len);
}
// 用时毫秒
System.out.println(System.currentTimeMillis() - begin);// 16秒就够

bis.close();
bos.close();

得出结论： 高效缓冲流读写速度效率更高。