java中的IO流分为哪几类
今天就跟大家聊聊有关java中的IO流分为哪几类，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。
成都创新互联公司服务项目包括陆丰网站建设、陆丰网站制作、陆丰网页制作以及陆丰网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，陆丰网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到陆丰省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！
流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出
一、IO：上传下载，写入写出
流: 一连串流动的数据，以先入先出的方式进行流动，管道，以程序为中心、程序与网络|文件|服务器|数组.
分类
1)按照流向:
输入流；输出流
2)操作单元分:
字节流 (万能流):任何内容都可以转为字节,可以传输文本,图片,音频；字符流 :只能操作纯文本数据
3)按照功能:
节点流 : 包裹源头,实现基本功能；功能流 : 对节点流增强性能,提高效率
4)各个分类之间是相辅相成的
字节流
(1)字节输入流 : InputStream 此抽象类是表示字节输入流的所有类的超类；FileInputStream 从文件系统中的某个文件中获得输入字节
//字节流输入 InputStream
//导包 导包快捷键: ctrl+shift+o
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class Demo01 {
public static void main(String[] args) throws IOException {
//FileInputStream(String name)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定
//FileInputStream(File file)
通过打开一个到实际文件的连接来创建一个 FileInputStream，
该文件通过文件系统中的 File 对象 file 指定
InputStream is=new FileInputStream(new File("D:/test.txt"));//创建D盘符的根目录下的文件
System.out.println(is);
//方式1： int read() 读入数据 一个字节一个字节读入
/*int num=is.read();
System.out.println((char)num);
num=is.read();
System.out.println((char)num);
System.out.println((char)(is.read()));*/
//方式2：使用循环,循环读入，可以简化代码,重复代码只写一次,但还是一个字节一个字节的读入
/*int num=-1;
while((num=is.read())!=-1){
System.out.println((char)num);
}*/
//方式3：int read(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(new String(car,0,len));
}
//关闭
is.close();
}
}(2)字节输出流： OutputStream 此抽象类是表示输出字节流的所有类的超类；FileOutputStream 文件输出流是用于将数据写入 File 的输出流
//字节输出流 OutputStream
//导包 导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Demo02 {
public static void main(String[] args) {
//FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流
//FileOutputStream(String name,boolean append)
创建一个向具有指定 name 的文件中写入数据的输出文件流
//FileOutputStream(File file,boolean append)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流
//boolean append 返回值：true追加,false不追加(默认false)
OutputStream os=null;
//try...catch(){} 捕捉异常，处理异常
try {
//1.选择流
os=new FileOutputStream("D:/hhh.txt",hhtrue);
//文件不存在,系统会自动帮我们创建,但文件夹不会
//2.准备数据
String str="要好好学习，天天向上...";
byte[] c和=str.getBytes();
//3.写出 void write(byte[] b)
os.write(ch);
//4.刷出
os.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally{
//5.关闭
try {//预防空指针异常
if(os!=null){
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}功能流
缓冲流: 增强功能，提高性能，加快读写效率
1）字节流：
BufferedInputStream 字节输入流缓冲流
BufferedOutputStream 字节输出流缓冲流
没有新增方法，可以发生多态使用
//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class BufferedInputStream01 {
public static void main(String[] args) throws IOException {
//1.选择流
//BufferedInputStream(InputStream in)
InputStream is=new BufferedInputStream(new FileInputStream("D:/hehe.txt"));
OutputStream os=new BufferedOutputStream(new FileOutputStream("E:/hengheng.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();
is.close();
}
}2）字符流:
BufferedReader 字符输入流缓冲流
新增方法: String readLine() 读取一个文本行
BufferedWriter 字符输出流缓冲流
新增方法: void newLine() 写入一个行分隔符
//导包
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedReader02 {
public static void main(String[] args) throws IOException {
//1.选择流 导包快捷键: ctrl+shift+o
BufferedReader br=new BufferedReader(new FileReader("D:/hehe.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("D:/ccc.txt"));
//2.读写
String msg=null;
while((msg=br.readLine())!=null){
bw.write(msg);
bw.newLine();
}
//3.刷出
bw.flush();
//4.关闭
bw.close();
br.close();
}
}字符流
只能操作纯文本
1)节点流:
(1)字符输入流：Reader 读取字符流的抽象类；FileReader 用来读取字符文件的便捷类
//字符输入流 Reader
//导包 导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Demo03 {
public static void main(String[] args) {
//FileReader(String fileName)
Reader rd=null;
try {
//1.选择流
rd=new FileReader("D:/hehe.txt");//创建D盘符的根目录下的文件
//2.读入
//方法1：int read() 读取单个字符。
/*System.out.println((char)rd.read());
System.out.println((char)rd.read());
System.out.println((char)rd.read());
System.out.println((char)rd.read());*/
int len=-1; //存储读到的数据 如果为-1,证明已达到末尾
//方法2:
/*while(-1!=(len=rd.read())){
System.out.println((char)len);
}*/
//方法3：int read(char[] cbuf) 将字符读入数组。
char[] car=new char[1024];
while((len=rd.read(car))!=-1){
System.out.println(new String(car,0,len));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally{
if(rd!=null){
try {
//关闭功能
rd.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}(2)字符输出流: Writer 写入字符流的抽象类；FileWriter 用来写入字符文件的便捷类
//字符输出流：Writer
//导包 导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
public class CharDemo02 {
public static void main(String[] args) {
//FileWriter(File file) //默认不追加
//FileWriter(File file, boolean append)
//FileWriter(String file)
//FileWriter(String file, boolean append)
Writer rt=null;
try {
//1.选择流
rt=new FileWriter("D:/houhou.txt",true);
//2.写出
/* void write(char[] cbuf) 写入字符数组
void write(char[] cbuf, int off, int len) 写入字符数组的某一部分
void write(int c) 写入单个字符
void write(String str) 写入字符串
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();
} finally{
//4.关闭
if(null!=rt){
try {
rt.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}Data流(字节节点流)
Data流(字节节点流)：
读写基本数据类型+String类型数据，是字节流功能流的一种
DataInputStream 新增方法: readXxx()
DataOutputStream 新增方法: writeXxx()
存在新增方法不能发生多态，先写出再写入
可能碰到的异常：EOFException 文件有,内容读入不到,必须读入的是写出的源文件
//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Data01 {
public static void main(String[] args) throws IOException {
//调用方法
write("D:/data.txt");
read("D:/data1.txt");
}
//读入
public static void read(String path) throws IOException{
//1.输入流 数据类型+数据
DataInputStream in=new DataInputStream(new BufferedInputStream(new FileInputStream(path)));
//2.读入
int i=in.readInt();
boolean b=in.readBoolean();
String s=in.readUTF();
System.out.println(i+"-->"+b+"-->"+s);
//3.关闭
in.close();
}
//写出
public static void write(String path) throws IOException{
//1.输出流
DataOutputStream out=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
//2.准备数据
int i=101;
boolean f=false;
String s="哈哈";
//3.写出 写出和读入的顺序要保持一致
out.writeInt(i);
out.writeBoolean(f);
out.writeUTF(s);
//4.刷出
out.flush();
//5.关闭
out.close();
}
}对象流
Object 保存数据类型+数据
字节的功能流:当想要传输|读写对象类型数据的时候,可以使用一个对象流
序列化: 把对象类型的数据转化为可存储|可传输的状态的过程
ObjectInputStream() 反序列化输入流 新增方法: readObject()
ObjectOutputStream() 序列化输出流 新增方法: writeObject()
注意:
1)先序列化后反序列化
2)序列化反序列读写顺序一致
3)不是所有的类都能序列化 java.io.Serializable 空接口
4)不是所有的属性都需要序列化 transient
5)static内容不会被序列化
6)如果父类实现Serializable接口,子类中可以序列化所有内容
如果子类实现Serializable接口,但是父类没有实现,子类只能序列化子类独有的内容
//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Arrays;
public class ObjectDemo02 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
write("D:/object.txt");
read("D:/object.txt");
}
//反序列化输入
public static void read(String path) throws IOException, ClassNotFoundException{
//1.输入流
ObjectInputStream is=new ObjectInputStream(new BufferedInputStream(new FileInputStream(path)));
//2.读入
Object p= is.readObject();
int[] arr= (int[]) is.readObject();
if(p instanceof Person){
Person person=(Person)p;
System.out.println(person.getName());
}
System.out.println(p);
System.out.println(Arrays.toString(arr));
//3,关闭
is.close();
}
//序列化输出
public static void write(String path) throws IOException{
//1.输出对象信息
ObjectOutputStream os=new ObjectOutputStream(new BufferedOutputStream(new
FileOutputStream(path)));
//2.准备数据
Person p=new Person("aaa",18);
int[] arr={1,2,3,4};
//3.输出
os.writeObject(p);
os.writeObject(arr);
//4.刷出
os.flush();
//5.关闭
os.close();
}
}
//接口
class Person implements Serializable{
private String name;
private static int age;
public Person() {
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}二、File 类
File 类：文件和目录路径名的抽象表示形式
提供的功能：操作文件外部的能力,不能操作文件内部的内容
能够定义真实存在的路径|文件,不在的也可以定义,所以抽象表现形式
构造器： File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例
File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例
File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例
看完上述内容，你们对java中的IO流的种类有进一步的了解吗？如果还想了解更多知识或者相关内容，请关注创新互联行业资讯频道，感谢大家的支持。
标题名称：java中的IO流分为哪几类
文章URL：http://ybzwz.com/article/gcsspc.html
