java中的io流分为几种,java 中 IO 流分为几种?它们的区别是什么?
一、IO：上传下载，写入写出
流：一系列流动的数据，以先进先出的方式流动，管道，以程序为中心，程序和网络文件服务器阵列.(相关课程推荐：java视频教程)
分类
1)按流向：
输入流；输出流
2)业务单位分为：
字节流(universal stream):任何内容都可以转换成字节，可以传输文字、图片、音频；字符流：只能操作纯文本数据。
3)根据功能：
节点流：包装源码，实现基本功能；功能流：增强节点流的性能，提高效率。
4)各分类互为补充。
字节流
(1) Byte InputStream: InputStream这个抽象类是一个超类，代表Byte InputStream的所有类；FileInputStream从文件系统中的文件获取输入字节。
//输入到InputStream的字节流
//包指南快捷键：ctrl shift o
导入Java . io . file；
导入Java . io . file inputstream；
import Java . io . filenotfoundexception；
导入Java . io . io exception；
导入Java . io . inputstream；
公共类演示01 {
公共静态void main(String[] args)引发IOException {
//FileInputStream(字符串名称)
通过打开到实际文件的连接来创建FileInputStream，实际文件由文件系统中的路径名指定。
//FileInputStream(文件File)
通过打开到实际文件的连接来创建FileInputStream，
该文件由文件系统中的文件对象文件指定。
InputStream is=new File InputStream(new File( D:/test . txt ))；//在D盘符的根目录下创建一个文件
system . out . println(is)；
//模式1: Intread()逐字节读入数据。
/* int num=is . read()；
system . out . println((char)num)；
num=is . read()；
system . out . println((char)num)；
system . out . println((char)(is . read()))；*/
//方式二：使用循环，循环读取，可以简化代码。Repeat代码只写一次，但还是一个字节一个字节地读。
/*整数=-1；
while((num=is.read())！=-1){
system . out . println((char)num)；
}*/
//模式三：Intread (byte [] b)按字节数组读入字节数组。
//返回值：返回读入字节数组的数据个数，未读入则返回-1。
byte[]car=new byte[1]；
//int len=is . read(car)；
int len=-1；
while((len=is.read(car))！=-1){
System.out.println(新字符串(car，0，len))；
}
//关闭
is . close()；
}
}(2)Byte output stream:output stream这个抽象类是所有表示输出字节流的类的超类；输出流FileOutputStream是用于将数据写入文件的输出流。
//字节输出流输出流
//包指南快捷键：ctrl shift o
import Java . io . filenotfoundexception；
导入Java . io . file output stream；
导入Java . io . io exception；
导入Java . io . output stream；
公共类演示02 {
公共静态void main(String[] args) {
//FileOutputStream(字符串名称)创建一个输出文件流，将数据写入具有指定名称的文件。
//FileOutputStream(字符串名称，布尔追加)
创建输出文件流，将数据写入具有指定名称的文件。
//FileOutputStream(文件File，布尔追加)
创建一个Fileoutputstream，将数据写入由指定file对象表示的文件。
//布尔追加返回值：真追加，假不追加(默认为假)
OutputStream os=null
//尝试.catch(){}捕获并处理异常。
尝试{
//1.选择流。
OS=new file output stream( D:/hhh . txt ，hh true)；
//文件不存在，系统会自动帮我们创建，文件夹不会。
//2.准备数据
String str=好好学习，天天向上.；
Byte[] c和=str . getbytes()；
//3.写空写(字节[] b)
OS . write(ch)；
//4.铲除
OS . flush()；
} catch(file not found exception e){
e . printstacktrace()；
} catch (IOException e) {
e . printstacktrace()；
}最后{
//5.关闭
尝试{//防止空指针异常
如果(os！=null){
OS . close()；
}
} catch (IOException e) {
e . printstacktrace()；
}
}
}
}字符流
只能操作纯文本。
1)节点流量：
(1)字符输入流：阅读器读取字符流的抽象类；FileReader用来读取字符文件的一个方便的类。
//字符输入流阅读器
//包指南快捷键：ctrl shift o
导入Java。io。filenotfoundexception
导入Java。io。filereader
导入Java。io。io异常；
导入Java。io。读者；
公共类演示03 {
公共静态void main(String[] args) {
//FileReader(字符串文件名)
读取器rd=空
尝试{
//1.选择流
rd=new file reader( D:/呵呵。txt’)；//创建D盘符的根目录下的文件
//2.读入
//方法1:int read()读取单个字符。
/*系统。出去。println((char)rd。read())；
系统。出去。println((char)rd。read())；
系统。出去。println((char)rd。read())；
系统。出去。println((char)rd。read())；*/
int len=-1；//存储读到的数据如果为-1,证明已达到末尾
//方法2:
/*while(-1！=(len=rd。read()){
系统。出去。println((char)len)；
}*/
//方法3:int read(char[] cbuf)将字符读入数组。
char[]car=new char[1024]；
while((len=rd.read(car))！=-1){
System.out.println(新字符串(car，0，len))；
}
} catch(找不到文件异常e){
e。printstacktrace()；
} catch (IOException e) {
e。printstacktrace()；
}最后{
如果(rd！=null){
尝试{
//关闭功能
研发。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
}
}
}(2)字符输出流：作家写入字符流的抽象类；字符输出流用来写入字符文件的便捷类
//字符输出流：作家
//导包导包快捷键：ctrl shift o
导入Java。io。filenotfoundexception
导入Java。io。filereader
导入Java。io。filewriter
导入Java。io。io异常；
导入Java。io。读者；
导入Java。io。作家；
公共类CharDemo02 {
公共静态void main(String[] args) {
//文件写入器(文件文件)//默认不追加
//文件写入器(文件文件，布尔追加)
//文件写入器(字符串文件)
//文件写入器(字符串文件，布尔追加)
编写器rt=null
尝试{
//1.选择流
rt=new FileWriter( D:/Hou Hou。txt ，真)；
//2.写出
/*无效写入(char[] cbuf)写入字符数组
void write(char[] cbuf，int off，int len)写入字符数组的某一部分
无效写入(int c)写入单个字符
无效写入（字符串)写入字符串
void write(String str，int off，int len)写入字符串的某一部分
*/
rt . write(97)；
rt . write( \ r \ n )；//换行
rt.write(你真好看！);
rt . write( \ r \ n )；
rt.write(你真好看！,2,2);
rt . write( \ r \ n )；
char[] ch={a ， b ， c ， d ， e }；
rt . write(ch)；
rt . write( \ r \ n )；
rt.write(ch，2，3)；
//3.刷出
rt . flush()；
} catch (IOException e) {
e。printstacktrace()；
}最后{
//4.关闭
if(null！=rt){
尝试{
rt . close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
}
}
}功能流
缓冲流：增强功能，提高性能，加快读写效率
1)字节流：
缓冲输入流字节输入流缓冲流
输出流字节输出流缓冲流
没有新增方法，可以发生多态使用
//导包
导入Java。io。bufferedinputstream
导入Java。io。bufferedoutputstream
导入Java。io。文件输入流；
导入Java。io。filenotfoundexception
导入Java。io。文件输出流；
导入Java。io。io异常；
导入Java。io。inputstream
导入Java。io。输出流；
公共类BufferedInputStream01 {
公共静态void main(String[] args)引发IOException {
//1.选择流
//BufferedInputStream(InputStream in)
InputStream is=new BufferedInputStream(新文件InputStream( D:/呵呵。txt’)；
输出流OS=new BufferedOutputStream(新文件输出流( E:/heng heng。txt’))；
//2.读写
byte[]car=new byte[1024]；
int len=-1；
while((len=is.read(car))！=-1){
os.write(car，0，len)；
}
//3.刷出
OS。flush()；
//4.关闭
OS。close()；
是。close()；
}
}2)字符流：
类字符输入流缓冲流
新增方法：String readLine()读取一个文本行
缓冲区输出字符输出流缓冲流
新增方法：无效换行符()写入一个行分隔符
//导包
导入Java。io。缓冲阅读器；
导入Java。io。缓冲编写器；
导入Java。io。filereader
导入Java。io。filewriter
导入Java。io。io异常；
公共类BufferedReader02 {
公共静态void main(String[] args)引发IOException {
//1.选择流导包快捷键：ctrl shift o
缓冲阅读器br=新缓冲阅读器(新文件阅读器( D:/呵呵。txt’)；
缓冲编写器bw=新缓冲编写器(新文件编写器( D:/CCC。txt’)；
//2.读写
字符串消息=空
while((msg=br.readLine())！=null){
bw。写(msg)；
bw。newline()；
}
//3.刷出
bw。flush()；
//4.关闭
bw。close()；
br。close()；
}
}Data流(字节节点流)
数据流（字节节点流):
读写基本数据类型线类型数据，是字节流功能流的一种
输入流新增方法：readXxx()
输出流新增方法：writeXxx()
存在新增方法不能发生多态，先写出再写入
可能碰到的异常：eof异常文件有，内容读入不到，必须读入的是写出的源文件
//导包
导入Java。io。bufferedinputstream
导入Java。io。bufferedoutputstream
导入Java。io。数据输入流；
导入Java。io。数据输出流；
导入Java。io。文件输入流；
导入Java。io。filenotfoundexception
导入Java。io。文件输出流；
导入Java。io。io异常；
公共类数据01 {
公共静态void main(String[] args)引发IOException {
//调用方法
写( D:/data。txt’)；
读取( D:/data1。txt’)；
}
//读入
公共静态空的读取（字符串路径)引发IOException{
//1.输入流数据类型数据
data inputstream in=new data inputstream(new BufferedInputStream(new file inputstream(path)))；
//2.读入
int I=in。readint()；
布尔b=英寸。读取boolean()；
字符串s=in。读取utf()；
系统。出去。println(I - b - s)；
//3.关闭
英寸close()；
}
//写出
公共静态空的写入（字符串路径)引发IOException{
//1.输出流
数据输出流out=新数据输出流(new BufferedOutputStream(新文件输出流(路径)))；
//2.准备数据
int i=101
布尔f=假；
字符串s=哈哈；
//3.写出写出和读入的顺序要保持一致
出去。写int(I)；
出去。写布尔型(f)；
out.writeUTF
//4.刷出
出去。flush()；
//5.关闭
出去。close()；
}
}对象流
目标保存数据类型数据
字节的功能流：当想要传输读写对象类型数据的时候，可以使用一个对象流
序列化：把对象类型的数据转化为可存储可传输的状态的过程
ObjectInputStream()反序列化输入流新增方法：readObject()
ObjectOutputStream()序列化输出流新增方法：writeObject()
注意：
1)先序列化后反序列化
2)序列化反序列读写顺序一致
3)不是所有的类都能序列化java.io。序列化空接口
4)不是所有的属性都需要序列化短暂的
5)静态内容不会被序列化
6)如果父类实现可序列化接口，子类中可以序列化所有内容
如果子类实现可序列化接口，但是父类没有实现，子类只能序列化子类独有的内容
//导包
导入Java。io。bufferedinputstream
导入Java。io。bufferedoutputstream
导入Java。io。文件输入流；
导入Java。io。文件输出流；
导入Java。io。io异常；
导入Java。io。objectinputstream
导入Java。io。对象输出流；
导入Java。io。可序列化；
导入Java。util。数组；
公共类ObjectDemo02 {
公共静态void main(String[] args)引发IOException，ClassNotFoundException {
写( D:/object。txt’)；
读取( D:/object。txt’)；
}
//反序列化输入
公共静态空的读取（字符串路径)引发IOException，ClassNotFoundException{
//1.输入流
ObjectInputStream is=new ObjectInputStream(new BufferedInputStream(new file inputstream(path)))；
//2.读入
对象p=是。read object()；
int[]arr=(int[])是。read object()；
如果（人的实例){
人person=(人)p；
系统。出去。println(人。getname())；
}
系统。出去。println(p)；
系统。出去。println(数组。tostring(arr))；
//3,关闭
是。close()；
}
//序列化输出
公共静态空的写入（字符串路径)引发IOException{
//1.输出对象信息
对象输出流OS=新对象输出流(new BufferedOutputStream(new
文件输出流(路径)))；
//2.准备数据
人p=新人(‘AAA’，18)；
int[] arr={1，2，3，4 }；
//3.输出
OS。writeobject(p)；
OS。writeobject(arr)；
//4.刷出
OS。flush()；
//5.关闭
OS。close()；
}
}
//接口
类人实现可序列化{
私有字符串名称；
私有静态整数；
公共人物(){
}
公共人物（字符串名称，整数){
super()；
this.name=name
this.age=年龄；
}
公共字符串getName() {
返回名称；
}
public void setName(字符串名){
this.name=name
}
public int getAge() {
回归年龄；
}
公共无效存储(整数){
this.age=年龄；
}
@覆盖
公共字符串toString() {
返回 Person [name= name ，age= age ]；
}
}二、File 类
Class:文件和目录路径名的抽象表示。
提供的功能：能够在文件外操作，但不能操作文件内的内容。
可以定义真实路径 file，也可以定义缺席路径，所以是抽象表示。
构造函数：File(File parent，String child)根据父级的抽象路径名和子级路径名的字符串创建一个新的文件实例。
文件(字符串路径名)通过将给定的路径名字符串转换为抽象路径名来创建新的文件实例。
文件(字符串parent，字符串child)根据父路径名字符串和子路径名字符串创建新的文件实例。
本文来自java入门教程专栏，欢迎学习！以上是java中IO流如何分类的细节。请多关注我们的其他相关文章！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。