黑马程序员技术交流社区

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

作者: 厦门校区    时间: 2018-8-23 20:59
标题: 【厦门JavaEE就业三期-每日总结】字节流、字符流

今天我们学习了字符流和字节流,请根据自己的理解回答下面问题:
1.什么是输入流?什么是输出流?
2.输入流读取有几种方式,输出流写出有几种方式?
3.字符流和字节流的区别?
4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?
作者: 罗荣贵    时间: 2018-8-23 21:09
1.输入流是从硬盘(文件)读取数据到内存,输出流是将内存中的数据保存到硬盘中(文件中)
2.输入流分字节输入流和字符输入流,只有一种方式,输出流也分字节输出流和字符输出流,有两种输出方式,可以有覆盖式输出和续写式输出,其中具体输出方式又分单字节或字符输出和以字节数组或字符数组输出
3.字节流是以底层数据存储的方式进行写入输出,字符流的底层也是字节流,但是经过代码和JVM处理后以字符显示进行写入输出
4.jdk7之前是 try....catch...fianlly ,jdk 8 加入try...with ...reasuce ,在try(创建流对象),可以自动释放资源 ,到9 后可以在try都得括号内传入流对象,自动释放资源,但依然对创建流对象过程抛出异常处理
作者: 郭生发    时间: 2018-8-23 21:16
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流异常的处理有什么变化?

   JDK7之前使用try.....catch....finally...代码块
  JDK7使用try-with-sourse语句,无需手动close
  JDK9在JDK7的基础上引入对象的方式,无需手动close

作者: 张子建    时间: 2018-8-23 21:20
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...代码块
  JDK7使用try-with-sourse语句,无需手动close
  JDK9在JDK7的基础上引入对象的方式,无需手动close

作者: 陈张辉    时间: 2018-8-23 21:21
1.什么是输入流?什么是输出流?
    读                           写
2.输入流读取有几种方式,输出流写出有几种方式?
字符流/字节流                             字符流/字节流
3.字符流和字节流的区别?
字符流可以解决编码问题
4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?
try(创建流对象)                     JDK9    创建流对象并处理异常   try(流对象变量)

作者: 练志成    时间: 2018-8-23 21:22
.什么是输入流?什么是输出流?
输入流读取从文件中读取数据到代码中使用
输出流就是从代码中把数据传入文件
2.输入流读取有几种方式,输出流写出有几种方式?
两种,一种字节,一种字符(都是两种)
3.字符流和字节流的区别?
字节流读取的是字节
字符流读取的是字符
4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?
jdk7以前抛出和自己处理,7以后自己处理的方式中try后加了一个()
作者: 丶黑白    时间: 2018-8-23 21:22
余志斌
1.什么是输入流?什么是输出流?

输入流 :从目标文件数据读取至内存
输出流: 将数据写入目标文件
2.输入流读取有几种方式,输出流写出有几种方式?
   都是2种,一种通过字符流,一种通过字节流。
3.字符流和字节流的区别?
字节流是字符流的底层,是为了方便文本类文档操作设置的。
4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?
   在try后加了(),可以将对象创建步骤写在()内并且省略finally以及close方法。
作者: ZNBran    时间: 2018-8-23 21:23
1输入流就是读取其他设备保存的文件到当前工作内存当中,输出流就是把当前内存中的数据写入其他设备。
2输入流读取有两种方式一种是读取单个字节或是字符,第二种是将字节或是字符读入数组。
输出流写出有两种方式一种是写入单个字符或字节,第二是写入数组。
3字符流以字符为单位读写一般用来读写文本文件,无法读写图片视频等非文本文件。
4在JDK7之前使用try catch finally 处理流中的异常,JDK7在try的后边可以增加一个(),在括号中可以定义流对象,try中的代码执行完毕,会自动把流对象释放,不用写finally。JDK7之后try的括号中可以直接写对象名称。
======================================================周楠
作者: 赖良峰    时间: 2018-8-23 21:25
1.什么是输入流?什么是输出流?InputStream/Reader
OutStream/Writer
2.输入流读取有几种方式,输出流写出有几种方式?
FileInputStream/FileReader
FileOutStream/FileWriter
3.字符流和字节流的区别?
字符流基于字节流,字符流只能处理文本文件,
4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?

