IO流

1.分类：

按照数据的流向

输入流：读数据

输出流：写数据
按照数据类型来分

字节流

字节输入流；字节输出流

字符流

字符输入流；字符输出流
IO流分类一般按照数据类型来分
打开记事本，能读懂里面的内容，就使用字符流

否则使用字节流，如果不确定，那就字节流，这个是万能流。
硬盘-------->内存：输入流-读数据 ..... 读到内存
硬盘<--------内存：输出流-写数据 ......写到硬盘

字节流抽象基类
- inputStream: 这个抽象类是表示字节输入流的所有类的超类
- outputStream:这个抽象类是表示字节输出流的所有类的超类
- 子类特点：子类名称都是以其父类名字作为类名的后缀。

*字节流

1.字节缓冲流

BufferOutputStream:
BufferInputStream:
字节缓冲流仅仅提供缓冲区

2.字节流：输入输出流和缓冲流

package com.yang.io;

import java.io.*;

//练习
public class Demo12 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();
//        method1();//共耗时408298时间
//        method2();//共耗时516时间
//        method3();//共耗时407时间
        method4();//共耗时94时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时"+(endTime-startTime)+"时间");

    }
    //字节缓冲流一次读取一个字节数组
    public static void method4() throws IOException{
        //缓冲流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\Study\\files\\javaSe\\hh.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\Study\\files\\gg.avi"));
        //读数据
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys)) != -1){
            //写数据
            bos.write(bys,0,len);

        }
        //关闭流
        bis.close();
        bos.close();
    }
    //字节缓冲流一次读取一个字节
    public static void method3() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\Study\\files\\javaSe\\hh.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\Study\\files\\gg.avi"));
        int by;
        while ((by=bis.read())!=-1){
            bos.write(by);
        }
        bis.close();
        bos.close();

    }

    //一次读写一个数组
    public static void method2() throws IOException{
        FileInputStream fis = new FileInputStream("D:\\Study\\files\\javaSe\\hh.avi");
        FileOutputStream fos = new FileOutputStream("D:\\Study\\files\\gg.avi");
        byte[] bys = new byte[1024];
        int len;
        while((len=fis.read(bys))!=-1){
            fos.write(bys,0,len);
        }

        fis.close();
        fos.close();
    }

    //一次读写一个字节
    public static void method1() throws IOException{
        FileInputStream fis = new FileInputStream("D:\\Study\\files\\javaSe\\hh.avi");
        FileOutputStream fos = new FileOutputStream("D:\\Study\\files\\gg.avi");
        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }
        fis.close();
        fos.close();
    }
}

3.异常

package com.yang.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

