今天我们学习了字符流和字节流，请根据自己的理解回答下面问题：
1.什么是输入流？什么是输出流？
2.输入流读取有几种方式，输出流写出有几种方式？
3.字符流和字节流的区别?
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？

1.什么是输入流？什么是输出流？
答：输入流，输出流是IO流中根据流向的分类，这个流向是相对内存而言的，输入流是数据从硬盘流向内存，输出流是数据从内存流向硬盘。

2.输入流读取有几种方式，输出流写出有几种方式？
答：输入流分为两种，字节输入流和字符输入流，输出流也分为两种，字节输出流和字符输出流。
其中字节输入流的读取方式有3种，分别为读取单个字节，一次性读取多个字节并放入数组中，还有读取设定数量的字节放入数组中；
字符输入流读取的方式有4种，分别为读取单个字符，读取一个字符数组，读取部分字符数组，将字符读取入字符缓冲区；
字节输出流写出的方式有3种，分别为写出单独一个字节，一次写出一个byte数组的字节，一次写出byte数组中的部分；
字符输出流写出的方式有5种，分别为写出单独一个字符，一次写出一个字符数组的字符，一次写出一个字符数组的部分，一次写出一个字符串，一次写出一个字符串的部分；

3.字符流和字节流的区别?
答：字节流是使用字节为单位进行文件读写的流，对中文的识别能力较差，不擅长操作文本
字符流是使用字符为单位进行文件读写的流，对中文有很好的识别能力，可用于操作文本

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
答：在JDK7之前，对于IO流的异常处理有2种方式：第一种是throws把异常抛出，但是当程序出现异常的时候，流通道没有关闭，这很浪费资源。
第二种方式是：使用try...catch...finally方法，把流对象的创建和读写操作，流通道的关闭都包括起来，但是流通道的关闭需要设定一个先设定一个流对象，赋值null。
把流通道关闭的代码放到finally处，就需要对close重新try..catch,还要判断流对象不为null的时候才能执行。

在JDK7之后有2个不同的方式处理异常：
一个是JDK7版本，把流对象的声明直接放到try后的（）中，流对象编程局部变量，这样子就无需再使用finally来关闭流通道了。
另一个是JDK9版本，把流对象的声明放到try前面的一个（）中，在try后面的（）中写入流对象的变量名，这样子也是限定了流对象的作用域，但是流对象的创建还需要throws抛出异常。

1.什么是输入流？什么是输出流？
输入流：指数据从硬盘传输到内存；
输出流：指数据从内存写入到硬盘。

2.输入流读取有几种方式，输出流写出有几种方式？
字节输入流：
a.一次读取一个字节；
b.一次读取一个字节数组；
字节输出流：
a.一次写入一个字节；
b.一次写入一个字节数组；
c.一次写入一个字节数组的一部分。

字符输入流：
a.一次读取一个字符；
b.一次读取一个字符数组；
字符输出流：
a.一次写入一个字符；
b.一次写入一个字符数组；
c.一次写入一个字符数组的一部分；
d.一次写入一个字符串；
e.一次写入一个字符串的一部分。

3.字符流和字节流的区别?
a.字节流执行写入语句时直接写入到硬盘中，而字符流则是先写入到缓存，当调用flush方法或者close方法时才将缓存中的数据写入硬盘；
b.字节流不能读写中文字符，而字符流可以。

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前，一般用try...catch...finally处理；
JDK7,可以将流定义在try后面的小括号内，try-catch语句结束后会自动关闭流；
JDK9,可以将流定义在try外部，然后将对应的变量写入try后面的小括号内，try-catch语句结束后会自动关闭流。

1.什么是输入流？什么是输出流？
答：输入输出 是相对于内存来说的。输入时是指数据从硬盘读取到内存中，输出是指数据从内存中写入到硬盘中。

