1.简介

1.1继承结构

in/out相对于程序而言的输入(读取)和输出(写出)的过程。
在Java中，根据处理的数据单位不同，分为字节流和字符流。

java.io包：
File

字节流：针对二进制文件
InputStream
--FileInputStream
--BufferedInputStream
--ObjectInputStream
OutputStream
--FileOutputStream
--BufferedOutputStream
--ObjectOutputStream

字符流：针对文本文件。读写容易发生乱码现象，在读写时最好指定编码集为utf-8
Reader
--FileReader
--BufferedReader
--InputStreamReader
--PrintWriter/PrintStream
Writer
--FileWriter
--BufferedWriter
--OutputStreamWriter

1.2流的概念

• 数据的读写抽象成数据，在管道中流动。
• 流只能单方向流动
• 输入流用来读取in
• 输出流用来写出Out

• 数据只能从头到尾顺序的读写一次

  
  

2.File文件流

2.1 概述

封装一个磁盘路径字符串，对这个路径可以执行一次操作。
可以用来封装文件路径、文件夹路径、不存在的路径。

2.2 创建对象

File(String pathname)：通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

2.3 常用方法

文件、文件夹属性
length()：文件的字节量
exists()：是否存在，存在返回true
isFile()：是否为文件，是文件返回true
isDirectory()：是否为文件夹，是文件夹返回true
getName()：获取文件/文件夹名
getParent()：获取父文件夹的路径
getAbsolutePath()：获取文件的完整路径

创建、删除
createNewFile()：新建文件，文件夹不存在会异常，文件已经存在返回false
mkdirs()：新建多层不存在的文件夹\a\b\c
mkdir()：新建单层不存在的文件夹\a
delete()：删除文件，删除空文件夹

文件夹列表
list()：返回String[]，包含文件名
listFiles()：返回File[]，包含文件对象

2.4 练习：测试常用方法

package cn.tedu.bigdecimal;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
//测试文件流
public class Test2_File {
    public static void main(String[] args) throws IOException {
       //1，创建文件对象
       //参数是具体的路径，这个路径可以是文件路径也可以是文件夹路径
       File file = new File("D:\\teach\\1.txt");
       //2，测试常用方法
//     文件、文件夹属性
       System.out.println(file.length());
       System.out.println(file.exists());
       System.out.println(file.isFile());
       System.out.println(file.isDirectory());
       System.out.println(file.getName());
       System.out.println(file.getParent());
       System.out.println(file.getAbsolutePath());
//     创建、删除
       file = new File("D:\\teach\\2.txt");
       System.out.println(file.createNewFile());//创建不存在的文件！！
       file = new File("D:\\teach\\m");
       System.out.println(file.mkdir());//创建不存在的单级文件夹！！
       file = new File("D:\\teach\\o");
       System.out.println(file.mkdirs());//创建不存在的多级文件夹！！
       System.out.println(file.delete());//删除文件或者删除空的文件夹
//     文件夹列表
       file = new File("D:\\teach\\a");
       String[] names = file.list();
       //列出文件夹中的所有文件的  名称
       System.out.println(Arrays.toString(names));
        File[] fs = file.listFiles();
       //列出文件夹中的所有文件的 文件对象
       System.out.println(Arrays.toString(fs));
    }
}

3.字节流读取

字节流是由字节组成的,字符流是由字符组成的. Java里字符由两个字节组成.字节流是最基本的，所有的InputStream和OutputStream的子类都是，主要用在处理二进制数据。
流式传输主要指将整个音频和视频及三维媒体等多媒体文件经过特定的压缩方式解析成一个个压缩包，由视频服务器向用户计算机顺序或实时传送。在采用流式传输方式的系统中，用户不必像采用下载方式那样等到整个文件全部下载完毕，而是只需经过几秒或几十秒的启动延时即可在用户的计算机上利用解压设备对压缩的A/V、3D等多媒体文件解压后进行播放和观看。此时多媒体文件的剩余部分将在后台的服务器内继续下载。

3.1 InputStream抽象类

此抽象类是表示字节输入流的所有类的超类/抽象类。

常用方法：
abstract  int read():从输入流中读取数据的下一个字节。
int read(byte[] b):从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
int read(byte[] b, int off, int len):将输入流中最多 len 个数据字节读入 byte 数组。
void close():关闭此输入流并释放与该流关联的所有系统资源。

3.2 FileInputStream子类

直接插在文件上，直接读取文件数据。

创建对象:
FileInputStream(File file)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(String pathname)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

3.3 BufferedInputStream子类

BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组(默认8M大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。

创建对象:
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

4.字符流读取

常用于处理纯文本数据。

4.1Reader抽象类

用于读取字符流的抽象类。

常用方法:
int read():读取单个字符。
int read(char[] cbuf):将字符读入数组。
abstract  int read(char[] cbuf, int off, int len):将字符读入数组的某一部分。
 int read(CharBuffer target):试图将字符读入指定的字符缓冲区。
abstract  void close():关闭该流并释放与之关联的所有资源。

4.2FileReader子类

用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在FileInputStream上构造一个InputStreamReader。

创建对象:
FileReader(String fileName)
在给定从中读取数据的文件名的情况下创建一个新 FileReader。
FileReader(File file)
在给定从中读取数据的 File 的情况下创建一个新 FileReader。

4.3 InputStreamReader子类

InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

创建对象:
InputStreamReader(InputStream in, String charsetName)
创建使用指定字符集的 InputStreamReader。
InputStreamReader(InputStream in)
创建一个使用默认字符集的 InputStreamReader。

4.4 BufferedReader子类

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

创建对象:
BufferedReader(Reader in)
创建一个使用默认大小输入缓冲区的缓冲字符输入流。

5.测试：文件的读取

5.1字节流读取

package cn.tedu.in;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
//测试文件的读取
public class Test5_In {
    public static void main(String[] args) {
       method();// 字节流读取
       method2();// 高效的字节流读取
    }
    private static void method2() {
       try {
           //BufferedInputStream是高效的读取流：原因在于底层维护了一个byte[]，默认大小是8*1024字节是8K。
           // 1，创建字节流的读取对象
           InputStream in2 = new BufferedInputStream( new FileInputStream("D:\\teach\\1.txt") ) ;
           // 2，开始读取，read()读取到数据的末尾，返回-1
           // 需求：重复的读取每个字节
           int b;// 定义变量，记录读取到的数据
           while ((b = in2.read()) != -1) {// b!=-1，也就是有数据就一直读取
              System.out.println(b);
           }
           // 3，释放资源
           in2.close();
       } catch (IOException e) {
           e.printStackTrace();
       }
    }
    private static void method() {
       try {
           // 1，创建字节流的读取对象
           // InputStream in = new InputStream();//InputStream是字节读取流的父类，但是是抽象类，不能new
           // InputStream in = new FileInputStream(new File("D:\\teach\\1.txt"));
           InputStream in2 = new FileInputStream("D:\\teach\\1.txt");
           // 2，开始读取，read()读取到数据的末尾，返回-1
           // System.out.println( in2.read() );//一个字节一个字节开始读
           // System.out.println( in2.read() );
           // System.out.println( in2.read() );
           // System.out.println( in2.read() );//-1，没数据了
           // System.out.println( in2.read() );//-1，没数据了
           // 需求：重复的读取每个字节
           int b;// 定义变量，记录读取到的数据
           while ((b = in2.read()) != -1) {// b!=-1，也就是有数据就一直读取
              System.out.println(b);
           }
           // 3，释放资源
           in2.close();
       } catch (IOException e) {
           e.printStackTrace();
       }
    }
}

5.2字符流读取

package cn.tedu.in;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
//测试字符流读取
public class Test6_In2 {
    public static void main(String[] args) {
        method();// 字符流的读取
       method2();// 高效的字符流读取
    }
    private static void method2() {
       try {
           //BufferedReader是高效的字符读取流，原因是，底层维护了一个char[]，默认的容量也是8*1024字节就是8K
           // 1、创建对象
           Reader in2 = new BufferedReader( new FileReader("D:\\teach\\1.txt") );
           // 2、开始读取
           int b;// 定义变量，记录读取到的数据
           while ((b = in2.read()) != -1) {// 只要有数据，就一直读
              System.out.println(b);
           }
           // 3、释放资源
           in2.close();
       } catch (IOException e) {
           e.printStackTrace();
       }
    }
    private static void method() {
       try {
           // 1、创建对象
           // Reader in = new Reader();//Reader是字符流读取的父类，但是是一个抽象类，不能new
           // Reader in = new FileReader(new File("D:\\teach\\1.txt"));
           Reader in2 = new FileReader("D:\\teach\\1.txt");
           // 2、开始读取
           // System.out.println(in2.read());//一个字符一个字符读取
           // System.out.println(in2.read());
           // System.out.println(in2.read());
           // System.out.println(in2.read());//-1，没数据了
           // System.out.println(in2.read());//-1，没数据了
           int b;// 定义变量，记录读取到的数据
           while ((b = in2.read()) != -1) {// 只要有数据，就一直读
              System.out.println(b);
           }
           // 3、释放资源
           in2.close();
       } catch (IOException e) {
           e.printStackTrace();
       }
    }
}