Java IO流

ChinaJDK

于 2023-04-01 19:07:58 发布

阅读量113

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/ChinaJDK/article/details/129857721

版权

在这里插入图片描述

IO流的分类

①按流向：输入流，输出流
②按数据不同，字节流，字符流(字符流操作文本文件如.txt .java 字节流操作非文本文件如.ovi .jpg .mp3)
③按角色不同: 节点流处理流

IO的体系结构

在这里插入图片描述

@Test
    public void test01(){
        String src="";
        String dest="";
        copyFile(src,dest);
    }

    //使用缓冲流完成非文本文件的传输
    public void copyFile(String src,String dest){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.创建FileInputStream的实例，同时打开指定文件
            FileInputStream fis = new FileInputStream(src);

            //2.创建FileInputStream的实例，并同时打开指定文件
            FileOutputStream fos = new FileOutputStream(dest);

            //3.创建BufferedInputStream包装对应节点流，用于提高效率
            bis = new BufferedInputStream(fis);

            //4.创建BufferedOutputStream包装对应的节点流，用于提高效率
            bos = new BufferedOutputStream(fos);

            //5.读取指定文件内容
            byte[] b = new byte[1024];
            int len=0;
            while ((len=bis.read(b))!=-1){
                //6.将指定的内容写到目标地点
                bos.write(b,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bos!=null){
                //7.关闭流
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bis!=null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

//使用缓冲文件完成文本文件的复制
    @Test
    public void test04(){
        String src="";
        String dest="";
        copyFile(src,dest);

    }
    public void copyFile(String src,String dest){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //1.创建FileReader的实例，并同时打开指定文件
            FileReader fr = new FileReader(src);
            //2.创建FileWriter的实例，并同时打开指定文件
            FileWriter fw = new FileWriter(dest);
            //3.创建BufferedReader包装对应节点流，用于提高效率
            br = new BufferedReader(fr);
            //4.创建BufferedWriter包装对应节点流，用于提高效率
            bw = new BufferedWriter(fw);
            //5.读取指定文件内容
            String str=null;
            while ((str=br.readLine())!=null){
                //6.将指定内容写到目标地点去
                bw.write(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bw!=null){
                //7.关闭流
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

对象流

ObjectInputStream和ObjectOutputStream

对象的序列化

将内存中的对象永久的以二进制形式保存到磁盘中
①创建节点流对象
②(可选) 创建缓冲流包装节点流，用于提高效率
③创建对象流包装对应的缓冲流，用于完成序列化
④通过wirteXXX()方法完成序列化
⑤序列化对象的类必须实现java.io.serializable接口
⑥提供序列号private static final long serialVersionUID= ;

//序列化
    @Test
    public void test1(){
        ObjectOutputStream oos = null;
        try {
            String str="abcde";
            int num=100;

            boolean boo=true;
            FileOutputStream fos = new FileOutputStream("");
            oos = new ObjectOutputStream(fos);

            oos.writeUTF(str);
            oos.writeInt(num);
            oos.writeBoolean(boo);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

对象的反序列化

将磁盘中的对象读取
①transient修饰的属性不会被序列化
②static修饰的属性不会被序列化（属于类，不属于对象）

//反序列化
    @Test
    public void test2(){
        ObjectInputStream ois = null;
        try {
            //1.创建FileInputStream的实例，同时打开指定文件
            FileInputStream fis = new FileInputStream("");
            //2.创建BufferedInputStream包装对应节点流，用于提高效率
            BufferedInputStream bis = new BufferedInputStream(fis);
            //3.创建ObjectInputStream的实例，包装对应的缓冲流，用于反序列化
            ois = new ObjectInputStream(bis);
            //4.读取指定文件的内容
            String str = ois.readUTF();
            int num = ois.readInt();
            boolean boo = ois.readBoolean();
            System.out.println(str);
            System.out.println(num);
            System.out.println(boo);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ois!=null){
                //关闭流
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

public class test01 {
    //对象的序列化
    @Test
    public void test01(){
        ObjectOutputStream oos = null;
        try {
            Person p1 = new Person("张三", 18);
            Person p2 = new Person("yhf", 19);
            Person p3 = new Person("天帝", 20);

            FileOutputStream fos = new FileOutputStream("");
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            oos = new ObjectOutputStream(bos);

            oos.writeObject(p1);
            oos.writeObject(p2);
            oos.writeObject(p3);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //对象的反序列化
    @Test
    public void test02(){
        ObjectInputStream ois = null;
        try {
            FileInputStream fis = new FileInputStream("");
            BufferedInputStream bis = new BufferedInputStream(fis);
            ois = new ObjectInputStream(bis);

            Person p1 = (Person) ois.readObject();
            Person p2 = (Person) ois.readObject();
            Person p3 = (Person) ois.readObject();

            System.out.println(p1);
            System.out.println(p2);
            System.out.println(p3);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class Person implements Serializable {
    private String name;
    private Integer age;
}

其他IO流

控制台IO

System.in:标准的输入流
System.out:标准的输出流
system.err:标准的错误输出流

打印流

PrintStream & PrintWriter

转换流

InputStreamReader和OutputStreamWriter

编码:字符串->字节数组
解码:字节数组->字符串

  //编码
    @Test
    public void test2() throws IOException {
        String str="yhf  天下第一";
        FileOutputStream fos = new FileOutputStream("");
        OutputStreamWriter osw = new OutputStreamWriter(fos);
        BufferedWriter bw = new BufferedWriter(osw);

        bw.write(str);
        bw.close();
    }

  //解码
    @Test
    public void test3() throws IOException {
        FileInputStream fis = new FileInputStream("");
        //字节流转字符流
        InputStreamReader isr = new InputStreamReader(fis);
        BufferedReader br = new BufferedReader(isr);
        String str=null;
        while ((str=br.readLine())!=null){
            System.out.println(str);
        }
        br.close();
    }

java.io.File类

表示目录文件，提供了一些用于操作文件和目录的基本方法，如新建删除。重命名，若需要操作文件内容，File对象无能为力，若需要操作文件内容，需要使用IO流，因此通常使用File对象和IO流的配合操作文件内容。

public class test07 {
    //访问文件名
    @Test
    public void test1(){
        File file = new File("");
        File file2 = new File("");

        System.out.println(file.getName());
        System.out.println(file.getPath());
        System.out.println(file.getAbsoluteFile());
        System.out.println(file.getAbsolutePath());
        System.out.println(file.getPath());

        boolean bo = file.renameTo(file2);//重命名(file必须存在，file2必须不存在)
        System.out.println(bo);
    }
    //文件检测
    @Test
    public void test02(){
        File f1 = new File("");
        System.out.println(f1.exists());
        System.out.println(f1.canRead());
        System.out.println(f1.canWrite());
        System.out.println(f1.isFile());
        System.out.println(f1.isDirectory());//是否是目录
    }
    //获取常规文件信息
    @Test
    public void test03(){
        File f1 = new File("");
        long millis = f1.lastModified();//文件最后修改日期(毫秒)
        System.out.println(millis);
        Date date = new Date(millis);
        System.out.println(date);

        long l = f1.length();
        System.out.println(l);//文件大小(目录没有大小，必须求出文件大小总和)
    }
    //文件操作
    @Test
    public void test04() throws IOException {
        File f1 = new File("");
        if (f1.exists()){
            System.out.println(f1.createNewFile());//创建文件
        }
        //如果是文件夹，要清空里面文件，才能成功
        System.out.println(f1.delete());
    }
    //文件夹操作
    @Test
    public void test05(){
        File f1 = new File("");
        System.out.println(f1.mkdir());//创建文件夹
        System.out.println(f1.mkdirs());//创建一连串文件夹

        //列出文件夹中所有文件String类型的列表
        String[] list = f1.list();
        for (String s:list) {
            System.out.println(s);
        }

        //获取文件夹的所有文件对象
        File[] files = f1.listFiles();
        for (File file : files) {
            System.out.println(file.getName()+","+file.getPath());
        }
    }
}