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

1、缓冲流为什么会提高IO流读写的效率？
   主要是利用了在内存中开辟的buf空间来实现的，减少了直接消耗系统IO资源的次数，从而提高了性能。

2、我们在读写过程中，什么情况下会发生写入乱码问题？是怎样产生的？我们是如何解决的？

    Java读取文件的方式总体可以分为两类：按字节读取和按字符读取。

    按字节读取就是采用InputStream.read()方法来读取字节，然后保存到一个byte[]数组中，最后经常用new String(byte[]);把字节数组转换成String。在最后一步隐藏了一个编码的细节，new String(byte[]);会使用操作系统默认的字符集来解码字节数组，中文操作系统就是GBK。而我们从输入流里读取的字节很可能就不是GBK编码的，因为从输入流里读取的字节编码取决于被读取的文件自身的编码。举个例子：我们在D:盘新建一个名为demo.txt的文件，写入”我们。”，并保存。此时demo.txt编码是ANSI，中文操作系统下就是GBK。此时我们用输入字节流读取该文件所得到的字节就是使用GBK方式编码的字节。那么我们最终new String(byte[]);时采用平台默认的GBK来编码成String也是没有问题的(字节编码和默认解码一致)。试想一下，如果在保存demo.txt文件时，我们选择UTF-8编码，那么该文件的编码就不在是ANSI了，而变成了UTF-8。仍然采用输入字节流来读取，那么此时读取的字节和上一次就不一样了，这次的字节是UTF-8编码的字节。两次的字节显然不一样，一个很明显的区别就是：GBK每个汉字两个字节，而UTF-8每个汉字三个字节。如何我们最后还使用new String(byte[]);来构造String对象，则会出现乱码，原因很简单，因为构造时采用的默认解码GBK，而我们的字节是UTF-8字节。正确的办法就是使用new String(byte[],”UTF-8”);来构造String对象。此时我们的字节编码和构造使用的解码是一致的，不会出现乱码问题了。

3、序列化流中的serialVersionUID的作用？

    对于jvm来说，要进行持久化的类必须要有个标记，相当于一个通行证，只有持有这个通行证，jvm才让类创建的对象进行持久化。这个通行证就是Serializable接口，这个接口将类与一个称为serialVersionUID的变量关联起来，这个serialVersionUID就是在反序列化中用来确定由哪个类来加载这个对象。

最好在实现serializable接口时，设定serialVersionUID为某个值，不然当在传输的某一端修改实体类时，serialVersionUID会被虚拟机设置成一个新的值。造成两端的serialVersionUID不一致会发生异常。

    需要注意的地方是，serialVersionUID不是决定由哪个类加载硬盘文件中的唯一因素，类的包名、类的名称都有关联。如果不一致，也会出现类型转化错误。原因是类的包名，类名已经被写入了文件当中。

4、请根据自己的语言表述IO流的体系

java.IO层次体系结构

     在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader；一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了

      Java I/O主要包括如下几个层次，包含三个部分：

   1.流式部分――IO的主体部分；

   2.非流式部分――主要包含一些辅助流式部分的类，如：File类；

   3.其他类--文件读取部分的与安全相关的类，如：SerializablePermission类.

   主要的类如下：

     1. File（文件特征与管理）：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。

     2. InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。

     3. OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

     Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。

     4. Reader（文件格式操作）：抽象类，基于字符的输入操作。

     5. Writer（文件格式操作）：抽象类，基于字符的输出操作。

非流式文件类--File类

    在Java语言的java.io包中，由File类提供了描述文件和目录的操作与管理方法。但File类不是InputStream、OutputStream或Reader、Writer的子类，因为它不负责数据的输入输出，而专门用来管理磁盘文件与目录。

作用：File类主要用于命名文件、查询文件属性和处理文件目录。

File类共提供了三个不同的构造函数，以不同的参数形式灵活地接收文件和目录名信息。构造函数：
1）File (String   pathname)   

2）File (String  parent  ,  String child)

3）File (File    parent  , String child)

        一个对应于某磁盘文件或目录的File对象一经创建， 就可以通过调用它的方法来获得文件或目录的属性:   

       1）publicboolean exists( ) 判断文件或目录是否存在
      2）publicboolean isFile( ) 判断是文件还是目录
       3）publicboolean isDirectory( ) 判断是文件还是目录
      4）publicString getName( ) 返回文件名或目录名
      5）publicString getPath( ) 返回文件或目录的路径。
      6）publiclong length( ) 获取文件的长度
       7）publicString[ ] list ( ) 将目录中所有文件名保存在字符串数组中返回。

       File类中还定义了一些对文件或目录进行管理、操作的方法，常用的方法有：
      1） public boolean renameTo(File newFile );   重命名文件
      2） public void delete( );   删除文件
      3）  public boolean mkdir( ); 创建目录

