黑马程序员技术交流社区

标题: 【厦门JavaEE就业5期-每日总结】字节流、字符流 [打印本页]

作者: 厦门校区 时间: 2018-12-30 17:56
标题: 【厦门JavaEE就业5期-每日总结】字节流、字符流
今天我们学习了字符流和字节流，请根据自己的理解回答下面问题：
1.什么是输入流？什么是输出流？
2.输入流读取有几种方式，输出流写出有几种方式？
3.字符流和字节流的区别?
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？

作者: 赖熙蒙 时间: 2018-12-30 19:29
本帖最后由赖熙蒙于 2018-12-30 20:34 编辑

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。

作者: Chidori 时间: 2018-12-30 19:35
本帖最后由 Chidori 于 2018-12-30 20:30 编辑

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之前创建的对象进行声明。

作者: 陈辉阳 时间: 2018-12-30 19:35
简洁扼要的来几句

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

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

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

作者: 杨馥榕 时间: 2018-12-30 19:56
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

作者: 李灵杰 时间: 2018-12-30 20:03
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

作者: 许晓明 时间: 2018-12-30 20:08
本帖最后由许晓明于 2018-12-30 20:31 编辑

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抛出异常。

作者: 骆颖权 时间: 2018-12-30 20:11
标题: RE: 【厦门JavaEE就业5期-每日总结】字节流、字符流
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。

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

作者: Java中的莫Q哇啦 时间: 2018-12-30 20:35
1.什么是输入流？什么是输出流？

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

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

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

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

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

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

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

作者: Java中的莫Q哇啦 时间: 2018-12-30 20:36
1.什么是输入流？什么是输出流？

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

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

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

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

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

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

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

作者: lj478360767 时间: 2018-12-30 20:36
今天我们学习了字符流和字节流，请根据自己的理解回答下面问题：
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) {
     // 使用对象
}

作者: 吴洪标 时间: 2018-12-30 20:43
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语句结束后会自动关闭流。

作者: 苏志祥 时间: 2018-12-30 21:35
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

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

作者: 董志超Eric 时间: 2018-12-30 21:46
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异常。

作者: 陈基林 时间: 2018-12-30 23:56

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的优化版本更好用些。

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

作者: 苏阿合 时间: 2018-12-31 00:04
本帖最后由苏阿合于 2018-12-31 00:51 编辑

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出。

作者: 林文悦 时间: 2018-12-31 17:03
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(异常类变量变量名){
         异常的处理逻辑
      }

作者: 陈益源 时间: 2018-12-31 23:27
1.什么是输入流？什么是输出流？
输入流就是数据从硬盘或其他设备读取到硬盘中
输出流就是数据从内存中写入到硬盘或其他设备中

2.输入流读取有几种方式，输出流写出有几种方式？
（1）输入流分为字节输入流和字符输入流
字节输入流：read()  一次读取一个字节，返回的是字节的十进制表示形式；
int read(byte[] b)  一次读取一个字节数组，返回的是读取到的有效字节个数。
字符输入流：read() 一次读取一个字符，返回的是字节的十进制表示形式；
read(char[] cbuf)  一次读取一个字符数组，返回的是读取到的有效字节个数。
（2）输出流分为字节输出流和字符输出流
字节输出流：write(int b) 一次写入一个字节
write(byte[] b) 一次写入一个字节数组
write(byte[] b, int off, int len)    一次写入一个字节数组的一部分
字符输出流：write(int c) 一次写入一个字符
write(char[] cbuf) 一次写入一个字符数组
write(char[] cbuf, int off, int len) 一次写入一个字符数组的一部分
write(String str) 一次写入一个字符串
write(String str, int off, int len) 一次写入一个字符串的一部分

3.字符流和字节流的区别?
字符流适用于文本，需要使用flush()把内存缓冲区中的数据,刷新到文件中
字节流适用于文件，可以直接写入到文件中

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前对IO流异常的处理在使用try...catch时，需要在catch后面补上finally在里面关闭流，如有异常finally也一定会执行，保证流可以正常关闭；但在finally里面关闭流，就需要提高流对象的作用域，使用时必须有值，所以定义的同时要赋值null；null不可以调用方法，需要在finally里增加一个判断；
JDK7：try(创建流对象，可以是多个){
可能发生异常的代码
      }catch(异常类型  变量名){
针对异常的处理逻辑
      }；try中的代码执行完后会自动关闭流，不需要再写finally
