小王Java学习打卡day14——IO流

最新推荐文章于 2024-11-13 17:07:29 发布
最新推荐文章于 2024-11-13 17:07:29 发布
阅读量280 收藏
点赞数
分类专栏： 学习打卡 文章标签： java 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w1099938370/article/details/125038539
版权
本文介绍了Java中的IO流概念，包括输入输出、File类、四大基本流、缓冲流和字符编码。讲解了如何使用File类操作文件路径，通过实例展示了文件流的使用，如读写文件、文件拷贝。还涵盖了缓冲区的重要性以及如何使用缓冲流提高性能。此外，文章还提及了字符编码的历史发展和常用编码集，以及序列化和打印流的基本概念。
摘要由CSDN通过智能技术生成

IO 的概述

  1. 概述：数据存到内存里面，程序运行结束之后，数据就没了，此时就需要把数据持久化存储起来
  2. input 输入（读）
  3. output输出（写）
  4. java.io 包中

File 类

  1. file类：文件目录的抽象

  2. 文件路径的分隔符：

    • windows：使用 \ 来进行路径分割，在java中使用 \\ 来分割， ； 来分割属性
    • unix： / 分割路径， ： 分割属性（要区分大小写）
    • windows 不区分大小写

  3. 获取当前系统的分隔符：

    • 分割属性的获取
    //获取分割属性
String s = File.pathSeparator;
System.out.println(s);
char pathSeparatorChar = File.pathSeparatorChar;
System.out.println(pathSeparatorChar);
//获取斜线的分隔符
String separator = File.separator;
System.out.println(separator);

  4. 获取路径和名称

    • 相对路径

    • 绝对路径：从根目录直接能进入的路径

      //获取绝对路径
public String getAbsolutePath() {
    return fs.resolve(this);
}
//获取绝对路径的文件
public File getAbsoluteFile() {}
//获取路径
public String getPath() {}
//获取上级目录
public String getParent() {}

//获取文件名称
public String getName() {}

      1. 如何创建一个文件，以及基本方法

        • ​ 构造器
        //直接使用路径创建文件
public File(String pathname) {}
//根据绝对路径创建文件
File file = new File("D:\\software\\hello.txt");
//先创建目录对象，然后再创建文件
File file1 = new File("D:\\software");
File file2 = new File(file1, "hello.txt");
//目录和文件分成两个参数传
File file3 = new File("D:\\software", "hello.text");
  • ​ 方法的学习
//判断是不是文件
public boolean isFile() {}
//判断是不是目录
 public boolean isDirectory() {}
//删除文件
  public boolean delete() {}
//判断文件或目录是否存在
   public boolean exists() {}
//创建目录（存在就不创建）
 public boolean mkdir() {}
//查看当前目录所有的文件
  public String[] list() {}