7之前:
try{
可能会产生异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}finally{
一定会指定的代码 资源释放
}
7之后
try(流对象1,流对象2,...){
可能会产生异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}(执行完后会自动释放流对象,不用finally关键字)

作者: liebstch    时间: 2018-8-23 21:26
陈建秋
1.什么是输入流?什么是输出流?输入流:从硬盘中读取数据到工作内存中。
输出流:从工作内存中将数据写到硬盘上。
2.输入流读取有几种方式,输出流写出有几种方式?
字节输入流;字符输入流;
字节输出流,字符输出流;
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,当是在外部创建流对象依旧会抛出异常。

作者: spik    时间: 2018-8-23 21:26
1.什么是输入流?什么是输出流?
    1、输入流是指把数据从其他设备上读取到内存中的流。
    2、输出流是指把数据从内存中写出到其他设备上的流。

2.输入流读取有几种方式,输出流写出有几种方式?
输入流读取有字节输入和字符输入两种;输出流也是有字节输出和字符输出两种。

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

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

lijionghua
作者: 李志超    时间: 2018-8-23 21:27
1.什么是输入流?什么是输出流?
硬盘--》内存;内存--》硬盘
2.输入流读取有几种方式,输出流写出有几种方式?
inputstream&reader;outputstream&writer
3.字符流和字节流的区别?
字符流的底层原理是字节流,可读取中文而不会产生乱码(相同编码规则)。
4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?
7之前:try..catch..finally
7:try..with..sourse(不需要finally也会执行释放资源)
9: try中可以传流对象,但是流对象要创建在try上方,且需要抛出异常。
作者: 罗建辉    时间: 2018-8-23 21:28
1.什么是输入流?什么是输出流?
输入流:InputStream,将内容从磁盘中文件读取到工作内存中
输出流:OutputStream,将工作空间的内容写入到文件中

2.输入流读取有几种方式,输出流写出有几种方式?
输入流:字节输入流,字符输入流
输出流:字节输出流,字符输出流

3.字符流和字节流的区别?
字节流:读取文件时是一个字节一个字节读取
字符流:读取文件时是两个字节两个字节的读取

4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?
JDK7之前,使用try...catch...finally,来处理异常代码块
JDK7优化后使用try-with-resource 语句,其特点是可以自动关闭资源,



作者: 张煜兴    时间: 2018-8-23 21:30
本帖最后由 张煜兴 于 2018-8-24 08:56 编辑

1.什么是输入流?什么是输出流?
输入流:进行读操作的流,从硬盘到内存
输出流:进行写操作的流,从内存到硬盘

2.输入流读取有几种方式,输出流写出有几种方式?
字节输入流读取主要有三种:read()、read(byte[ ] bytes)、read(byte[ ] bytes,int index,  int length),
字符输入流:read()、read(char[ ] chars)、read(char[ ] chars,int index,  int length)
字节输出流写出有:write()、write(byte[ ] bytes)、write(byte[ ] bytes,int index,  int length)
字符输出流:write()、write(char[ ] chars)、write(chars[ ] chars,int index,  int length)、write(string  s)、write(string  s,int index,  int length)

3.字符流和字节流的区别?
字节流和字符流部分方法传输的参数不一致,字符流只能对文本进行IO操作,而字节流可以对更多类型文件进行IO操作

4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?
JDK7之前:用try...catch...finally
JDK7:用try()...with...resource
JDK7之后:用try(多个流对象,并用;隔开)...with...resource



作者: sulaymanfan    时间: 2018-8-23 21:32
1.什么是输入流?什么是输出流?    输入流:相对于参照物读进来的数据
    输出流:相对于参照物写出去的数据

2.输入流读取有几种方式,输出流写出有几种方式?
       字节输入流;字节输出流
       字符输入流;字符输出流;
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,当是在外部创建流对象依旧会抛出异常。



作者: 舟sir    时间: 2018-8-23 21:32
1.什么是输入流?什么是输出流?输入流:数据读入cpu
输出流:cpu数据写入文件
2.输入流读取有几种方式,输出流写出有几种方式?

两种:read方法和load方法
两种:write方法和Store方法
3.字符流和字节流的区别?

字符流:是以字符形式读取和写入,用字节流读取和写入会出去乱码
字节流:是以字节单位读取和写入
4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?