JDK7之后：先定义流对象，需要声明抛出异常
                  try(流对象变量名,流对象变量名){
            可能会产出异常的代码
                  }catch(异常类型变量名){
            异常的处理逻辑
              }

作者: 刘荣城 时间: 2019-1-1 11:58
1.什么是输入流？什么是输出流？
输入流就是把数据从设备上读取盗到内存中的数据。
输出流就是把数据才内存中输出到设备上的数据。
2.输入流读取有几种方式，输出流写出有几种方式？
输入流有两种方式，字节输出流有3种方法：一次一个字节，一次一个数组和一次一个数组的一部分
字符输出流有5种方法：一次一个字符，一次一个字符数组，一次一个字符数组的一部分，也可以一次一个字符，和一次一个字符的一部分。
输出有两种方式，字节输入流：有2中方法，单个输出字节和用死循环把全部字节输出
字符输入流：也有2中方法，单个输出字符和用死循环把全部字符输出
3.字符流和字节流的区别?
字节流，读取的时候是一个字节，有时候输入的中文会不完整，因为中文有可能是两个字节和多个字节。
字符流就可以读取中文。
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDk之前:try...catch...finally.
JDK中：try(创建流对象){}catch(IOExcrption e){e.printStackTrace();}
JDk后：在try外创建流对象，rty（对象名）{会出错的代码}catch（异常类变量）{异常逻辑}

作者: 陈彬 时间: 2019-1-1 22:04
1.什么是输入流？什么是输出流？
   输入流就是把其他设备上的数据读取到内存中的流。
   输出流把数据从内存中写到其他设备上
2.输入流读取有几种方式，输出流写出有几种方式？
输入流分为：
   字节输入流：将指定的字节信息写入到内存正宗,但是只能是字节,如果是中文的话会出现乱码的情况
   字符输入流：可以读取字符信息到内存中
输出流分为：
   字节输出流：将指定的字节信息写出到指定的目的地,但是只能写的是字节,如果是中文的话会出现乱码的情况,他写的是十进制,如果写的是0-127之间的十进制那么在文件中会显示的是十进制所对应的ASCII码所对应的字母,如果超过127.那么会去查找对应系统编码表.
   字符输出流：将指定的字符信息写出到指定的目的地,可以是字节,也能是中文汉字,
3.字符流和字节流的区别?          字符流可以写出和写入中文,而字节流不能写中文,在IDEA中一个中文等于3个字节,所以使用字节流的话会出现乱码的情况
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
      JDK7之前使用try.....catch....finally语句来处理异常,在try中写可能会发生异常的代码,然后在catch中写异常的处理方法,在finlly语句块中写光流的操作.
      JDK7try().....catch....finally  可以把创建流对象放在try()后的括号中定义,这样不用在写finally语句块就能在try语句结束后,就能自动的关闭流
      JDK7之后try().....catch....finally 可以把创建流对象的语句放在try外面,然后在括号中使用对象,这样也不用在写finally语句块就能在try语句结束后,就能自动的关闭流但是这样会有一个问题就是创建流对象的语句是放在try外面的,所以要在声明一下异常,

作者: ab8846254 时间: 2019-1-1 22:35
1.什么是输入流？什么是输出流？答：1.输入流，InputStream 是IO流中字节输入流中的父类我们常用的为FileInputStream  可以把硬盘中的数据读取到内存，
   2.输出流 OutPutStream 是IO流中字节输出流中的父类我们常用的是FileOutPutStream 把内存中的数据源写入到硬盘，
2.输入流读取有几种方式，输出流写出有几种方式？
答：1.输入流的读取方式有三种，read方法一次读取一个字节，一次读取一个字节数组，一次读取一个字节数组的一部分，我们较为常用的一般是一次读取一个字节数组，并且长度一般为1024个字节
      2.输出流的写出方式有两种一次写一个字节数组，一次写一个字节数组的一部分。