//列出所有的文件对象
public File[] listFiles() {
//在目录里创建新的文件
File file4 = new File("D:\\software\\我爱祖国.mp3");
boolean newFile = file4.createNewFile();
//重命名
public boolean renameTo(File dest) {}

  1. 需求：列出指定目录中的所有文件，包括子文件夹中的所有文件及其子文件。递归

    • 回顾递归（5的阶乘）
    public static void main(String[] args) {
    //5的阶乘
    int i = recursion(5);
    System.out.println(i);
}
public static int recursion(int a) {
    if (a == 1) {
        return 1;
    } else {
        return a * recursion(a - 1);
    }
}

需求：列出指定目录中的所有文件，包括子文件夹中的所有文件及其子文件。递归

public static void main(String[] args) {
    File file = new File("C:\\Users\\wxj\\Desktop\\Study change life\\day13");
   fileRecursion(file);

}

public static void fileRecursion(File file){
    //第一层级
    File[] files = file.listFiles();
    System.out.println(file.getAbsolutePath());
    for (File f : files) {
        if (f.isFile()){
            System.out.println("  -"+f.getName());
        }else {
            fileRecursion(f);
        }
    }

需求：批量修改文件名

public static void main(String[] args) {
    File file = new File("C:\\Users\\wxj\\Desktop\\Study change life\\day13\\day13_work");
    File[] files = file.listFiles();
    //需要修改的文件名字符串
    String deleteName = "呃呃呃饿";
    for (File f : files) {
        //删选包含字符串的文件
        if (f.getName().contains(deleteName)){
            //使用replace进行更改名字
            String replace = f.getName().replace(deleteName, "");
            File renameFile = new File(file, replace);
            f.renameTo(renameFile);
        }
    }
}

需求：打印指定目录下面 .java 结尾的资源

  • 文件过滤器

    FilenameFilter filenameFilter = new FilenameFilter() {
    //匿名内部类
    @Override
    public boolean accept(File dir, String name) {
        return false;
    }
};

  • 需求实现

public static void main(String[] args) {
    File file = new File("D:\\java\\29");
    File[] files = file.listFiles(new FilenameFilter() {
        @Override
        public boolean accept(File dir, String name) {
            return new File(file,name).isFile() && name.endsWith(".java");
        }
    });
    for (File f : files) {
        System.out.println(f.getName());
    }
}

IO流

  1. I O 设备

    • 输入：键盘，鼠标，麦克风
    • 输出：显示器，打印机，音响

  2. 程序

    • 输入：从磁盘到内存里
    • 输出：从内存写数据到磁盘文件里

  3. IO 流的分类

  • 按流向（输入输出流）
  • 按数据单位（字符字节流）
  • 四大基本流：
    • 字节输出流
    • 字节输入流
    • 字符输出流
    • 字符输入流
  • 注意：不管是什么流，最后都需要关闭资源。close，如果不关闭，磁盘文件一直被占用，不能够删除和修改。**

文件流

  1. 字节流

    • FileOutputStream 文件输出流

      • 需求：读 C:\Users\wxj\Desktop\Study change life\day14\task02\任务作业.txt 文件，并且写入 wangxiaoj进去

        File file = new File("C:\\Users\\wxj\\Desktop\\Study change life\\day14\\task02\\任务作业.txt");
FileOutputStream stream = new FileOutputStream(file,true);
stream.write("wangxiaoj".getBytes());
stream.close();

      • 需求：C:\Users\wxj\Desktop\Study change life\day14\task02\任务作业.txt 读出来，在程序中打印

        File file = new File("C:\\Users\\wxj\\Desktop\\Study change life\\day14\\task02\\任务作业.txt");
//创建输入流
FileInputStream inputStream = new FileInputStream(file);
//创建数组，设置每次最大读取空间
byte[] bytes = new byte[1024];
System.out.println(Arrays.toString(bytes));
int length = -1;
//循环读，读一次只能读一个
while ((length = inputStream.read(bytes) )!= -1){
    String str = new String(bytes, 0, length);
    System.out.println(str);
}
 inputStream.close();

        • 使用字节流实现文件的拷贝

          public static void main(String[] args) throws IOException {
    //源文件
    File srcFile = new File("C:\\Users\\wxj\\Desktop\\Study change life\\day14\\task02\\任务作业.txt");
    //目标文件
    File deskFile = new File("C:\\Users\\wxj\\Desktop\\Study change life\\day14\\task02\\拷贝目标文件.txt");
    //源文件 输入流
    FileInputStream srcInputStream = new FileInputStream(srcFile);
    //目标文件输出流
    FileOutputStream deskOutputStream = new FileOutputStream(deskFile);

    byte[] buffer = new byte[10];
    int length= -1;// 表示读了多少个字节，  -1 表示还没有读完
    //不等于 -1 表示还没有读完，就一直读下去
    while ((length=srcInputStream.read(buffer))!=-1){
        //把读到的写到目标文件里面
        System.out.println(Arrays.toString(buffer));
        deskOutputStream.write(buffer);
    }
    //关闭资源
    srcInputStream.close();
    deskOutputStream.close();
}

  2. 字符流

    • FileReader （字符输入流）
public static void main(String[] args) throws IOException {
    File file = new File("C:\\Users\\wxj\\Desktop\\Study change life\\day14\\task02\\任务作业.txt");
    FileReader fileReader = new FileReader(file);
    char[] chars = new char[12];
    int length = -1;
    while ((length = fileReader.read(chars))!= -1){
        String s = String.valueOf(chars);
        System.out.println(s);
    }
    fileReader.close();
  • FileWrite （字符输出流）
    public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\wxj\\Desktop\\Study change life\\day14\\task02\\任务作业.txt");
        FileWriter fileWriter = new FileWriter(file,true);、//没有加true则会覆盖之前的数据
        fileWriter.write("这是新写进来的数据：376783487<br>");
        fileWriter.close();
    }
  1. 字节流和字符流的选择
  • 二进制文件，图片，视频，音频，必须使用字节流
  • 文本文件可以使用字符流
  • 不清楚就全部使用字节流

  1. fiush 刷新操作

    • 计算机直接访问外部的磁盘文件，比直接操作内存会慢很多，可以设置一个缓冲区，写的时候先写到内存里面，达一个设定值才写到磁盘，减少与与磁盘的交互。
    • 使用缓冲区的意义：
      • 提高cpu的使用率
      • 回滚写入的数据
    • 操作系统使用 -1 来表示磁盘文件 结尾的标志
    • io 是最影响程序性能的。缓冲区一般设置使用容量的整数倍，可以提高io性能

  2. try()… catch() 资源自动释放

缓冲流

  1. 就是个包装流，目的是起到缓冲的作用，提升io性能

  2. 字节流的缓冲流

    • BufferedInputStream //缓冲输入流
BufferedOutputStream //缓冲输出流

  3. 字符流的缓冲流

  • BufferedReader 字符输入缓冲流
  • BufferedWriter 字符输出缓冲流
  1. 目的：习惯的去操作我们的byte char数组，先与内存进行交互，然后达到一定量之后，再去与磁盘交互。减少与磁盘交互的次数，提高性能。

字符编码

  1. 字符编码的发展流程

    • 一开始只能认识数字 0 1，后来可以识别一些字母 （ASCII 美国标准信息交换码）

    • 随着计算机的普及，很多国家将自己的字符引入计算机，汉字，一个字节的存储范围太小，两个字节来存储汉字

      中文的二进制最高位规定为1 （负数） GB2312编码 —GBK

    • 汉字在其他国家的编码问题，别人不认识，显示出乱码的情况。需要统一的编码， Unicode编码

  2. 常用的字符编码集

    • ASCII：占一个字节，包含128个符号，不能表示汉字
    • ISO-8859-1（lantin-1）占一个字节：收录西欧的语言，不能表示汉字
    • GB-312（ANSI）：占两个字节
    • UTF-8：（存储汉字占三个字节）针对Unicode可变长字符编码，成为后来的通用编码（IETF要求所有的互联网协议都使用）

  3. 字符的编码以及解码（使用相同的编码规范）

    • 编码：把字符串转换成byte数组
    • 解码：把byte数组转换成字符串

合并流

SequenceInputStream

//创建两个流对象，以供合并
FileInputStream inputStream1 = new FileInputStream("D:\\D-Test\\aaaa.txt");
FileInputStream inputStream2 = new FileInputStream("D:\\D-Test\\bbbb.txt");
//调用合并流方法
SequenceInputStream sequenceInputStream = new SequenceInputStream(inputStream1,inputStream2);
//读取
byte[] bytes = new byte[1200];
int length = -1;
while ((length = sequenceInputStream.read(bytes))!=-1){
    System.out.println(new String(bytes, 0, length));
}

sequenceInputStream.close();

对象流

  1. 序列化以及反序列化

    • 序列化：把我们堆内存中的java对象数据，存储到磁盘中去，或者给其他的网络节点使用
    • 反序列化：把磁盘文件的数据恢复成一个java对象的过程

  2. 为什么我们要使用序列化？

    • 在分布式系统里面，数据的共享都需要使用序列化，（redis）
    • 服务钝化：把不常用的对象存储到磁盘中去，节约内存开销
    • 使用json传输的时候

  3. 做序列化和反序列化的要求：必须去实现java.io.Serializable 接口

    • java中大多数的类都先实现了序列化接口的

  4. 对象流

    • 序列化：ObjectInputStream
    • 反序列化：ObjectOutputStream
     public static void main(String[] args) throws IOException, ClassNotFoundException {
        File file = new File("D:\\D-Test\\obj.txt");
//        writeObject(file);
        readObject(file);
    }
    //序列化操作
    public static void writeObject(File file) throws IOException {
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(file));
        outputStream.writeObject(new Student("王曼七",24));
        outputStream.close();
    }

    //反序列化操作
    public static void readObject(File file) throws IOException, ClassNotFoundException {
        ObjectInputStream InputStream = new ObjectInputStream(new FileInputStream(file));
        Object o = InputStream.readObject();
        Student stu = (Student)o;
        System.out.println(stu.getName() + "," + stu.getAge());
        InputStream.close();
    }

  5. 常见错误（NotSerializableException）实现序列化接口

  6. 序列化版本号的作用：相当于一个密码，引入了版本号，避免因为升级导致版本不兼容的问题。

打印流

  1. PrintStream 字节流

  2. PrintWrite 字符流

  3. 格式化输出

    String name;
int age;
Object[] obj = {"王曼七",24};
//设置格式
String s = "姓名：%s ，年龄：%d ";
 System.out.printf(s,obj);//姓名：王曼七 ，年龄：24

Properties 加载配置文件

    public static void main(String[] args) throws IOException {
        //创建properties对象
        Properties properties = new Properties();
        //创建一个输入流
        FileInputStream inputStream = new FileInputStream
                ("D:\\idea_workspace\\day16\\src\\cn\\xiaojun\\practice\\conf\\db.properties");
        properties.load(inputStream);
        System.out.printf("url:%s",properties.getProperty("url"));
        System.out.printf("用户名:%s",properties.getProperty("username"));
        System.out.printf("密码:%s",properties.getProperty("password"));
    }

NIO

  1. jdk1.4开始提供，可以把一块磁盘文件映射到内存中去，java.nio
  2. 应用领域（云服务器中）
  3. jdk1.7提供了一个工具类---->files(操作文件类)
public static void main(String[] args) throws IOException {
    Files.copy(Paths.get("D:\\D-Test\\obj.txt"),
            new FileOutputStream("D:\\D-Test\\obj333.txt"));
}
  1. 与io的不同点
    • Channels Buffers（通道缓冲区）：通过通道和缓冲区
    • 异步（Asynchronous）:线程读取通道数据到缓冲区时，线程可以做其他事情
    • 选择器(Selectors): 用来监听多个通道，单线程可以去监听多个数据通道
小王Java学习打卡day18——多线程
w1099938370的博客
05-29 275
多线程 多行并发 需求：一边打LOL，一边听网易云音乐 问题：程序间断的问题 多进程或者多线程来解决 并行：多件事情在同一时间点发生 并发：多件事情在同一时间段发生，同一时间段运行多个程序 单个cpu：一个时间点只能执行一个程序，可以交替执行 线程与进程 进程：内存中的应用程序，每个进程都是一块独立的内存空间 线程：进程中执行任务的单元，一个进程可以同时并发的运行多个线程 进程：进程有独立的内存空间，一个进程中至少有一个线程 线程：栈空间是独立的，堆空间是共享的 多线程的优势：因为堆空间是共享
小王Java学习打卡day07——模板方法设计，接口，多态
w1099938370的博客
05-07 196
接口 什么是接口？ 硬件接口：两个硬件设备之间的连接方式，包含数据传输协议 软件接口：程序代码，包含一种规范 统一接口以后的意义：根据规范设计产品，可以做到适配性 type-c JAVA接口 定义：需要使用 interface 关键字 public interface interfaceDemo { } ​ 接口的注意点： 接口里面只能定义抽象方法。 接口里的方法默认是public 和 static 修饰符 接口里面不能有方法主体，因为..
IO流目录
qq_32486015的博客
03-22 205
IO流分类了解（概念）以及文本输入输出流 字符集，编码解码 文件的拷贝以及封装成工具类 字节数组流 处理流（概念）以及装饰器模式 处理流之缓冲流 对接流 处理流之数据流 处理流之对象流 处理流之转换流 处理流之打印流 文件分割、合并、序列流 IO-Commons-fileUtils ...
Java IO流详解
热门推荐
ss810540895的博客
04-21 1万+
原文 Java IO流详解 1.什么是IO Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 IO又分为流IO（java.io）和块IO(java.nio) Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的
JAVA IO——IO原理和分类
weixin_59796310的博客
08-15 453
JAVA IO——IO原理和分类
JAVA IO——获取文件信息
weixin_59796310的博客
08-13 1237
保姆级教学——JAVA IO——获取文件信息
JAVA IO——常用的类
weixin_59796310的博客
08-16 463
JAVA IO——常用的类
JAVA IO——FileOutputStream
weixin_59796310的博客
08-17 2559
保姆级教学——JAVA IO——FileOutputStream
JAVA IO——文件拷贝
weixin_59796310的博客
08-19 755
保姆级教学 JAVA IO——文件拷贝
JAVA IO——文件字符说明
weixin_59796310的博客
08-23 397
JAVA IO——文件字符说明
Day22_7 Java学习之对象数组
weixin_43717536的博客
07-22 1万+
一、先定义，再开辟数组空间类名称对象数组名[]=null;对象数组名=new类名称[长度];二、定义并开辟数组空间类名称对象数组名[]=new类名称[长度];特别注意在声明对象数组后，必须对每个数组成员进行实例化之后才能直接使用，否则报空指针异常！Studentstudent[]={newStudent("小王",20),newStudent("小明",20),newStudent("小红",20)}；...
C/JAVA 每日一练——零基础学习动态规划
weixin_59796310的博客
02-15 2718
C/JAVA 每日一练——零基础学习动态规划
Java中文件IO流.pdf
07-11
Java 中文件 IO 流 Java 中文件 IO 流是指 Java 语言中对文件的输入输出操作，通过定义文件流来实现文件的读写操作。文件流是指在程序中用于文件输入输出的对象， Java 中提供了多种文件流类型，包括 InputStream ...
java学习路线（项目开发、web方向、大数据方向）.rar
04-29
- **IO流**：理解输入/输出流的概念，学习文件操作、网络通信以及对象序列化。 - **多线程**：学习线程的创建、同步、并发控制，理解线程池的概念。 - **反射机制**：掌握动态加载类、获取类信息、创建对象、调用...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 306
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Java基础07
m0_74977981的博客
11-11 700
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
SpringBoot(五)
最新发布
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 797
Rest请求处理
SpringBoot 实现图片加水印
心猿意码
11-11 407
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 448
顺序算法题----力扣刷题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值