java中的IO流如何分类

一、IO：上传下载，写入写出

流: 一连串流动的数据，以先入先出的方式进行流动，管道，以程序为中心、程序与网络|文件|服务器|数组..（相关课程推荐：java视频教程）

分类

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)节点流:

(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();
				}
			}
		}
	}
}

功能流

缓冲流: 增强功能，提高性能，加快读写效率

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();
	}
}

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入门教程栏目，欢迎学习！

以上是java中的IO流如何分类的详细内容。更多信息请关注PHP中文网其他相关文章！