2.输入流读取有几种方式，输出流写出有几种方式？
答：读取数据和写出数据
字节输入流Inputstream读取的方式有两种read();和read（byte[] b）;
字节输出流OutputStream写出的方式有三种writer（int b）、writer（byte[] b）写入数组、writer（byte[],int off,int len）写入指定长度的数组。
字符输入流 Reader读取的方式有两种 read();和read（char[] cbuf）;
字符输出流 Writer写出的方式有五种  witer（int c）；witer（char[] c）、witer（char[], int off,int len）、writer（String str）、writer（String str，int off，int len）

3.字符流和字节流的区别?
答：在操作流的时候，无论是什么样的流对象，其底层传输的始终为二进制数。
他们二者的最大的区别是：
字节流读写数据的最小单位是字节（不适合中文的读写），而字符流的最小读写单位为字符
第二个区别是：字符输出流内置缓冲区的原因，需要通过flush或者close关流，否则无法写出字符到文件中。

字符流优势是文本的读写  字节流的优势是文件的读写。

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
答:JDK7之前是try catch finally（关流放在finally里面）JDK7的时候把流对象放在try代码块中。JDK7之后，只是把流对象名写在try（）内，而且要throws异常。

1.什么是输入流？什么是输出流？
IO流按照流动的方向，以内存为基准，分为输入流和输出流
输入流：把数据从硬盘中读取到内存中的流
输出流：把数据从内存中写出到硬盘中的流

2.输入流读取有几种方式，输出流写出有几种方式？
（1）输入流分为字节输入流和字符输入流；输出流分为字节输出流和字符输出流
（2）输入流中的字节输入流的读取方式有2种：(1)int read() ：一次读一个字节,(2)int read(byte[] b)一次读一个字节数组;字符输入流：字符输入流的读取方式有2种，(1)int read() 一次读一个字符，(2)int read(byte[] b)一次读一个字符数组。
（3）输出流中的字节输出流的读取方式有3种：(1)void write(int b) 一次写一个字节(2)write(byte[] b)一次写一个数组(3) void write(byte[] b, int off, int len)一次写一个数组的一部分；字符输出流读取方式有5种：(1)void write(int c) 一次写一个字符，(2)void write(char[] cbuf)一次写一个字符数组,(3)void write(char[] cbuf, int off, int len)一次写一个字符数组的一部分,(4)write(String str)一次写一个字符串,(5)write(String str, int off, int len)一次写一个字符串的一部分

3.字符流和字节流的区别?

(1)字节流在读取一段文本输入的时候将一个字符拆成对应字节数，任何再进行一个个字节的传输，而我们在读取的时候会根据ASCII编码表找单个字节的十进制对应的字符，就会造成没有对应上，造成乱码。而字符流是将一个字符拆成对应字节数进行打包后，然后再进行字节传输，而我们在读取的时候会根据打包的字节数对应编码表找打包的字节数的十进制对应的字符不会造成乱码

(2)字符流进行写文件的时候要进行刷新缓冲区，不然缓冲区中的数据会存在缓冲区，而不会写入文件中，而字节流不用。

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前有两种方式对IO流的异常处理
(1)使用throws将异常抛出，但是如果有异常会直接停止程序，而没有关闭流，会造成内存资源的浪费。
(2)使用try...catch处理异常要在finally位置关闭流，因为作用域问题需要在tay...catch的外部对流对象进行赋值，但我们在进行关流的时候要对流对象进行判断是否为null，如果为null就不能调用close，否则会抛出空指针异常,代码很复杂。
JDK7把创建流对象直接放到try后的（）中，且JDK7在try...catch中提供了关流的操作，无需再使用finally来关闭流通道了。
JDK9之后流对象在try...catch外面创建，把流对象的对象名写在try后的（）中，JDK9也在try...catch中提供了关流的操作，无需再使用finally来关闭流通道了，但JDK9由于创建流对象写在try...catch外面所以需要将文件找不到异常继续进行处理thows出。

1.什么是输入流？什么是输出流？
答：输入流 ：把数据从其他设备上读取到内存中的流。
输出流 ：把数据从内存中写出到其他设备上的流。

