java io流的分类_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入门教程栏目，欢迎学习！