Jdk1.7 增加Try-with-resource语句多了(),会自动释放资源,关闭对象,不需要finally,lose方法
jdk1.7之后: 引入了对象方式,同样可以释放资源,不需要close方法




周家乾

作者: weimengchao    时间: 2018-8-23 21:34
1.什么是输入流?什么是输出流?
从外界到内存
从内存到外界
2.输入流读取有几种方式,输出流写出有几种方式?
字节输入流 字符输入流
字节输出流 字符输出流
3.字符流和字节流的区别?
字符流的底层是字节流
字节流一个字节一个字节读取
字符流一个字符一个字符读取
4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?
try{}catch{}finally{}处理异常
try(流对象){}catch{} 可以直接关闭流资源

作者: MJ11    时间: 2018-8-23 21:34
本帖最后由 MJ11 于 2018-8-23 21:58 编辑

1.什么是输入流?什么是输出流?
         输入流:InputStream,指把数据由硬盘设备读取到内存中的流         输出流:OutputStream,指把数据从内存中写出到其他设备上的流
2.输入流读取有几种方式,输出流写出有几种方式?
      输出流:三种,write(byte[] b) :将 b.length字节从指定的字节数组写入此输出流。                   write(byte[] b, int off, int len) :从指定的字节数组写入 len字节,从偏移量 off开始输
                  出到此输出流。
                   write(int b) :将指定的字节输出流。
     输入流:两种,read() : 从输入流读取数据的下一个字节
                            read(byte[] b) : 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。

3.字符流和字节流的区别?
         区别:字符流底层是字节流,字节流操作的是一个字节单位
4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?
JDK之前: try...catch...finally
JDK之时:try()...with...resource,必须实现AutoCloseable,自动释放资源(Io对象调用close())
JDK之后:  try(IO对象名)..多个对象名之间用;隔开..with...resource   
               1.需要在try代码块上创建流对象,也需要处理异常
               田浪

作者: 黄艺纯    时间: 2018-8-23 21:34
1.什么是输入流?什么是输出流?

输入流 :把数据从 其他设备 上读取到 内存 中的流。
输出流 :把数据从 内存 中写出到 其他设备 上的流。

2.输入流读取有几种方式,输出流写出有几种方式?

两种:字节流和字符流。

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

1.字节流在操作的时候本身是不会用到缓冲区(内存)的,是与文件本身直接操作的,而字符流在操作的时候是使用到缓冲区的
2.字节流在操作文件时,即使不关闭资源(close方法),文件也能输出,但是如果字符流不使用close方法的话,则不会输出任何内容,说明字符流用的是缓冲区,并且可以使用flush方法强制进行刷新缓冲区,这时才能在不close的情况下输出内容

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

    JDK7之前处理异常需要在try、catch后面加final代码块处理close();代码过于冗余。JDK7之后,只需在try()里面定义io类即可自动关闭流。

    在JDK7之后新增加了AutoCloseable接口,而Closeable继承了该接口。能够写在try(...)的括号里面的类对象必须实现AutoCloseable 接口,这样try(...)里面的对象执行完代码块{...}里面的内容后(即大括号里面的内容执行完毕后小括号里面的对象会自动关闭),会自动调用自己的close()方法去关流,所以FileInputStream和FileOutputStream都是实现了AutoCloseable 接口的


作者: 谢君昇    时间: 2018-8-23 21:36
1.什么是输入流?什么是输出流?  输入流:内存从硬盘读取数据;
  输出流:内存把数据写到硬盘;
2.输入流读取有几种方式,输出流写出有几种方式?
   字节、字符输入流;
   字节、字符输出流;
3.字符流和字节流的区别?
   字节流可以用于任何对象,而字符流只能处理字符或字符串;
4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?

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

作者: 郑颖锋    时间: 2018-8-23 21:37
今天我们学习了字符流和字节流,请根据自己的理解回答下面问题:
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之前定义流对象,并抛出流对象的异常。





作者: 李伟javaee03    时间: 2018-8-23 21:37
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之后引入对象的方式,支持更加简洁的引入对象,会自动释放资源

作者: yangshixian    时间: 2018-8-23 21:38
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代码执行完后,流对象自动释放,来处理异常

杨式贤


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