2.输入流读取有几种方式，输出流写出有几种方式？
答：输入流 ：字节输入流有2种方式，字符输入流有2种方式。
输出流 ：字节输出流有3种方式，字符输出流有5种方式。


3.字符流和字节流的区别?
答：字节流只能获取一个一个字节，当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为
一个中文字符可能占用多个字节存储。 而字符流可以获取一串字符，且可以自己定义获取的长度（2048的倍数）。
字符流需要刷新，字节流不需要。

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？

答：JDK7之前的try...catch...finally代码块使用复杂繁琐。
JDK7优化后的try-with-resource语句确保了每个资源在语句结束时关闭。  
JDK9中try-with-resource的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close。

1.什么是输入流？什么是输出流？输入流指的是将数据从硬盘中传输到内存中，输入流又分为字节输入流(不能传输中文)和字符输入流（可以传输中文）
输出流指的是将数据从内存中传输到硬盘中，输出流又分为字节输出流（不能传输中文）和字符输出流（可以传输中文）
2.输入流读取有几种方式，输出流写出有几种方式？
字节输入流读取有两种方式、字节输出流写出有三种方式
字符输入流读取有两种方式，字符输出流写出有五种方式
3.字符流和字节流的区别?
最根本的区别就是字节流不能用来传输中文
字符流需要使用flush方法把内存缓冲区的数据，刷新到文件中
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？

使用IO流的时候会发生异常，使用throws进行抛出的话，就会停止程序，流不会关闭，浪费资源
只能用try...catch处理异常，但是在JDK1.7之前使用try...catch处理异常非常繁琐，
JDK7的时候可以直接将创建的流对象放入try（）后面的括号中，将需要执行的代码放到try后面的{}中，catch同样用来声明异常。
JDK9又进行了一项更新，在try之前创建流对象并将流对象名放进try后面的（）中，将需要执行的代码放到try后面的{}中，catch同样用来声明异常，但是还是要对try之前创建的对象进行声明。

简洁扼要的来几句

输入  到内存叫输入
输出 到硬盘叫输出

输入流读取 read方法那几个吧 read(int b) read(byte[ ]b)
输出流写出 顾名思义就是write方法啊  write(int a)  write(char [ ]c)

字符流和字节流区别  字符流就是可以读取中文，字节流不可以，也不是不可以 会产生不完整的中文 中文有多个字节组成  
重点  JDK7  try(流对象  ){  可能异常的代码 }catch( 异常类型 ){ 打印异常 除了异常逻辑   } finally{  死都要执行的代码 比如close 释放流   }

1.什么是输入流？什么是输出流？
答：输入流：数据从硬盘流向内存；输出流：数据从内存流向硬盘
2.输入流读取有几种方式，输出流写出有几种方式？
答：在字节里输入流有3种；分别为public void close()，public abstract int read() ，public int read(byte[] b) 。输出流里有3种；分别为public void write(byte[] b) ，public void write(byte[] b, int off, int len) ，public abstract void write(int b)。
在字符种输入流有3种；分别为public void close()，public int read() ，public int read(char[] cbuf) 。输出流有5种；分别为void write(int c)，void write(char[] cbuf) ，abstract  void write(char[] cbuf, int off, int len) ，void write(String str) ，void write(String str, int off, int len) 。
3.字符流和字节流的区别?
字符流：使用字符作为单位进行文件读写，用于操作文本的。
字节流：使用字节为单位进行文件读写，用于操作文件。
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
jdk7之前：try...catch...finally代码块使用复杂繁琐。
jdk7：优化后的 try-with-resource 语句，该语句确保了每个资源在语句结束时关闭。
JDK9： try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭， 无需手动close

1.什么是输入流？什么是输出流？
        对内存来说
        按流向分 : () 输入流/输出流
                输入流
                        数据从硬盘流向内存
                输出流
                        数据从内存流向硬盘
                       
        按格局分 :
        计算机中储存的一切数据        都是二进制形式的
        01010101
                8 个 bit 为一个 字节
        字节流
                使用字节为单位进行文件读写
                问题是
        不擅长操作文本
        字符流
                使用字符作为单位进行文件读写        用于操作文本的
               