//复制文本文件 读-->写
//读-FileInputStream 写-FileOutputStream
public class Demo09 {
    public static void main(String[] args)  {

        //创建读的对象
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("D:\\Study\\files\\java.txt");
            fos = new FileOutputStream("D:\\Study\\files\\fos.txt");
            int by;
            //读数据
            while ((by=fis.read())!=-1){
                //写数据
                fos.write(by);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis!=null && fos!=null){//提升代码的健壮性
                try {
                    //关闭流
                    fis.close();
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

*字符流

1.字符流：底层还是字节流

package com.yang.io;

import java.io.*;

//字符流读写数据
public class Demo13 {
    public static void main(String[] args) throws IOException {
        //创建字符流 读对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("basicGrammar\\Demo12.java"));
        //创建字符流 写对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("basicGrammar\\osw.java"));
        //读数据
//        int ch;
//        while((ch=isr.read())!=-1){
//            osw.write(ch);
//        }
        char[] chs = new char[1024];
        int len;
        while((len= isr.read(chs))!=-1) {//while 循环
            //写数据
            osw.write(chs,0,len);
        }
        //刷新流
        osw.flush();
        //关闭流：先刷新，后关闭
        isr.close();
        osw.close();

    }
}

2.字符流：简化版FileRead -字符流的子类

package com.yang.io;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

//字符流简化版
//FileRead  FileWrite
public class Demo14 {
    public static void main(String[] args) throws IOException {
        //创建字符流对象
        FileReader fr = new FileReader("basicGrammar\\Demo12.java");
        FileWriter fw = new FileWriter("basicGrammar\\fw.java");
//        //读写数据
        int ch;
        while ((ch=fr.read())!=-1){
            fw.write(ch);
        }
//        char[] chs = new char[1024];
//        int len;
//        while ((len=fr.read(chs))!=-1){
//            fw.write(chs,0,len);
//        }
        //关闭流
        fr.close();
        fw.close();
    }
}

3.字符缓冲流

package com.yang.io;

import java.io.*;

//字符缓冲流
public class Demo15 {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲流对象
        BufferedReader br = new BufferedReader(new FileReader("basicGrammar\\Demo12.java"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("basicGrammar\\bw.java"));
        //读写数据
        //一次读写一个字符
        int ch;
        while ((ch=br.read())!=-1){
            bw.write(ch);
        }
        //一次读写一个字符数组
//        char[] chs = new char[1024];
//        int len;
//        while ((len=br.read(chs))!=-1){
//            bw.write(chs,0,len);
//        }
        //关闭流
        br.close();
        bw.close();
    }
}

4.字符流特有功能读写，常用的

package com.yang.io;

import java.io.*;
//常用的这个复制方法
//使用字符缓冲流特有功能复制文件
public class Demo16 {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲流对象
        BufferedReader br = new BufferedReader(new FileReader("basicGrammar\\box.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("basicGrammar\\bw.txt"));

        //使用特有功能读写 br.readLine();一次读一行，读到末尾返回null
        //                bw.newLine();//换行符

        String len;//字符串
        while ((len=br.readLine())!=null){//读一行
            bw.write(len);//对一行写一行
            bw.newLine();//换行符
            bw.flush();//刷新缓存到硬盘
        }
        //关闭流
        br.close();
        bw.close();
    }
}

*IO总结

1.字节流，万能流

输入的流：InputStream------> FileInputStream

------> BufferInputStream

输出的流：outputStream------>FileoutputStream

------> BufferoutputStream

4种方法：读写各两种

        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }

        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys)) != -1){
            //写数据
            bos.write(bys,0,len);

        }

2.字符流

输入的流：Reader---->InputStreamReade---------->FileReader

BufferedReader
输出的流：Writer----->outputStreamWriter-------->FileWriter

BufferedWriter

5种方法：

        int ch;
        while ((ch=fr.read())!=-1){
            fw.write(ch);
        }

        char[] chs = new char[1024];
        int len;
        while((len= isr.read(chs))!=-1) {//while 循环
            //写数据
            osw.write(chs,0,len);
        }

 String len;//字符串
        while ((len=br.readLine())!=null){
            bw.write(len);//写一行
            bw.newLine();//换行
            bw.flush();//刷新
        }

*补充：对象流

1.ObjectOutputStream

对象序列化流
ObjectOutputStream 将java对象的原始数据类型和图形写入OutputStream.可以使用ObjectInputStream 读取重构对象
一个对象想要被序列化，该对象所属的类必须实现--Serializable---接口
Serializable是一个标记接口，实现该接口，不需要重写任何方法。

package com.yang.io;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

//对象序列化流
public class Demo17 {
    public static void main(String[] args) throws IOException {
        //创建对象序列化流写入
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("basicGrammar\\oos.txt"));
        //创建对象
        Student s = new Student("林青霞",20);
        //写入对象
        oos.writeObject(s);
        //关闭流
        oos.close();
    }
}

2.ObjectInputStream

对象反序列化流

package com.yang.io;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

//对象反序列化流
public class Demo18 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建反序列化流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("basicGrammar\\oos.txt"));
        //读取对象。返回的是一个Object对象
        Object obj = ois.readObject();
        Student s = (Student) obj;//强转
        System.out.println(s.getName()+","+s.getAge());
        ois.close();
    }
}

发表于 2022-07-20 22:30 NewRoadWorld 阅读(69) 评论(0) 编辑收藏举报

搜索

常用链接

随笔档案

阅读排行榜

IO 流

IO流

1.分类：

*字节流

1.字节缓冲流

2.字节流：输入输出流和缓冲流

3.异常

*字符流

1.字符流：底层还是字节流

2.字符流：简化版FileRead -字符流的子类

3.字符缓冲流

4.字符流特有功能读写，常用的

*IO总结

1.字节流，万能流

4种方法：读写各两种

2.字符流

5种方法：

*补充：对象流

1.ObjectOutputStream

2.ObjectInputStream