java中的IO流

1、JDK所提供的所有流类位于java.io包中，都分别继承自以下四种抽象流类。

InputStream：继承自InputStream的流都是用于向程序中输入数据的，且数据单位都是字节（8位）。

OutputStream：继承自OutputStream的流都是程序用于向外输出数据的，且数据单位都是字节（8位）。

Reader：继承自Reader的流都是用于向程序中输入数据的，且数据单位都是字符（16位）。

Writer：继承自Writer的流都是程序用于向外输出数据的，且数据单位都是字符（16位）。

 

 

 

 

 

1.1 Writer字符输出流

它是所有字符输出流的跟类。---FileWriter类

public class TestWriter {
public static void main(String[] args) throws Exception{
        //字符输出流 ---指定对哪个文件（路径）进行写操作
        Writer  writer=new FileWriter("D:/AAA/d.txt");
//true:表示允许追加内容到文件中 
　　　　　　//Writer writer=new FileWriter("D:/AAA/d.txt",true);

        String str="你好 你今天真漂亮";
        writer.write(str);
 
        writer.flush(); //刷新流
        writer.close(); //关闭流资源
    }
}

 

 

1.2 Reader字符输入流

它是所有字符输入流的根类  它的实现类有很多，我们使用FileReader实现类。

public class TestReader {
    public static void main(String[] args) throws Exception {
        //创建字符输入流对象. 作用：就是读取aaaa.txt里的内容
        Reader reader=new FileReader("D:/BBB/aaa.txt");
 
        int r=0;//表示读取字符的个数
        while ((r=reader.read())!=-1){
            System.out.print((char)r);
        }
    }
}

1.3经典题 要求: D:/AAA/d.txt 复制到 C:/AAA/d.txt.

public class TestDemo1{
@Test
    public void test02() throws Exception{
         //创建一个字符输入流
        FileReader fr=new FileReader("D:/AAA/d.txt");
 
        //创建一个字符输出流
        FileWriter fw=new FileWriter("C:/AAA/f.txt");
 
        int c=0;//读取到字符的个数
        char[] cs=new char[10];//每次读取的内容放入该数组中
 
        while( (c=fr.read(cs)) !=-1 ){
            fw.write(cs,0,c);
            fw.flush(); //刷新
        }
 
        fw.close();//关闭资源
        fr.close();
    }
}

2.1字节输出流--OutputStream

它可以对任意文件进行操作，对文件进行输出操作。以字节为单位。 它是所有字节输出流的父类，FileOutputStream

//测试字节输出流
@Test
public void testOutStream() throws Exception{
OutputStream os=new FileOutputStream("D:/AAA/f.txt");
String str="abcd";
//把字符串转换为字节数组.
byte[] bytes = str.getBytes();

os.write(bytes);

os.flush();
os.close();

}

 

2.2字节输入流---InputStream

它可以对任意文件进行读操作 ，以字节为单位，它是所有字节输入流的父类，子类有FileInputStream

//一次一次的读取
@Test
public void testInputStream() throws Exception{
InputStream is=new FileInputStream("D:/AAA/f.txt");

byte [] bytes=new byte[3];
int c1=is.read(bytes);//一次读取三个字节 并把读取的内容放入字节数组中 返回读取到字节的个数
System.out.println(bytes+"=============>个数："+c1);

c1=is.read(bytes);
System.out.println(bytes+"=============>个数："+c1);

c1=is.read(bytes);
System.out.println(bytes+"=============>个数："+c1);

}


//如果文件中内容非常大 使用循环来读取
@Test
public void testInputStream2() throws Exception{
InputStream is=new FileInputStream("D:/AAA/f.txt");
byte [] bytes=new byte[300];
int c=0; //读取到的个数
while( (c=is.read(bytes))!=-1 ){
//把byte数组转换为字符串
String str=new String(bytes,0,c);
System.out.println(str);
}

is.close();
}

 

2.3使用字节输入和输出流完成文件的复制功能:

@Test
public void testCopy() throws Exception{
//创建字节输入流 视频
InputStream is=new FileInputStream("D:/AAA/56.jpg");
//字节输出流
OutputStream fos=new FileOutputStream("C:/AAA/57.jpg");
byte[] bytes=new byte[10];
int c=0;

while( (c=is.read(bytes)) !=-1 ){
fos.write(bytes,0,c);
}

is.close();
fos.close();
}

 

3.1缓存流是在基础流[InputStream OutputStream Reader Writer]之上 添加了一个缓存池功能.

BufferInutStream BufferOutputStream BufferReader BufferWriter 提高IO的效率，降低IO的次数

@Test
public void TestBuffer() throws Exception{
OutputStream out=new FileOutputStream("D:/AAA/g.txt");

BufferedOutputStream bos=new BufferedOutputStream(out);//缓存流要作用再基础流上
String str="abcdefhijglmn";

byte[] bytes = str.getBytes();
bos.write(bytes); //因为你写的内容 暂时放入缓存池中 并没有直接放入文件中。 所以文件中没有你的内容

bos.flush();//刷新缓存池---把池子中的内容输入到文件上

bos.close(); //关闭----先刷新缓冲池 再关闭流资源

}

 

4.1对象流--对java对象进行IO操作

为什么需要对象流？
我们现在操作IO流的时候 都是将字符串读写操作 可不可以将java对象在文件中进行读写呢？ 可以的 Student st=new Student();对象
将java对象进行读写操作 意义在于持久化信息 例如： 游戏存档

因为运行的时候 所有的数据都是在运行内存中的 持久化 将运行内存的数据 保存到硬盘上 存档（写） 读档(读)

源代码

public class Role implements Serializable {
private String roleName;
private String level;//级别
private int id;
private String other;//其他属性

public Role(){

}

@Override
public String toString() {
return "Role{" +
"roleName='" + roleName + '\'' +
", level='" + level + '\'' +
", id=" + id +
", other='" + other + '\'' +
'}';
}

public Role(String roleName, String level, int id, String other) {
this.roleName = roleName;
this.level = level;
this.id = id;
this.other = other;
}
}

public class TestDemo2 {
//存档：----序列化:
@Test
public void testObjectStream() throws Exception{
OutputStream out=new FileOutputStream("D:/AAA/a.txt");
ObjectOutputStream os=new ObjectOutputStream(out);

//使用对象流调用输出方法 输出的类对象 该类必须实现Serializable 序列化接口
Role r=new Role("狄仁杰","6",001,"射手");
os.writeObject(r);
os.close();
}
//测试读档，反序列化
@Test
public void testObjectStream2() throws Exception{
InputStream input=new FileInputStream("D:/AAA/a.txt");
ObjectInputStream ois=new ObjectInputStream(input);
Object o = ois.readObject();

System.out.println(o);
ois.close();
}
}

 

运行结果图:

 

 

1. 序列化: 把内存中的java对象存储到磁盘[网盘]的过程。
---java对象所属的类必须实现序列化接口.implements Serializable
2. 反序列化: 把磁盘中的内容读取到java对象内存中的过程。