Java.IO流类库

1.io流的四个基本类

      java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer类，它们分别处理字节流和字符流：

    在java.io包中， java.io.InputStream 表示字节输入流， java.io.OutputStream表示字节输出流，处于java.io包最顶层。这两个类均为抽象类，也就是说它们不能被实例化，必须生成子类之后才能实现一定的功能。

2.io的包装类

1.缓冲流（buffer）高效流

2.转换流 InputStringRester与OutputStringWriter；解决编码问题

3.序列化流ObjectInputString与ObjectOutputStream；将对象序列化，反序列化

4.打印流 PrintStream 对输出流的封装

   

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.字符流和字节流的区别?
字符流是以字符为单位读写数据的流
字节流是以字节为单位读写数据的流
字节流和字符流部分方法传输的参数不一致，字符流只能对文本进行IO操作，而字节流可以对更多类型文件进行IO操作
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？resource 语句，在try()的括号中创建流对象语句，如果多个,使用';'隔开 ，它会自动处理创建流对象时产生的异常，但是括号内的异常必须实现AutoCloseable，在try执行结束后关闭流。
JDK7之后 try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close，当是在外部创建流对象依旧会抛出异常。
  JDK7之前使用try.....catch....finally...代码块
  JDK7使用try-with-sourse语句，无需手动close
  JDK9在JDK7的基础上引入对象的方式，无需手动close

1.什么是输入流？什么是输出流？  输入流：内存从硬盘读取数据；
  输出流：内存把数据写到硬盘；
2.输入流读取有几种方式，输出流写出有几种方式？
   字节、字符输入流；
   字节、字符输出流；
3.字符流和字节流的区别?
   字节流可以用于任何对象，而字符流只能处理字符或字符串；
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？

  jdk7前：try.....catch....finally..
  jdk7后：try-with-sourse，自动释放资源
  jdk9：需要在try代码块之上创建流对象

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

2.输入流读取有几种方式，输出流写出有几种方式？
输入流读取有字节输入和字符输入两种；输出流也是有字节输出和字符输出两种。

3.字符流和字节流的区别?
字符流是指操作字符文本的流，底层还是字节流，是为了解决编码问题二产生的。
字节流是以二进制的形式读写文件的，在计算机中所有的文件都是以二进制的形式存储。

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
7之前异常是以 try{}catch{}finally{}的形式，或者用throws声明出去。
8的时候出现了try(){}catch{} try后面的的参数是创建流对象，这样就能直接关闭资源
9的时候在8的基础上可以在参数中直接写对象，但是还是需要用throws将异常声明出去。

----------------吴齐宾-------------------
1.什么是输入流？什么是输出流？
输入流:数据从外部流入内存.输出流:从内存输出到外部;
2.输入流读取有几种方式，输出流写出有几种方式？
输入流读取有两种方式:
1.fileinputstream
2.filereader
输出流写出有两种方式:
1.fileoutputstream
2.filewrieter
3.字符流和字节流的区别?
字符流基本只运用于文本文档的传输,而字节流可以适用于大部分的文件传输
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
1.1.7之前try....catch....finally
2.1.7之后try-with-sourse，自动释放资源
3.1.7之后引入了对像的引用

邹毅涛
1.什么是输入流？什么是输出流？
将外部数据读取到内存中叫输入流。
将内存中的字节写出到外部为输出流。
2.输入流读取有几种方式，输出流写出有几种方式？
输入流读取和输出流写出都有字节输入流和字符输入流两种方式。
3.字符流和字节流的区别?
字符流操作的是字符，字节流则是字节。字符流可以解决编码问题。计算机最小存储单元为字节。
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前用try CatchFinally需要手动释放资源。
JDK7-JDK9改为try with resource try中语句执行完自动释放资源
JDK9之后try中写对象，代码简洁，但仍需抛出异常，执行完也会自动释放资源。

1.什么是输入流？什么是输出流？输入流从硬盘读取到内存中，
输出流从内存写入硬盘。
2.输入流读取有几种方式，输出流写出有几种方式？
字节输出流、write（int i ）、write(btye[] b)、write（byte[] b,int f,int l）
字节输入流：read(int i),read(btye[] b)、read（byte[] b,int f,int l）
字符输出流：write(String string)、write(char[] char)、write（int i），write（String string，int f，int l），write(char[] char,int f,int i)
字符输入流：read(char[] char)、，read（）
3.字符流和字节流的区别?
字符流的底层是字节流，可以对任何文件输入输出，不会使用缓冲区，直接读写到硬盘
字符流可以直接写入字符串，只能对文本输入输出，需要使用缓冲区，间接读写到硬盘
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？