3.字符流和字节流的区别?
答：字节流为最基本的流，一般用于处理一些我们看不懂的东西，如视频图片，字符流等于字节流+编码表也可以成为转换流一般处理一些文本文档，我们能读的懂的文件，用字节流处理字符的话会出现编码问题，所以衍生出字符流。
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？

答：在JDK7之前，关闭流异常处理为两种方式一种是抛出异常，一种是捕获异常，抛出异常的话在出现问题后流对象将无法关闭这样会很浪费资源，捕获异常的话，需要在try...catch...finally语句块外面创建对象赋值为null 在里面引用，这样才能获取到流对象，并且还要在finally里面再次try...catch。
  JDK7之后的JDK9对异常处理及关流的方式做了改进，在try...catch语句里面底层自动封装了关流的操作我们只需要把对象写入到try里面当代码运行完毕后会自动关流，不需要我们手动调用close方法

作者: zhuyiming 时间: 2019-1-2 08:48

1.什么是输入流？什么是输出流？
输入流将数据读取到内存
输出流内存中的数据写出到硬盘
2.输入流读取有几种方式，输出流写出有几种方式？
输入流读取有
字节流和字符流输入 1/一次读一个字节 2/一次读一个字符数组
输出流写出有
字节流 1/一次读一个字节数组 2/一次读一个字节 3/一次写一个数组的一部分
字符流 1/一次写一个字符 2/一次写一个字符数组 3/一次写一个字符数组的一部分 4/一次写一个字符串 5/一次写一个字符串的一部分
3.字符流和字节流的区别?
字节流用于操作文件的流
字符流用于操作文本的流
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前，try...catch...finally
JDK7
[td]