2.输入流读取有几种方式，输出流写出有几种方式？

     输入流 ：字节输入流有3种方式，字符输入流有5种方式。
     输出流 ：字节输出流有3种方式，字符输出流有3种方式。
3.字符流和字节流的区别?
        字符流可以操作中文
        字节流不以操作中文
        字节流只能获取一个一个字节，当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为
        一个中文字符可能占用多个字节存储。 而字符流可以获取一串字符，且可以自己定义获取的长度（2048的倍数）。
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
        JDK7的新特性
        在try的后边可以增加一个(),在括号中可以定义流对象
        那么这个流对象的作用域就在try中有效
        try中的代码执行完毕,会自动把流对象释放,不用写finally
       
        JDK9新特性
        try的前边可以定义流对象
        在try后边的()中可以直接引入流对象的名称(变量名)
        在try代码执行完毕之后,流对象也可以释放掉,不用写finally
       

1.什么是输入流？什么是输出流？输入流：数据从硬盘流向内存。
输出流：数据从内存流向硬盘。

2.输入流读取有几种方式，输出流写出有几种方式？
输入流读取有字节输入流和字符输入流。
字节输入流的读取有2种： read()、 read(byte[] b)
字符输入流的读取有2种：read() 读取单个字符并返回。int read(char[] cbuf)一次读取多个字符,将字符读入数组。
输出流写出有字节输出流和字符输出流。
字节输出流的写出有3种： write(byte[] b) 、 write(byte[] b, int off, int len)、write(int b)。
字符输出流的写出有5种：write(int c) 、write(char[] cbuf)、write(char[] cbuf, int off, int len)、write(String str)、write(String str, int off, int len) 。

3.字符流和字节流的区别?
Java中的字节流处理的最基本单位为单个字节，它通常用来处理二进制数据。
Java中的字符流处理的最基本的单元是Unicode码元，1字符=2字节。它通常用来处理文本数据。

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前使用try...catch...finally 代码块，处理异常部分  。

JDK7优化后的 try-with-resource 语句，该语句确保了每个资源在语句结束时关闭。所谓的资源（resource）是指在程序完成后，必须关闭的对象。

JDK9中 try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close。

1.什么是输入流？什么是输出流？
相对内存而言的，输入流是数据从硬盘流向内存，输出流是数据从内存流向硬盘
2.输入流读取有几种方式，输出流写出有几种方式？
输入流 ：字节输入流有3种方式，字符输入流有5种方式。
输出流 ：字节输出流有3种方式，字符输出流有3种方式。
3.字符流和字节流的区别?
字节流是使用字节为单位进行文件读写的流，对中文的识别能力较差，不擅长操作文本
字符流是使用字符为单位进行文件读写的流，对中文有很好的识别能力，可用于操作文本
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前需要使用finally关闭流，代码繁琐
JDK7可以将输入流与输入流的创建写在tru后的括号里
JDK9可以将输入流与输入流创建的对象名称用“；”写在try后的括号中

1.什么是输入流？什么是输出流？

输入流就是内存容磁盘获取数据信息的过程，输出流就是内存往磁盘植入数据信息的过程。

2.输入流读取有几种方式，输出流写出有几种方式？

字节输入流读取有2种方式：一次读一个字节和一次读一个字节数组，输出流写出有3种方式。字符输入流读取有2种方式：一次读一个字符和一次读一个字符数组，输出流写出有5种方式。

3.字符流和字节流的区别?

字符流可以读取的中文不会出现乱码现象，字节流读取的中文有可能会出现乱码现象。

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？

JDK7和JDK7之后出现了try后面跟了一个（）小括号，小括号里面用来放我们的流对象，程序运行结束后会自动关掉流，省去了finaly方法来手动关闭流对象。

