AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java进阶——IO流（I）

2022-12-07 92
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 流：数据在数据源（文件）和程序（内存）之间经历的路径输入流：数据从数据源（文件）到程序（内存）的路径输入流：数据从程序（内存）到数据源（文件）的路径

IO流

一、文件

1.1、文件流

文件在程序中是以流的形式来操作的

image-20221113155034580

  • 流：数据在数据源（文件）和程序（内存）之间经历的路径
  • 输入流：数据从数据源（文件）到程序（内存）的路径
  • 输入流：数据从程序（内存）到数据源（文件）的路径

1.2、常用的文件操作

1.2.1、创建文件对象相关构造和方法

  • new File(String pathname) // 根据路径构建一个File对象
  • new File(File parent, String child) // 根据父目录文件+子路径构建
  • new File(String parent, String child) // 根据父目录+子路径构建
import org.junit.jupiter.api.Test;

import java.io.File;
import java.io.IOException;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/11/13
 * @description 实操创建文件的三种方法
 */
public class FileCreate {
    public static void main(String[] args) {

    }

    /**
     * 方式一  new File(String pathname) // 根据路径构建一个File对象
     */
    @Test
    public void create01() {
        String filePath = "F:\\file\\test01.txt";
        File file = new File(filePath);
        try {
            file.createNewFile();
            System.out.println("文件创建成功！！！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * 方式二  new File(File parent, String child) // 根据父目录文件+子路径构建
     */
    @Test
    public void create02() {
        File parentFile = new File("F:\\file\\");
        String fileName = "test02.txt";
        File file = new File(parentFile, fileName);
        try {
            file.createNewFile();
            System.out.println("文件创建成功！！！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 方式三  new File(String parent, String child)  // 根据父目录+子路径构建
     */
    @Test
    public void create03() {
        String parentPath = "F:\\";
        String filePath = "file\\test03.txt";
        File file = new File(parentPath, filePath);

        try {
            file.createNewFile();
            System.out.println("文件创建成功！！！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1.2.2、获取文件的相关信息

  • getName：获取文件的名字
  • getAbsolutePath：获取文件的绝对路径
  • getParent：获得文件的父级目录
  • length：获取文件的大小（返回字节数）
  • exists：判断文件是否存在
  • isFile：判断是否是一个文件
  • isDirectory：是不是一个目录
import org.junit.jupiter.api.Test;

import java.io.File;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/11/13
 * @description 获取文件的基本信息
 */
public class FileInformation {
    public static void main(String[] args) {

    }
    /**
     * 获取文件信息
     */
    @Test
    public void info() {
        // 先创建文件对象
        File file = new File("F:\\file\\test01.txt");

        // 调用相应的方法，得到对应的信息
        System.out.println("文件名 = " + file.getName());
        System.out.println("文件绝对路径 = " + file.getAbsolutePath());
        System.out.println("文件父级目录 = " + file.getParent());
        System.out.println("文件大小(字节) = " + file.length());
        // true
        System.out.println("文件是否存在 = " + file.exists());
        // true
        System.out.println("是不是一个文件 = " + file.isFile());
        // false
        System.out.println("是不是一个目录 = " + file.isDirectory());
    }
}

运行结果：

image-20221113165110285

1.2.3、目录的操作和文件删除

  • mkdir创建一级目录
  • mkdirs创建多级目录
  • delete删除空目录或文件
import org.junit.jupiter.api.Test;

import java.io.File;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/11/13
 * @description 目录操作
 */
public class Directory_ {
    public static void main(String[] args) {

    }

    /**
     * 判断 F:\\file\\test01.txt 是否存在，如果存在就删除
     */
    @Test
    public void m1() {
        String filePath = "f:\\file\\test01.txt";
        File file  = new File(filePath);

        if (file.exists()) {
            if (file.delete()) {
                System.out.println(filePath + "删除成功");
            } else {
                System.out.println(filePath + "删除失败");
            }
        } else {
            System.out.println("该文件不存在...");
        }
    }


    /**
     * 判断 F:\\file1 是否存在，如果存在就删除
     */
    @Test
    public void m2() {
        String filePath = "f:\\file1";
        File file  = new File(filePath);

        if (file.exists()) {
            if (file.delete()) {
                System.out.println(filePath + "删除成功");
            } else {
                System.out.println(filePath + "删除失败");
            }
        } else {
            System.out.println("该目录不存在...");
        }
    }

    /**
     * 判断 F:\\file1\\a\\b 是否存在，如果存在就提示已存在，否则就创建
     */
    @Test
    public void m3() {
        String directoryPath = "f:\\file1\\a\\b";
        File file  = new File(directoryPath);

        if (file.exists()) {
            System.out.println(directoryPath + "该目录已存在！！！");
        } else {
            if (file.mkdirs()) {
                System.out.println(directoryPath + "该目录创建成功！！！");
            } else {
                System.out.println(directoryPath + "该目录创建失败！！！");
            }
        }
    }
}

二、IO流原理及流的分类

2.1、Java IO流的原理

  • I/O 是Input/Output的缩写，I/O技术是非常使用的技术，用于处理数据传输。
  • Java程序中，对于数据的输入/输出操作以”流(stream)“的方式进行
  • java.io包下提供了各种”流“类接口，用以获取不同种类的数据，并通过方法输入或输出数据

image-20221113172149298

2.2、流的分类

  • 按操作数据单位不同分为：字节流（8bit），字符流（按字符）
  • 按数据流的流向不同分为：输入流，输出流
  • 按流的角色不同分为：节点流，处理流/包装流
(抽象基类) 字节流 字符流
输入流 InputStream Reader
输出流 OutputStream Writer

2.3、IO流常用的类

2.3.1、InputStream：字节输入流

  • InputStream抽象类是所有类字节输入流的超类

  • InputStream常用的子类

    • FileInputStream：文件输入流
    • BufferedInputStream：缓冲字节输入流
    • ObjectInputStream：对象字节输入流

image-20221113203033594

FileInputStream常用的方法

image-20221113203513517

代码演示：

import org.junit.jupiter.api.Test;

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

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/11/13
 * @description FileInputStream的使用
 */
public class FileInputStream_ {
    public static void main(String[] args) {

    }

    /**
     * 演示读取文件
     * read只能读取单个字节
     * -> 使用read(byte[] b)读取
     */
    @Test
    public void readFile1() {
        String filePath = "F:\\file\\hello.txt";
        FileInputStream fileInputStream = null;
        try {
            // 创建FileInputStream 对象，用于读取文件
            fileInputStream = new FileInputStream(filePath);
            int readData = 0;
            while ((readData = fileInputStream.read()) != -1) {
                // 转成char显示
                System.out.print((char) readData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭文件流，释放资源
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    /**
     * 使用read(byte[] b)读取文件，提高效率
     */
    @Test
    public void readFile2() {
        String filePath = "F:\\file\\hello.txt";
        FileInputStream fileInputStream = null;
        try {
            // 创建FileInputStream 对象，用于读取文件
            fileInputStream = new FileInputStream(filePath);
            int readLen = 0;
            // 定义字节数组
            byte[] bytes = new byte[10];
            // 如果返回-1，表示读取完毕
            // 如果读取正常，返回实际读取的字节数
            while ((readLen = fileInputStream.read(bytes)) != -1) {
                // 转成char显示
                System.out.print(new String(bytes, 0, readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭文件流，释放资源
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.3.2、FileOutputStream常用的方法

  • 创建FileOutputStream两种方式

    • 1.如果 new FileOutputStream(filePath) 创建方式，当写入内容时，会覆盖原来的内容
    • 2.如果 new FileOutputStream(filePath, true) 创建方式，当写入内容时，会追加到文件的末尾
  • fileOutputStream.write('H')写入一个字节
  • fileOutputStream.write(str.getBytes()); 写入字符串 str.getBytes() 可以把字符串 -> 字节数组
  • write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
  • fileOutputStream.write(str.getBytes(), 0, str.length());

image-20221113210454966

FileOutputStream的类图

image-20221113210822132

演示代码：

import org.junit.jupiter.api.Test;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/11/13
 * @description OutputStream的演示
 */
public class FileOutputStream01 {
    public static void main(String[] args) {

    }

    /**
     * 演示使用FileOutputStream 将数据写到文件中，
     * 如果该文件不存在，则创建该文件
     */
    @Test
    public void writeFile() {
        // 创建 FileOutputStream对象
        String filePath = "F:\\file\\a.txt";
        FileOutputStream fileOutputStream = null;
        try {
            // 得到FileOutputStream 对象
            // 1.如果 new FileOutputStream(filePath) 创建方式，当写入内容时，会覆盖原来的内容
            // 2.如果 new FileOutputStream(filePath, true) 创建方式，当写入内容时，会追加到文件的末尾
            fileOutputStream = new FileOutputStream(filePath);
            // 写入一个字节
            // fileOutputStream.write('H');
            // 写入字符串
            String str = "Hello World!";
            // str.getBytes() 可以把字符串 -> 字节数组
            // fileOutputStream.write(str.getBytes());
            /*write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。  */
            fileOutputStream.write(str.getBytes(), 0, str.length());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}
FileInputStream和FileOutputStream综合演示

文件拷贝：

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

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/11/14
 * @description 文件拷贝
 */
public class FileCopy {
    public static void main(String[] args) {
        // 完成文件拷贝
        // 1.创建文件的输入流，将文件读入到程序
        // 2.创建文件的输出流，将读取到的文件数据，写入到指定的文件

        String srcFilePath = "源文件夹路径";
        String destFilePath = "目标盘文件路径";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {
            fileInputStream = new FileInputStream(srcFilePath);
            fileOutputStream = new FileOutputStream(destFilePath);
            // 定义一个字节数组
            byte[] bytes = new byte[1024];
            int readLen = 0;
            while ((readLen = fileInputStream.read(bytes)) != -1) {
                // 读取到后，就写入文件 通过 fileOutputStream
                fileOutputStream.write(bytes, 0, readLen);
            }
            System.out.println("拷贝成功！！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                // 关闭输入和输出流，关闭资源
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

2.3.3、FileReader和FileWriter

FileReader和FileWriter是字符流，即按照字符来操作io

1、FileReader

image-20221114143335097

相关方法：

  • new FileReader(String/File)
  • read:每次读取单个字符，返回该字符，如果到文件末尾返回-1
  • read(char[])：批量读取多个字符到数组，返回读取到的字符数组，如果到文件末尾返回-1

相关API：

  • new String(char[]): 将char[]转换成String
  • new String(char[], off, len): 将char[] 的指定部分转换成String

代码演示：

import org.junit.jupiter.api.Test;

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

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/11/14
 * @description 字符输入流
 */
public class FileReader_ {
    public static void main(String[] args) {

    }


    /**
     * 单个字符读取文件
     */
    @Test
    public void readFile1() {
        String filePath = "F:\\file\\story.txt";
        FileReader fileReader = null;
        int dataLen = 0;
        try {
            // 1.创建FileReader对象
            fileReader = new FileReader(filePath);
            // 循环读取 单个字符读取
            while ((dataLen = fileReader.read()) != -1) {
                System.out.print((char) dataLen);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    /**
     * 字符数组读取文件
     */
    @Test
    public void readFile2() {
        String filePath = "F:\\file\\story.txt";
        FileReader fileReader = null;
        int readLen = 0;
        char[] chars = new char[8];
        try {
            // 1.创建FileReader对象
            fileReader = new FileReader(filePath);
            // 循环读取 单个字符读取
            while ((readLen = fileReader.read(chars)) != -1) {
                System.out.print(new String(chars, 0, readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}
2、FileWriter

关系类图：

image-20221114142435501

相关方法：

  • new FileWriter(File/String)：覆盖模式，相当于流的指针在首端
  • new FileWriter(File/String, true)：追加模式，相当于流的指针在尾端
  • writer(int)：写入单个字符
  • writer(char[])：写入指定数组
  • writer(char[], off, len)：写入指定数组的指定部分
  • writer(String)：写入整个字符串
  • writer(string, off, len)：写入字符串的指定部分

注意：==FileWriter使用后必须要关闭(close)或刷新(flush)，否则写入不到指定的文件。==

代码演示：

import org.junit.jupiter.api.Test;

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

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/11/14
 * @description 文件写入
 */
public class FileWwriter_ {
    public static void main(String[] args) {

    }

    @Test
    public void fileWriter1() {
        String filePath = "F:\\file\\note.txt";
        // 创建FileWriter对象
        FileWriter fileWriter = null;
        char[] chars = {'a', 'b', 'c',};
        try {
            fileWriter = new FileWriter(filePath);
            // 写入单个字符
            fileWriter.write('H');
            // 写入指定数组
            fileWriter.write(chars);
            // 写入指定数组的指定部分
            fileWriter.write("天苍苍，野茫茫".toCharArray(), 0, 3);
            // 写入整个字符串
            fileWriter.write("你好信阳~");
            // 写入字符串的指定部分
            fileWriter.write("上海北京", 0, 2);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileWriter != null) {
                    fileWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
文章标签：
Java
API
关键词：
Java IO
io java
Java进阶
io进阶
Java进阶io
java小豪
目录
相关文章
Java开发者
|
29天前
|
Java
java 中 IO 流
Java中的IO流是用于处理输入输出操作的机制，主要包括字节流和字符流两大类。字节流以8位字节为单位处理数据，如FileInputStream和FileOutputStream；字符流以16位Unicode字符为单位，如FileReader和FileWriter。这些流提供了读写文件、网络传输等基本功能。
Java开发者
50 9
java冯坚持
|
2月前
|
存储 缓存 Java
java基础：IO流 理论与代码示例（详解、idea设置统一utf-8编码问题）
这篇文章详细介绍了Java中的IO流，包括字符与字节的概念、编码格式、File类的使用、IO流的分类和原理，以及通过代码示例展示了各种流的应用，如节点流、处理流、缓存流、转换流、对象流和随机访问文件流。同时，还探讨了IDEA中设置项目编码格式的方法，以及如何处理序列化和反序列化问题。
java冯坚持
91 1
java基础：IO流 理论与代码示例（详解、idea设置统一utf-8编码问题）
程序员小海绵
|
3月前
|
安全 Java API
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射（2023版）
String常量池、String、StringBuffer、Stringbuilder有什么区别、List与Set的区别、ArrayList和LinkedList的区别、HashMap底层原理、ConcurrentHashMap、HashMap和Hashtable的区别、泛型擦除、ABA问题、IO多路复用、BIO、NIO、O、异常处理机制、反射
程序员小海绵
65 3
土木林森
|
2月前
|
Java 数据处理 开发者
揭秘Java IO流：字节流与字符流的神秘面纱！
揭秘Java IO流：字节流与字符流的神秘面纱！
土木林森
43 1
土木林森
|
2月前
|
自然语言处理 Java 数据处理
Java IO流全解析：字节流和字符流的区别与联系！
Java IO流全解析：字节流和字符流的区别与联系！
土木林森
110 1
Java开发者
|
3月前
|
Java 大数据 API
Java 流(Stream)、文件(File)和IO的区别
Java中的流（Stream）、文件（File）和输入/输出（I/O）是处理数据的关键概念。`File`类用于基本文件操作，如创建、删除和检查文件；流则提供了数据读写的抽象机制，适用于文件、内存和网络等多种数据源；I/O涵盖更广泛的输入输出操作，包括文件I/O、网络通信等，并支持异常处理和缓冲等功能。实际开发中，这三者常结合使用，以实现高效的数据处理。例如，`File`用于管理文件路径，`Stream`用于读写数据，I/O则处理复杂的输入输出需求。
Java开发者
246 12
john散漫
|
2月前
|
Java
Java 中 IO 流的分类详解
【10月更文挑战第10天】不同类型的 IO 流具有不同的特点和适用场景，我们可以根据具体的需求选择合适的流来进行数据的输入和输出操作。在实际应用中，还可以通过组合使用多种流来实现更复杂的功能。
john散漫
66 0
椰椰椰耶
|
2月前
|
存储 Java 程序员
【Java】文件IO
【Java】文件IO
椰椰椰耶
42 0
小白学大数据
|
3月前
|
数据采集 Java 数据挖掘
Java IO异常处理：在Web爬虫开发中的实践
Java IO异常处理：在Web爬虫开发中的实践
小白学大数据
49 5
路边两盏灯
|
4月前
|
NoSQL Java Redis
【Azure Spring Cloud】Java Spring Cloud 应用部署到Azure上后，发现大量的 java.lang.NullPointerException: null at io.lettuce.core.protocol.CommandHandler.writeSingleCommand(CommandHandler.java:426) at ... 异常
【Azure Spring Cloud】Java Spring Cloud 应用部署到Azure上后，发现大量的 java.lang.NullPointerException: null at io.lettuce.core.protocol.CommandHandler.writeSingleCommand(CommandHandler.java:426) at ... 异常
路边两盏灯
49 0

热门文章

最新文章

  • 1
    升级到MySQL 8.4，MySQL启动报错：io_setup() failed with EAGAIN
  • 2
    南大通用GBase 8a配置gcware日志等级，减少日志输出，节省磁盘IO
  • 3
    Java volatile关键字：你真的懂了吗？
  • 4
    java小工具util系列2：字符串工具
  • 5
    Java爬虫：数据采集的强大工具
  • 6
    Java多线程并发编程：同步机制与实践应用
  • 7
    Java中的异常处理：从基础到高级
  • 8
    深入理解Java异常处理机制
  • 9
    Liunx部署java项目Tomcat、Redis、Mysql教程
  • 10
    Java爬虫：深入解析商品详情的利器
  • 1
    【Bug合集】——Java大小写引起传参失败，获取值为null的解决方案
    20
  • 2
    JavaEE初阶——初识EE（Java诞生背景，CPU详解）
    13
  • 3
    反射-----浅解析（Java）
    13
  • 4
    Java—多线程实现生产消费者
    21
  • 5
    Java使用sql查询mongodb
    23
  • 6
    Java最新图形化界面开发技术——JavaFx教程（含UI控件用法介绍、属性绑定、事件监听、FXML）
    65
  • 7
    Java中的算法优化与复杂度分析
    15
  • 8
    Java的基础概念一
    20
  • 9
    Java基础-常用API-Object类
    28
  • 10
    Java多线程是什么
    23

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • 如何通过 Serverless 提高 Java 微服务治理效
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • 多IO线程优化版

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)