JDK7之前IO流只能定义在try的外面
JDK7IO流可以定义在try（）的括号里面，且可以自动关闭流，不需要调用close方法
JDK7之后，可以将IO流定义在try外面，try的括号内写入IO流的变量名，也不需要手动关闭流

1.什么是输入流？什么是输出流？
输入流：内存从硬盘读取数据；访问数据只读
输出流：内存把数据写到硬盘；保存数据写

2.输入流读取有几种方式，输出流写出有几种方式？
输入流读取方式：int read() 以单字节读取；int read(byte[] b) 以字节数组形式读取。
输出流写出方式：write(byte[] b)以字节数组方式写入；write(int b)以单字节写入；write(byte[] b, int off, int len) 从指定字节数组写入len字节。

3.字符流和字节流的区别?
字节流读取写入是以字节为单位的
字符流读取写入是以字符为单位的

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前使用throws ，try catch finally 处理流中的异常;
jdk7后：try-with-sourse，自动释放资源
  jdk9：需要在try代码块之上创建流对象

1.把设备上读取数据到内存中，2.把内存里的东西写入到设备上
2.输入两种，输出有3种
3.字符流的底层是字节流
4.JDK7之前使用try.....catch....finally...代码块
  JDK7使用try-with-sourse语句，无需手动close
  JDK9在JDK7的基础上引入对象的方式，无需手动close
--李翔

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之前使用try...catch...finally代码块处理异常，在finally代码块中关闭流。
JDK7的时候try-with-resource 语句，在try()的括号中创建流对象语句，如果多个,使用';'隔开 ，它会自动处理创建流对象时产生的异常，但是括号内的异常必须实现AutoCloseable，在try执行结束后关闭流。
JDK7之后 try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close，当是在外部创建流对象依旧会抛出异常。

孙享

1.什么是输入流？什么是输出流？
输入流：将文件信息读取到内存中。常用类有 FileInputStream 与 FileReader ，两者继承了InputStream
输出流：将内存中的信息写出到其他文件或者设备上.常用类有 FileOutputStream 与 Writer ,两者继承了OutputStream
2.输入流读取有几种方式，输出流写出有几种方式？
输入流：字节输入流(FileInputStream )，字符输入流(FileReader)；
输出流：字节输出流(FileOutputStream)，字符输出流(Writer);

3.字符流和字节流的区别?
区别在于，读写使用的单位不同；
字符流的底层原理仍是字节流

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7 之前使用的是 try...catch...finally
JDK7 try-with-resource 语句，在try()的括号中创建流对象语句，如果多个,使用';'隔开
它会自动处理创建流对象时产生的异常，但是括号内的对象必须实现   AutoCloseable，在try执行结束后关闭流。
JDK7之后 try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，
同样可以自动关闭，无需手动close，当是在外部创建流对象依旧会抛出异常。

郭林源

1.什么是输入流？什么是输出流？-->输入流是从其他设备上读取数据到工作内存，输出流是从工作内存写入数据到其他设备中

2.输入流读取有几种方式，输出流写出有几种方式？-->输入流读取方式 1：读取字节数据  2：使用字节数组读取      输出流写出方式  1：write(int b)   2：write(byte[] b)3：write(byte[] b, int off, int len)

3.字符流和字节流的区别?-->字节流在读取复杂文体时，因不同编码问题，可能会造成乱码，这时使用字符流就可以解决问题

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？-->JDK7之前使用try-catch-finally，较繁琐。JDK7优化了try-with-resource，try（）中增加了对象的创建，且try执行完后，自动关闭流，不用再写finally。
JDK9对try-with-resource 又加以改进，引入对象，同样可以自动关闭流

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

从硬盘中获取内容到内存中为输入流
反之，从内存中输出内容存储到硬盘中则为输出流

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

输入流分为字节输入流和字符输入流
输出流分为字节输出流和字符输出流

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

字符流读取写入的是文件的字节形式，可以对任何文件进行操作
而字符流读取写入的是文件的字符形式

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

jdk7之前的处理方式为：try...catch...finnay
jdk7的处理方式为：try...with...sourse
jdk7之后的处理方式为: try(对象)...with...sourse     

1.什么是输入流？什么是输出流？
      输入流：将数据从硬盘读取到内存
      输出流：将数据从内存写出到硬盘

2.输入流读取有几种方式，输出流写出有几种方式？
     输入流读取有两种方式
     1.read（byte b）
     2.read( byte[] bytes)     
字符输出流
1.read(char c)
2.read(char[] c)
     字符输出流写出有五种方式
     1.write(String s  )
     2.write（int b）
     3.write( String s,int index , len )
     4.write( char[] c)
     5.write( char[] c , int index ,len)
字节输出流三种
1.write（byte b）
2.write（ byte[] b ）
3.write（byte[] b,int index , len）