1.什么是输入流？什么是输出流？

输入流就是内存容磁盘获取数据信息的过程，输出流就是内存往磁盘植入数据信息的过程。

2.输入流读取有几种方式，输出流写出有几种方式？

字节输入流读取有2种方式：一次读一个字节和一次读一个字节数组，输出流写出有3种方式。字符输入流读取有2种方式：一次读一个字符和一次读一个字符数组，输出流写出有5种方式。

3.字符流和字节流的区别?

字符流可以读取的中文不会出现乱码现象，字节流读取的中文有可能会出现乱码现象。

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？

JDK7和JDK7之后出现了try后面跟了一个（）小括号，小括号里面用来放我们的流对象，程序运行结束后会自动关掉流，省去了finaly方法来手动关闭流对象。
--------------------------------------------------黄成成

今天我们学习了字符流和字节流，请根据自己的理解回答下面问题：
1.什么是输入流？什么是输出流？
输入流 ：把数据从 其他设备 上读取到 内存 中的流。
输出流 ：把数据从 内存 中写出到 其他设备 上的流。

2.输入流读取有几种方式，输出流写出有几种方式？
字节输入流:
1. 读取字节： read 方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回 -1
2. 使用字节数组读取： read(byte[] b) ，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读
取到末尾时，返回 -1
字符输入流:
1. 读取字符： read 方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回 -1
2. 使用字符数组读取： read(char[] cbuf) ，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，
读取到末尾时，返回 -1 ;
字节输出流:
1. 写出字节： write(int b) 方法，每次可以写出一个字节数据
2. 写出字节数组： write(byte[] b) ，每次可以写出数组中的数据
3. 写出指定长度字节数组： write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节
字符输出流:
写出基本字符： write(int b) 方法，每次可以写出一个字符数据
写出字符数组 ： write(char[] cbuf) 和  write(char[] cbuf, int off, int len) ，每次可以写出字符数
组中的数据，用法类似FileOutputStream
写出字符串： write(String str) 和  write(String str, int off, int len) ，每次可以写出字符串中的
数据，更为方便

