Java基础IO

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量476 收藏 1
点赞数 2
分类专栏： JavaWeb 文章标签： java 链表 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50302770/article/details/123327178
版权

文章目录

一、File文件操作类

1. File类的常用方法

在这里插入图片描述

2.相对路径和绝对路径

  • 绝对路径：从树型结构的角度来看，从根节点到这个节点的路径称之为绝对路径。
  • 相对路径：从树形结构的角度来看，从任何一个结点到目标节点的路径称之为相对路径。

3.使用File类递归打印文件目录列表

//遍历输出一个文件夹下所有的文件
public class IODemo1 {
    public static void main(String[] args) {
        File file =  new File("D:/work");
        listAll(file);
    }
    private static void listAll(File file){
            if(file.isDirectory()){
                File [] files=file.listFiles();
                for (File file2: files) {
                  listAll(file2);
                }
            }else {
                System.out.println(file);
            }
    }
}

二、IO流

1. IO流的概念

流：就像水流一样，一次可以读/写一个字节或多个字节
字节流：读写数据单位都是字节，读写二进制文件
字符流：读写数据的单位都是字符，读写文本文件

2. 复制字节流文件

步骤：

  • 创建字节流输入输出对象。
  • 读取字节流文件到磁盘。
  • 从磁盘写入到目标地址
  • 关闭文件（十分重要）

关闭文件十分的重要，每次一个进程打开一个文件都会占用文件描述表上的一个表项，一个进程可能对应多个PCB，（一个线程对应一个PCB）一个进程的若干PCB共享一个表，这个表项是有限的，当他满了的时候文件就打不开了。代码中每次打开一个文件本质上就是在文件描述符表中创建一个新的项，代码关闭一个项目，本质上就是白文件描述符表上的对应项删除。

1.0版本

/**
 * @ClassName IODemo2
 * @Description 字节流图片复制
 * @Author Rcy
 * @Data 2022/3/6 18:27
 */
public class IODemo2 {
    public static void main(String[] args) throws IOException {
        copyFile("D:/Test/666.jpg","D:/Test/8888.jpg");
    }
    private static void copyFile(String srcPath,String destPath) throws IOException {
        //1.先打开文件，创建InputStream和OutputStream对象
        FileInputStream fileInputStream =new FileInputStream(srcPath);
        FileOutputStream fileOutputStream = new FileOutputStream(destPath);
        //2.读取srcPath当中的内容
        //bytes相当于磁盘  一次读取1024个字节 这就是缓冲区
        byte [] bytes=new byte[1024];
        int len=-1;

        //3.将内容写入到destPath当中
        while((len=fileInputStream.read(bytes)) != -1){
            //如果len是-1就明读取结束了，然后写入，写入的长度是len的长度。
            fileOutputStream.write(bytes,0,len);
        }
        fileInputStream.close();
        fileOutputStream.close();
        System.out.println("文件复制成功");
    }
}

上述代码有一个致命的问题：他的close方法可能不会被调用。因为在运行中一旦触发了IOException异常，此时方法就会被立刻终止，从而导致下面的colse方法不能被调用。

改进：使用finally关键字修饰
2.0版本