作者: 陈捷    时间: 2018-8-23 21:41
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,当是在外部创建流对象依旧会抛出异常。
作者: 黄伟佳    时间: 2018-8-23 21:41
1.什么是输入流?什么是输出流?
输入:从外界输入到内存。
输出:从内存储存到外界硬盘等等之类的
2.输入流读取有几种方式,输出流写出有几种方式?
有两种:字节输入,输出流,字符输入,输出流

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



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

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


作者: 陈锦祥    时间: 2018-8-23 21:45
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 的改进,对于引入对象的方式,支持的更加简洁。

作者: 沈智桂    时间: 2018-8-23 21:46
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
作者: 冰是睡着的水    时间: 2018-8-23 21:48
1.什么是输入流?什么是输出流?
答:输入流指的是把数据从其他设备上读取到内存中的流;
    输出流指的是把数据从内存中写到其他设备上的流。

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

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

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

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

(黄嘉欣)
作者: 赵烈刚    时间: 2018-8-23 21:48
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括号中可以放入多个对象名,用“;”隔开。

作者: 吴鑫佳    时间: 2018-8-23 21:50
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的对象.
作者: 林嘉志    时间: 2018-8-23 21:51
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之上创建对象,声明异常)



作者: 苏华琛    时间: 2018-8-23 21:52
1.什么是输入流?什么是输出流?

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

2.输入流读取有几种方式,输出流写出有几种方式?

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

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

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

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

jdk7之前的处理方式为:try...catch...finnay
jdk7的处理方式为:try...with...sourse
jdk7之后的处理方式为: try(对象)...with...sourse     
作者: 仰望`星空    时间: 2018-8-23 21:52
郭林源

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 又加以改进,引入对象,同样可以自动关闭流
作者: 刘建宝    时间: 2018-8-23 21:52
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,当是在外部创建流对象依旧会抛出异常。
作者: 迪亚波罗    时间: 2018-8-23 21:53
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,当是在外部创建流对象依旧会抛出异常。

孙享

作者: 小悦悦    时间: 2018-8-23 21:54
1.把设备上读取数据到内存中,2.把内存里的东西写入到设备上
2.输入两种,输出有3种
3.字符流的底层是字节流
4.JDK7之前使用try.....catch....finally...代码块
  JDK7使用try-with-sourse语句,无需手动close
  JDK9在JDK7的基础上引入对象的方式,无需手动close
--李翔
作者: 林靖    时间: 2018-8-23 21:54
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代码块之上创建流对象

作者: 小鱼七    时间: 2018-8-23 21:55
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流的变量名,也不需要手动关闭流

作者: zouyitao    时间: 2018-8-23 21:57
邹毅涛
1.什么是输入流?什么是输出流?
将外部数据读取到内存中叫输入流。
将内存中的字节写出到外部为输出流。
2.输入流读取有几种方式,输出流写出有几种方式?
输入流读取和输出流写出都有字节输入流和字符输入流两种方式。
3.字符流和字节流的区别?
字符流操作的是字符,字节流则是字节。字符流可以解决编码问题。计算机最小存储单元为字节。
4.JDK7之前,JDK7和JDK7之后对IO流异常的处理有什么变化?
JDK7之前用try CatchFinally需要手动释放资源。
JDK7-JDK9改为try with resource try中语句执行完自动释放资源
JDK9之后try中写对象,代码简洁,但仍需抛出异常,执行完也会自动释放资源。
作者: Michcale    时间: 2018-8-24 08:37
----------------吴齐宾-------------------
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之后引入了对像的引用

作者: 铜墙铁壁花无缺    时间: 2018-8-24 08:41
KinLong Yu
1.什么是输入流?什么是输出流?
    1、输入流是指把数据从其他设备上读取到内存中的流。
    2、输出流是指把数据从内存中写出到其他设备上的流。

2.输入流读取有几种方式,输出流写出有几种方式?
输入流读取有字节输入和字符输入两种;输出流也是有字节输出和字符输出两种。

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

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

作者: shenxiaogan    时间: 2018-8-24 21:46

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

  jdk7前:try.....catch....finally..
  jdk7后:try-with-sourse,自动释放资源
  jdk9:需要在try代码块之上创建流对象
作者: 陈捷    时间: 2018-8-24 22:01
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
作者: 黄艺纯    时间: 2018-8-25 11:21
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 对输出流的封装

   










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