3.字符流和字节流的区别?
字节流可以传输任意文件数据,无论使用什么样的流对象，底层传输的始终为二进制数据,都可以用字节流来操作,而当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前:
try{   创建对象;
可能会出现异常的代码   }
catch(异常类型   异常名){  异常的处理逻辑   
}finilly{ try {
                if (对象名  != null) {
                释放资源   }
            } catch(异常类型   异常名){  异常的处理逻辑   }
JDK7:确保了每个资源在语句结束时关闭
try (创建流对象语句，如果多个,使用';'隔开) {
// 读写数据    
} catch (IOException e) {
e.printStackTrace();    }
JDK之后:对于引入对象的方式，支持的更加简洁,无需手动close
// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");
// 引入方式：直接引入
try (resource1; resource2) {
     // 使用对象
}

1.什么是输入流？什么是输出流？
输入流：把数据从硬盘里读取到内存中；
输出流：把数据从内存中写入到硬盘中。

2.输入流读取有几种方式，输出流写出有几种方式？
字节输入流读取有2种方式。   read（），read（byte[] bytes）。
   字节输出流写出有3种方式。write（int b）;write（byte[] bytes）;write(byte[] bytes ,  int off ,  int len)。
  字符输入流读取有2种方式        read（），read（char[] chars）
  字符输出流写出有5种方式   write（int b）;write（char[] chars）;write(char[] chars ,  int off ,  int len);  write(String str) ;  write(String str, int off ,  int len )

3.字符流和字节流的区别?
字符流以字符为单位；字节流以字节为单位

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
DK7之前使用try.....catch....finally...代码块
  JDK7使用try-with-sourse语句，无需手动close

1.输入流：把数据从其他设备上读取到内存中；输出流：把数据从内存写入到其他设备。
2.输入流 ：字节输入流有3种方式，字符输入流有5种方式；输出流 ：字节输出流有3种方式，字符输出流有3种方式。
3.  字节流不能读写中文，字符流可以。
4.添加了新特性，简化了代码书写，不需要写finally语句也能保证流的关闭。

1.什么是输入流？什么是输出流？ 以内存为基准,数据的传输也可以看成是数据的流动往内存方向流入的就是输入流，输入流也称为读取数据；反之从内存流出的数据流称为输出流，输出流也称为写出数据。 2.输入流读取有几种方式，输出流写出有几种方式？ 输入流读取有两种方式，如果是字节输入流的话，一种是一次读一个字节，另外一种是一次读一个字节数组；如果是字符输入流的话，一种是一次读一个字符，另外一种是一次读一个字符数组；输出流有中的字节输出流写出有三种方式：1、一次写出一个字节 2、一次写一个字节数组 3、一次写一个字节数组中的一部分；如果是输出流中的字符输出流的话也有三种方式：1、一次写出一个字符 2、一次写一个字符数组 3、一次写一个字符数组中的一部分。 3.字符流和字节流的区别? 1、字节流是以字节为单位读取数据，在处理文本的时候如果遇到中文的话会出现乱码问题，字符流是以字符为单位读取数据，在处理文本文件的时候比字节流更适合更好用。 2、字节流在操作数据的时候是文件本身直接操作的，而字符流在操作文本数据的时候需要进入缓冲区之后才能进行后续操作。底层还是字节流，只不过是在运用的时候对其做了封装更好的为处理文本服务。 4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？ 在JDK7之前，都需要用finally代码块去配合try。。catch，在finally代码块中使用close方法将资源释放。在JDK7这个版本对这方面进行了优化，可以使用try（）{ }catch（）{} ;在try后面加了个小括号，里面可以直接写创建流对象的语句，如果要创建多个流对象，创建语句之间加个；即可。后面不需要加finally代码块，也能实现之后的资源释放。JDK7之后的JDK9也对这方面进行了改进，可以直接创建流对象；将对象名放入try后面的那个小括号中即可，运行完之后也能实现资源的释放回收。但是因为创建流对象语句是在处理异常语句之外，这些语句需要声明异常方可通过编译，我个人来看还是觉得JDK7的优化版本更好用些。

1.什么是输入流？什么是输出流？
输入流：把硬盘中的数据，读取到内存中使用
输出流：把内存中的数据，写到硬盘中保存
2.输入流读取有几种方式，输出流写出有几种方式？
字节输入流有两种，输出流有三种
字节输入流有两种，输出流有五种
3.字符流和字节流的区别?
字节流以字节为单位，默认不使用缓冲区，不适合输入中文
字符流以码表为单位适合输入中文。
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
jdk7之前用cry catch finally
jdk7try后边可以加一个（）定义流对象，并且只在try中有效，运行完自动释放
jdk9try前可以定义流对象括号内引入变量名，执行完毕直接释放不用写finally

1.什么是输入流？什么是输出流？
从硬盘读取到内存的为输入流，从内存写到硬盘的为输出流；

2.输入流读取有几种方式，输出流写出有几种方式？
字节输入流（一次读一个字节和一次读一个字节数组）和字符输入流（一次读一个字符和一次读一个字符数组）；
字节输出流（一次写一个字节，一次写一个字节数组，一次一个自己字节数组的一部分）和字符输出流（一次写一个字符，一次写一个字符数组，一次写一个字符数组的一部分，一次写一个字符串，一次写一个字符串的一部分）；

3.字符流和字节流的区别?
字节流操作文件，字符流操作文本；

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前：用try...catch...finally处理；
JDK7：把将流定义在try后面的小括号内，try-catch语句结束后会自动关闭流；
JDK9: 把流定义在try外部，然后将对应的变量写入try后面的小括号内，try-catch语句结束后会自动关闭流。
     A a = new A();
     B b = new B();
        try(a,b){
            可能会产出异常的代码
        }catch(异常类变量 变量名){
            异常的处理逻辑
        }