3.字符流和字节流的区别?
字节流 ：以字节为单位，读写数据的流
字符流 ：以字符为单位，读写数据的流

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
jdk7之前：try...catch...finally
jdk7之后：try（在这里面创建的输出输入流对象会自动释放资源）{}catch..
jdk9之后：try（可以放对象多个用分号；隔开，但是要在try之上创建对象，声明异常）

1.什么是输入流？什么是输出流？
   从硬盘中读取数据到内存的数据流叫输入流，从内存中写数据到硬盘中的数据流叫输出流
2.输入流读取有几种方式，输出流写出有几种方式？
   字节输入流有分单个字节输入和byte数组输入，字符输入流有分单个字符输入和以及字符数组、字符串输入。
    字节输出有单个字节输出和byte数组储存然后输出byte数组，字符输出有分单个字符输出以及字符数组存储然后在输出字符数组。
3.字符流和字节流的区别?
   字符流是以字符大小为一个基本单位进行数据的传输，而字节流是按照一个字节进行传输的，字符流的底层也是字节流组成的，字符流专门用来处理文本文件，而字节流则都可以处理，因为在一切文件中一切皆字节组成。
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
   JDK7之前都是用try...catch..finally来处理IO流异常，final里面的方法还要进行异常的处理以及非空判断，在JDK7之后用try...with...resourse来处理IO流异常，就不用在写finally，因为执行完后会自动释放资源，并且可以把创建的IO对象放在try的小括号中，但要求必须是实现AutoCloseable的对象.

1.什么是输入流？什么是输出流？
把数据从其它设备读取到内存中的叫输入流，把数据从内存中读写出到其他设备的叫输出流。
2.输入流读取有几种方式，输出流写出有几种方式？
两种；字节流：read(char[] cbuf)；read方法
字符流：read(char[] cbuf)；read方法
3.字符流和字节流的区别?
字符流是以字符为单位，字节是以字节为单位。
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前：格式是：try()…with…finally
JDK7时：格式是：try()…with…resource必须实现AutoCloseable,自动释放资源。
JDK7之后：try（）…with…resource括号中可以放入多个对象名，用“；”隔开。

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

2.输入流读取有几种方式，输出流写出有几种方式？
答：输入流读取有两种方式，依据其构造方法：1.可以直接把文件路径作为参数作为流对象的参数
                                          2.可以先构造出文件对象，然后把文件对象作为输入流构造函数的参数

   输出流写也出有两种方式，依据其构造方法，同上。

3.字符流和字节流的区别?
答：字节流的应用更为广泛，字符流可以读写文本而不乱码。

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
答：JDK7之前，用try...catch...finally...来处理；
    JDK7，用try...with...resource...来处理；
    JDK7之后，与JDK7相比引入对象的方式支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close。

（黄嘉欣）

1.什么是输入流？什么是输出流？
以内存为基准，把数据从硬盘读入到内存的流叫输入流，把数据从内存写出到硬盘的流叫输出流
2.输入流读取有几种方式，输出流写出有几种方式？
3种，字符输入流read（），read（char【】chars），read（char【】chars，int index，int length）
字节输入流read（），read（byte【】bytes），read（byte【】bytes，int index，int length）
3种 字节输出流  write （）write（byte【】bytes），write（byte【】bytes，int index，int length）
字符输出流write（）；write（char【】chars），write（char【】chars，int index，int length）
3.字符流和字节流的区别?
以字符为单元输入或输出的流叫字符流。以字节为单元输入或输出的流叫字节流
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
jdk7之前用try...catch....finally，jdk七用try（）.....with...resource
jdk7之后用try（；）....with......resource

1.什么是输入流？什么是输出流？- 输入流 ：把数据从其他设备上读取到内存中的流。
- 输出流 ：把数据从内存 中写出到其他设备上的流。
2.输入流读取有几种方式，输出流写出有几种方式？
输入流：
字节输入流【InputStream】 2种
        - public abstract int read()： 从输入流读取数据的下一个字节。
        - public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

字符输入流【Reader】2种
        - public int read()： 从输入流读取一个字符。
        - public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

输出流：
字节输出流【OutputStream】3种
        - public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。  
        - public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。  
        - public abstract void write(int b) ：将指定的字节输出流。
字符输出流【Writer】5种
        - void write(int c) 写入单个字符。
        - void write(char[] cbuf)写入字符数组。
        - abstract  void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
        - void write(String str)写入字符串。
        - void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。

3.字符流和字节流的区别?
         字符流是以字符为单位读写数据的流
         字节流是以字节为单位读写数据的流
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？

JDK7之前  要繁复地try catch finnaly  进行处理IO异常 才能确保资源的释放
JDK7优化后的try-with-resource 语句，该语句确保了每个资源在语句结束时关闭。所谓的资源（resource）是指在程序完成后，必须关闭的对象。
JDK9优化后  对try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。