private static void copyFile2(String srcPath,String destPath) {
        FileOutputStream fileOutputStream=null;
        FileInputStream fileInputStream = null;
        try {
            fileInputStream =new FileInputStream(srcPath);
            fileOutputStream = new FileOutputStream(destPath);
            //2.读取srcPath当中的内容
            //bytes相当于磁盘  一次读取1024个字节 这就是缓冲区
            byte [] bytes=new byte[1024];
            int len=-1;

            //3.将内容写入到destPath当中
            while((len=fileInputStream.read(bytes)) != -1){
                //如果len是-1就明读取结束了，然后写入，写入的长度是len的长度。
                fileOutputStream.write(bytes,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                //用if判断他是否初始化成功，若不成功可能会造成空指针异常。
                if(fileInputStream!=null){
                    fileInputStream.close();
                }
                if(fileOutputStream!=null){
                    fileOutputStream.close();
                    System.out.println("文件复制成功");
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }

上述代码还有一个问题，太丑了！
3.0版本


    private static void copyFile3(String srcPath,String destPath){
        //代码自动调用close方法。
        try(FileInputStream fileInputStream =new FileInputStream(srcPath);
            FileOutputStream fileOutputStream = new FileOutputStream(destPath)){
            byte [] bytes = new byte[1024];
            int len = -1;
            while((len=fileInputStream.read(bytes))!=-1) {
                fileOutputStream.write(bytes,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

BufferedInputStream和BufferedOutputStream类

这两个类自带缓冲区，什么是缓冲区呢？
缓冲区本质上是一片内存空间，其存在的意义就是提高读写效率。
其工作原理是因为程序访问内存要比访问磁盘快很多（3-4个数量级）。一次读1个数据读100次的效率要远远低于一次读100个数据。

下面是一段有无缓冲区的代码运行速度对比。

/**
 * @ClassName IODemo3
 * @Description 有无缓冲区对比
 * @Author Rcy
 * @Data 2022/3/7 16:31
 */
public class IODemo3 {
    public static void main(String[] args) {
        copyFile("D:/Test/666.jpg","D:/Test/888856.jpg");
        copyFile2("D:/Test/666.jpg","D:/Test/888856.jpg");
    }

    //不使用缓冲区
    public static void copyFile(String srcPath, String destPath){
        long begin = System.currentTimeMillis();
        try(FileInputStream fileInputStream = new FileInputStream(srcPath)){
            int len=-1;
            while ((len=fileInputStream.read())!=-1){

            }
        }catch (IOException e){
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("不使用缓冲区" + (end-begin)+"ms");
    }

    //使用缓冲区
    public static void copyFile2(String srcPath, String destPath){
        long begin = System.currentTimeMillis();
        try(BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream(srcPath));
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destPath))){
            int len=-1;
            while ((len=bufferedInputStream.read())!=-1){

            }
        }catch (IOException e){
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("使用缓冲区" + (end-begin)+"ms");
    }
}

在这里插入图片描述
可以看到两者速度差距达到100多倍！

3.复制字符流文件

字节流文件和字符流文件的复制操作基本相同，区别在于字符流文件复制的时候采用的是FileReader和FileWriter这两个类。

/**
 * @ClassName Demo4
 * @Description 字符流的复制操作
 * @Author Rcy
 * @Data 2022/3/7 17:28
 */
public class IODemo4 {
    public static void main(String[] args) {
        copyFile2("D:/Test/123.txt","D:/Test/321.txt");
    }

    //按照字符复制
    private static void copyFile(String srcPath, String descPath) {
        try(FileReader fileReader = new FileReader(srcPath);
            FileWriter fileWriter = new FileWriter(descPath)){
            int len=-1;
            char[] buffer = new char[1024];
            while((len=fileReader.read(buffer))!=-1){
                fileWriter.write(buffer,0,len);
            }
        }catch (IOException e){
                e.printStackTrace();
        }
    }
  }

字符流不仅可以一个字符一个字符的复制，还可以进行按行复制。

 private static void copyFile2(String srcPath, String descPath) {
        try(BufferedReader bufferedReader = new BufferedReader(new FileReader(srcPath));
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(descPath))){
            String len="";
            //readLine()表示读一行，读到换行符为止，如果文件读取完毕就会返回null
            while((len=bufferedReader.readLine())!=null){
                bufferedWriter.write(len);
                //因为他是按行读取的，所以他每次读都会少一个换行符，我们要手动加入这个换行符。
                bufferedWriter.write("\n");
            }
        }catch (IOException e){
            e.printStackTrace();
        }
     }

三、 序列化和反序列化

1.什么是序列化和反序列化

序列化： 对象的寿命通常随着生成该对象的程序的终止而终止，有时候需要把在内存中的各种对象的状态（也就是实例变量，不是方法）保存下来，并且可以在需要时再将对象恢复。虽然你可以用你自己的各种各样的方法来保存对象的状态，但是Java给你提供一种应该比你自己的好的保存对象状态的机制，那就是序列化（将一个对象保存到二进制bit流中）

反序列化： 把二进制的byte流还原回原来的对象。

序列化和反序列化最大的作用就是让对象能通过网络传输/能够在文件中保存。在这个过程中要保证“信息不丢失！”

2.使用ObjectOutputStream类序列化/反序列化java对象

序列化的类必须实现支持持久化存储的Serializable接口，Serializable就像一个通行证，只有拥有这个通行证jvm才让他持久化到磁盘中。

import java.io.*;

/**
 * @ClassName IODemo5
 * @Description TODO
 * @Author Rcy
 * @Data 2022/3/7 20:15
 */
 //Serializable显示说明这个类可以被序列化
  class Student implements Serializable{
    //网络传输反序列化的时候需要比对UID，相同才可以反序列化。
    //private static final long serialVersionUID = 123456789L;
     public String name;
     public int score;
     public int age;

     public  Student(){

     }
    public Student(String name, int score, int age) {
        this.name = name;
        this.score = score;
        this.age = age;
    }
}
public class IODemo5 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Student student = new Student("张三", 99, 20);
        //serializeStudent(student);
        System.out.println(deserializeStudent(student).name);
    }
    //序列化
    private static void serializeStudent(Student student) throws IOException {
      ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("d:/Test/hehe.txt"));
       // writeObject()继承序列化+写文件
       // Student student = new Student("张三", 99, 20);
      objectOutputStream.writeObject(student);
      objectOutputStream.close();
    }
      
    //反序列化
      private static Student deserializeStudent(Student student) throws IOException, ClassNotFoundException {
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("d:/Test/hehe.txt"));
            return (Student) objectInputStream.readObject();
        }
  }
3 ERROR（s）
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 776
consul官网地址。
java基础 IO
tengyuxin的博客
08-31 3976
之前自己学习Java是跳着学的，只有碰到业务问题，我才回来学习。这次就是碰到将pdf 转成图片 预览的问题，所以来补充基础。
Java基础——IO
qq_52519008的博客
10-01 2125
流（Stream），是一个抽象的概念，是指一连串的数据（字符或字节），是以先进先出的方式发送信息的通道。当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。
Java基础知识——JavaIO
热门推荐
weixin_45680007的博客
02-01 1万+
Java io IO的基本分类 同步和异步的区别：同步是线程去查看是否完成，异步是完成的数据去提醒线程已经完成 参考资料 data = socket.read();socket本意为套接字，为ip+端口，我理解为一个数据载体 (BIO)阻塞io：未请求到数据即让出cpu (NIO not block io)非阻塞io：在 while 循环中不断地去询问内核数据是否就绪，这样会导致 CPU 占用率非...
JAVA—IO流详解
weixin_48006490的博客
09-01 7753
IO:Input/Output即输入&输出，也称之为流（河流，水流），指的是数据从一个地点到另一个地点过程；对于计算机来说文件的拷贝过程，文件的编写保存，显示功能都是使用到IO；将数据的传输过程看做一个输入输出。现实角度考虑可以将耳朵作为输入流，将嘴巴当做输出流输入输出介质：文件网络键盘（输入）显示器（输出）
【JAVA基础】Java IO详解
qq_27198345的博客
09-01 980
Java IO
java基础 IO流
09-05
此文档属于本人当初学习java基础之IO流，所整理的文档。里面有字节流与字符流的比较，也有总结使用不同方式读取文档的demo。希望对你的学习有帮助，谢谢！
java基础IO
08-19
java基础，java入门，培训机构文档，非常适合初学者，拿出来共享下。
IO:java基础io流
03-21
IO java基础io流
java基础 io*jdbc*html
11-13
java基础 io*jdbc*html
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 395
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 468
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1494
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 659
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
Lambda表达式特点
weixin_57763462的博客
04-24 622
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 238
待更新。
迭代器模式
LuckFairyLuckBaby的博客
04-23 571
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 729
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
java io 基础
07-28
Java IO（Input/Output）是Java编程语言中用于处理输入和输出的基础库。它提供了一种方便的方式来读取和写入数据，从而与外部世界进行交互。 Java IO库包含多个类和接口，用于在不同的场景下处理输入和输出。这些类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

3 ERROR（s）

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值