今天我们学习了字符流和字节流，请根据自己的理解回答下面问题：
1.什么是输入流？什么是输出流？
按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。

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

3.字符流和字节流的区别?
字节流读取写入是以字节为单位的
字符流读取写入是以字符为单位的，可以操作中文和其他非ASCII字符。

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前使用try catch finally 处理流中的异常;
JDK7优化后的try后面多了一个（），里面可以创建流对象语句，try中的代码执行完毕,会自动把流对象释放,不用写finally。
JDK7之后可以直接把流对象名称写在小括号内，在try之前定义流对象，并抛出流对象的异常。

1.        什么是输入流？什么是输出流？
输入流：将硬盘中的数据读取到内存中
输出流：将内存中的数据写入硬盘中
2.输入流读取有几种方式，输出流写出有几种方式？
字节输入流 read()  read(byte[] b)
字符输入流read()   read(char[] c)
字节输出流write(int b)   write(byte[] b)   write(byte[] b, int off, int len)
字符输出流write(int b)   write(char[] c)   write(char[] c, int off, int len)
write(String str)  write(String str, int off, int len)
3.字符流和字节流的区别?
字符流是以字符为单位的输入输出流
字节流是以字节为单位的输入输出流
4.JDK7之前，JDK7和JDK9之后对IO流异常的处理有什么变化？
JDK7之前使用try...catch...finally代码块处理异常
JDK7 使用try-with-resource 语句，会自动释放资源
JDK9之后引入对象的方式，支持更加简洁的引入对象，会自动释放资源

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

2.输入流读取有几种方式，输出流写出有几种方式？
输入流有三种
一、int read() 从输入流读取一个字节，并把他转为0-255之间的整数，并返回
二、int read(byte[] b) 从输入流读取若干字节，并保存到b指定的数组中，返回值是读取的有效的字节数的个数，如果读取的内容为空，返回-1
三、int read(byte[] b,int off,int len) 从输入流读取若干字节，并保存到b指定的数组中，off指定字节数组的下标，len表示读取的字节数，返回值是读取的有效的字节数的个数，如果读取的内容为空，返回-1
字符输入流读取的内容单位为字符，方法类似
输出流有三种
一、void write(int b) 把一个字节写出到输出流
二、void write(byte[] b) 把指定的字节数组的所有字节写出到输出流
三、void write(byte[] b,int off,int len) 把指定的字节数组的从偏移量off开始的leng 个字节写出到输出流
字符输出流写出的内容单位为字符，方法类似，还有特有的void write(String str) 写入字符串的方法和void write(String str, int off, int len) void write(char[] cbuf,int off,int len) 把指定的字符串的从偏移量off开始的leng 个字节写出到输出流的方法

3.字符流和字节流的区别?
字节流的输入和输出是以一个字节内容单位，字符流的输入和输出是以一个字符为单位
字符流写入的参数可以直接为一个字符串，字节流不行
字符流只能应用于文本类文件，字节流可以应用所有文件

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

JDK之前通过try/catch/finally的方法进行处理异常
JDK7通过在try后边增加()，在括号中定义流对象（定义多个用分号隔开）。这个流对象作用域在try中有效，try代码执行完，自动释放流对象，不用finally，来处理异常
JDK7之后通过try()后边的()可以直接引入之前创建的流对象的名称，在try代码执行完后，流对象自动释放，来处理异常

杨式贤

1.什么是输入流？什么是输出流？
输入流：把数据从其他设备上读取到内存的流；
输出流：把数据从内存写到其它设备的流；
2.输入流读取有几种方式，输出流写出有几种方式？
输入流读取有两种，一种通过字节流，一种通过字符流；
输出流写出有两种，一种通过字节流，一种通过字符流；
3.字符流和字节流的区别?
字节流可以传输任意的文件类型，一切皆字节，字符流的底层其实也是字节流；
字符流只能处理文本格式文件，解决字节流在不同版本编译字符异常的问题
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前使用try...catch...finally...处理异常；
JDK7使用try-with-resource,即try（资源对象），确保每个资源运行完后都会被关闭；
JDK9引入了对象try（o1,o2）...catch...,对象运行完后也会自动关闭

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.字符流和字节流的区别?
   字符流是以字符为单位读写数据的流
   字节流是以字节为单位读写数据的流
（1）字节流的操作单位为一个字节；字符流是字节流的包装，底层也是字节流。
（2）字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前使用try...catch...finally代码块处理异常，在finally代码块中关闭流。
JDK7的时候try-with-resource 语句，在try()的括号中创建流对象语句，如果多个,使用';'隔开 ，它会自动处理创建流对象时产生的异常，但是括号内的异常必须实现AutoCloseable，在try执行结束后关闭流。
JDK7之后 try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close，当是在外部创建流对象依旧会抛出异常。

1.什么是输入流？什么是输出流？
输入：从外界输入到内存。
输出：从内存储存到外界硬盘等等之类的
2.输入流读取有几种方式，输出流写出有几种方式？
有两种：字节输入，输出流，字符输入，输出流

3.字符流和字节流的区别?
一个是以字符进行操作。也就是char类型的。
一个是以字节进行操作。也就是一连串的数字。有对应的意思。
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
jdk7前：try.....catch....finally..
  jdk7后：try-with-sourse，自动释放资源
  jdk9：需要在try代码块之上创建流对象

1.什么是输入流？什么是输出流？
把数据从其他设备上读取到内存中
把数据从内存中写出到其他设备上
2.输入流读取有几种方式，输出流写出有几种方式？
         2种方式                              5种方式
3.字符流和字节流的区别?
读写单位不同字节流是字节字符流是字符
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前使用try.....catch....finally...代码块
JDK7使用try-with-sourse语句，无需手动close
JDK9在JDK7的基础上引入对象的方式，无需手动close

1.什么是输入流？什么是输出流？
流入内存叫输入，流出内存叫输出
2.输入流读取有几种方式，输出流写出有几种方式？：
字节、字符输入流；
字节、字符输出流
3.字符流和字节流的区别?
字节流只能读写字节或字节数组，字符流可以读写字符串。以字符为单位，可以读写汉字。
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前:try.....catch....finally..
Jdk1.7 增加Try-with-resource语句多了（），会自动释放资源，关闭对象，不需要finally，lose方法
jdk1.7之后： 引入了对象方式，同样可以释放资源，不需要close方法

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 的改进，对于引入对象的方式，支持的更加简洁。

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

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

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

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

（黄嘉欣）

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.输入流读取有几种方式，输出流写出有几种方式？
   字节输入流有分单个字节输入和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.输入流读取有几种方式，输出流写出有几种方式？
     输入流读取有两种方式
     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.输入流读取有几种方式，输出流写出有几种方式？

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

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

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

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

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

郭林源

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.什么是输入流？什么是输出流？
输入流：将文件信息读取到内存中。常用类有 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.字节输入流读取有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.把设备上读取数据到内存中，2.把内存里的东西写入到设备上
2.输入两种，输出有3种
3.字符流的底层是字节流
4.JDK7之前使用try.....catch....finally...代码块
  JDK7使用try-with-sourse语句，无需手动close
  JDK9在JDK7的基础上引入对象的方式，无需手动close
--李翔

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代码块之上创建流对象