try (创建流对象语句，如果多个,使用';'隔开) {// 读写数据} catch (IOException e) {e.printStackTrace();}
JDK9
[td]

A a = new A();
B b = new B();
[td]try(a,b){

可能会产出异常的代码

}catch(异常类变量变量名){

异常的处理逻辑

}[/td][/td][/td]

作者: 李柏刚 时间: 2019-1-2 14:19
1.什么是输入流？什么是输出流？以内存给标杆，按照流向可分为输入流：将数据读取到内存，输出流：内存中的数据写到硬盘
2.输入流读取有几种方式，输出流写出有几种方式？
输入流有：字节输入流，字符输入流；输出流有：字节输出流，字符输出流；
3.字符流和字节流的区别?
字符流是用来操作文本的流，字节流失用来操作文件的流
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？

JDK7之前：可以使用throws 抛出异常，或使用使用try...catch...finally
JDK7: 新增了 try（创建流对象语句，如果有多个，可以使用；隔开）{ //读写数据 }catch，会自动对括号内的流对象执行关流。
JDK之后：把流对象创建在到try前面的一个（）中，在try后面的（）中写入流对象的变量名，限制了作用域，当有异常时，会自动执行关流，但一样需要throw抛出异常。

作者: 赵烈刚 时间: 2019-1-2 18:51
1.什么是输入流？什么是输出流？
输入流:把数据从硬盘上读取到内存中的流;
输出流:把数据从内存中写出到硬盘上的流;
2.输入流读取有几种方式，输出流写出有几种方式？
字节输入流:一次读一个字节和一次读一个字节数组;
字符输入流:一次读一个字符和一次读一个字符数组;
字节输出流:一次写一个字节，一次写一个字节数组，一次一个自己字节数组的一部分;
字符输出流:一次写一个字符，一次写一个字符数组，一次写一个字符数组的一部分，一次写一个字符串，一次写一个字符串的一部分；
3.字符流和字节流的区别?
字符流:以字符为单位,可以是中文;
字节流:以字节为单位,中文会乱码;
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
jdk7:之前用cry catch finally;
jdk7:try后边可以加一个（）定义流对象，并且只在try中有效，运行完自动释放
jdk9:try前可以定义流对象括号内引入变量名，执行完毕直接释放不用写finally,

作者: 黄嘉宏 时间: 2019-1-2 19:34
1.什么是输入流？什么是输出流？输入流指把数据从其他设备上读取到内存中的流。
输出流指把数据从内存写出到其他设备上的流。
2.输入流读取有几种方式，输出流写出有几种方式？
输入流读取有2种方式，字节输入流，一次读一个字节或一次读一个字节数组；字符输入流，一次读一个字符或一次读一个字符数组
输出流写出也有2种方式，字节输出流，可以写一个字节，一个数组，或写一个数组的一部分；字符输出流，可以写一个字符，一个字符数组，一个字符数组的一部分，一个字符串，一个字符串的一部分。
3.字符流和字节流的区别?
字节流可以传输任意文件数据，但是字节流在读取文本文件时，如果遇到中文字符，可能不会显示完整的字符，所以在处理文本文件时，要使用字符流类。
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？

JDK7之前，使用try...catch...finally代码块，处理异常部分。
JDK7在try后加个括号，里面放入流对象，可以确保每个资源在语句结束后关闭。
JDK7之后把流对象放在try...catch之外，引入的对象可以自动关闭。

作者: 洪烁铭 时间: 2019-1-2 19:38
1.什么是输入流？什么是输出流？从硬盘读取到内存使用的类就是输入流；文件从内存转移到硬盘中，可以进行写操作的类就是输出流。

2.输入流读取有几种方式，输出流写出有几种方式？
输入流读取的方式：分为字节流和字符流。都可以读取单个字节或者整个数组
输出流写入的方式：字节流：可以写入单个字节、整个数组、数组的一部分；字符流：可以写入单个字节、整个数组、数组的一部分、字符串、字符串的一部分。

3.字符流和字节流的区别?
字符流是对文本进行操作；字节流是对文件进行操作。

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

JDK7之前，用try··catch ，finally，在finally中进行关流；
JDK7，把创建流的对象写在try后面的（）中，出了作用域自动关闭，省去关流和处理异常的
JDK7之后，格式如下： A a = new A(); B b = new B(); try(a,b){ 可能会产出异常的代码 }catch(异常类变量变量名){ 异常的处理逻辑}

作者: 吴少华 时间: 2019-1-2 20:05
1.什么是输入流？什么是输出流？
以内存为主体，数据从硬盘流向内存为输入流，数据从内存流向硬盘位输出流
2.输入流读取有几种方式，输出流写出有几种方式？
字节输入流，字符输入流，缓存字节输入流，缓存字符输入流
字节输出流，字符输出流，缓存字节输出流，缓存字符输出流
3.字符流和字节流的区别?
字符流以字符为单位进行文件读写只能进行操作文字文本，
字节流以字节问单位进行文件读写不适合文字文字文本操作，适合非文字文本操作的增删改查
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7之前，一般用try-catch-finally处理
JDK7直接把定义放在Try中，tryj结束就自动关闭流这样就不会和JDK7之前一样要处理定义的异常繁琐的try处理
JDK7之后将定义在try-catch外部，虽然不要进行定义异常的try-catch处理，但是文件找不到异常需要throw声明抛出
综合还是用JDK7方法比较好

作者: 黄毅 时间: 2019-1-2 20:16
1.什么是输入流？什么是输出流？输入流：数据从硬盘到内存中
输出了：数据从内存写入到硬盘中
2.输入流读取有几种方式，输出流写出有几种方式？
字节输入流：一次读取一个字节；一次读取一个字节数组
字符输入流：一次读一个字符；一次读一个字符数组
字节输出流：一次写一个字节；一次写一个数组；一次写一个数组的一部分
字符输出流：一次写一个字符；一次写一个字符数组；一次写一个字符数组的一部分；一次写一个字符串；一次写一个字符串的一部分
3.字符流和字节流的区别?
字节流无法读写中文；字符流先将数据放到缓存区中，再通过flush()方法
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
JDK7前：用tyr...catch...finally
JDK7:
try (创建流对象语句，如果多个,使用';'隔开) {
// 读写数据
} catch (IOException e) {
e.printStackTrace();
}
JDK7后：
A a = new A();
B b = new B();
      try(a,b){
         可能会产出异常的代码
      }catch(异常类变量变量名){
         异常的处理逻辑
      }

作者: 杨鑫棋 时间: 2019-1-2 20:28
1.什么是输入流？什么是输出流？

输入流：将硬盘中的数据传输到内存中。
输出流：将内存中的数据传输到硬盘里。
输入流又分为两种：字节输入流和字符输入流。
输出流分为：字节输出流和字符输出流。

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

字节输入流: 字符输入流：
1.一次读取一个字节 1.一次读取一个字符
2.一次读取一个字节数组 2.一次读取一个字符数组

字节输出流：字符输出流：
1.一次写入一个字节 1.一次写入一个字符
2.一次写入一个字节数组 2.一次写入一个字符数组
3.一次写入一个字节数组的一部分 3.一次写入一个字符数组的一部分
4.一次写入一个字符串
5.一次写入一个字符串的一部分

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

字节流读写数据的最小单位是字节，所以不适合中文读写，字符流读写单位是字符
字符流有缓冲区，需要通过flush方法或者close方法将缓冲区的内容刷入。

4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
、
JDK7之前：用try...catch...finally处理

JDK7：将流对象定义在try后面的小括号内

JDK7之后：将创建完的流对象的对象名写到try后面括号内。

作者: 周章强 时间: 2019-1-2 21:41

1.什么是输入流？什么是输出流？
相对于内存而言，输入流就是从硬盘到内存。输出流就是内存到硬盘。

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

各两种。字节输入流，字符输入了。字节输出流，字符输出流。

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

字节流是使用字节作为单位进行文件读写的流。
字符流是使用字符为单位进行读写的流更适合对中文数据的操作。

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

JDK7之前是try catch finally（关流放在finally里面）JDK7的时候把流对象放在try代码块中。
JDK7之后，只是把流对象名写在try（）内，而且要throws异常。

作者: 王宏 时间: 2019-1-2 21:57
1.什么是输入流？什么是输出流？
答：从硬盘读取到内存的是输入流，从内存读取到硬盘的是输出流

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

3.字符流和字节流的区别?
1、字节流是以字节为单位读取数据，在处理文本的时候如果遇到中文的话会出现乱码问题，字符流是以字符为单位读取数据，在处理文本文件的时候比字节流更适合更好用。
2、字节流在操作数据的时候是文件本身直接操作的，而字符流在操作文本数据的时候需要进入缓冲区之后才能进行后续操作。底层还是字节流，只不过是在运用的时候对其做了封装更好的为处理文本服务。

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

作者: 王宏 时间: 2019-1-2 22:00
1.什么是输入流？什么是输出流？
以内存为基准,数据的传输也可以看成是数据的流动往内存方向流入的就是输入流，输入流也称为读取数据；反之从内存流出的数据流称为输出流，输出流也称为写出数据。
2.输入流读取有几种方式，输出流写出有几种方式？
输入流读取有两种方式，如果是字节输入流的话，一种是一次读一个字节，另外一种是一次读一个字节数组；如果是字符输入流的话，一种是一次读一个字符，另外一种是一次读一个字符数组；输出流有中的字节输出流写出有三种方式：1、一次写出一个字节 2、一次写一个字节数组 3、一次写一个字节数组中的一部分；如果是输出流中的字符输出流的话也有三种方式：1、一次写出一个字符 2、一次写一个字符数组 3、一次写一个字符数组中的一部分。
3.字符流和字节流的区别?
1、字节流是以字节为单位读取数据，在处理文本的时候如果遇到中文的话会出现乱码问题，字符流是以字符为单位读取数据，在处理文本文件的时候比字节流更适合更好用。
2、字节流在操作数据的时候是文件本身直接操作的，而字符流在操作文本数据的时候需要进入缓冲区之后才能进行后续操作。底层还是字节流，只不过是在运用的时候对其做了封装更好的为处理文本服务。
4.JDK7之前，JDK7和JDK7之后对IO流异常的处理有什么变化？
jdk7之前用cry catch finally
jdk7try后边可以加一个（）定义流对象，并且只在try中有效，运行完自动释放
jdk9try前可以定义流对象括号内引入变量名，执行完毕直接释放不用写finally

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2