Java进阶——IO流（I）

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量350 收藏
点赞数
分类专栏： 视频笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51929833/article/details/128222377
版权

文章目录

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），字符流（按字符）
  • 按数据流的流向不同分为：输入流，输出流
  • 按流的角色不同分为：节点流，处理流/包装流
(抽象基类)字节流字符流
输入流InputStreamReader
输出流OutputStreamWriter

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小豪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java进阶学习—IO流
m0_74270947的博客
12-20 114
一、IO概述： (1)数据写到文件中，实现数据永久化存储 (2)读取文件中已经存在的数据 1、I:硬盘的数据读取到内存 2、O:内存的数据写入到硬盘 3、IO流分类： (1)按流向分：输入流、输出流 (2)按数据类型分：字节流、字符流 二、字节流：操作所有类型的文件(包括音频、视频) 1、字节流写数据步骤： (1)创建字节输出流对象 notes：文件不存在就创建、文件存在就清空 (2)写数据 note：写出的整数实际是整数在码表上对应的字母 (3)释放资源 note：每次使
Java IO流（超详细！）
m0_67392010的博客
06-08 3564
通过IO可以完成硬盘文件的读和写。以内存作为参照物：这种流是万能的，什么类型的文件都可以读取。包括： 等…eg. 假设文件file1.txt，采用字节流的话是这样读的： a中国bc张三fe 第一次读：一个字节，正好读到’a’ 第二次读：一个字节，正好读到’中’字符的一半。 第三次读：一个字节，正好读到’中’字符的另外一半。这种流是为了方便读取 而存在的，这种流不能读取：图片、声音、视频等文件。只能读取 ，连word文件都无法读取。注意： 纯文本文件，不单单是.txt文件，还包括 .java、.ini、.p
10-java进阶-IO流1
08-03
1.创建文件，文件位置为相较于当前工程的位置，不然会报FileNotFoundException 2.新建流:FileReader reader = new F
Java IO 流操作详解
BXA
05-27 1851
Java IO流提供了一种可以对数据进行输入输出的机制。可以把它比作是一条河流从源头流向目标地，由源文件输入到程序再由程序输出到目标文件。IO即Input/Output顾名思义就是数据的输入输出，在Java中指的是java.io包中的类库，提供了一系列操作数据输入与输出的类和接口。Java NIO（New IO）是JDK1.4引入的新的IO API，能够以更高效的方式进行文件、网络读写等各种I/O操作。
Java IO流操作 (I)
Rick的博客
03-14 182
1.FileWriter 写数据---输出流---由控制台向文件中写数据 import java.io.FileWriter; import java.io.IOException; /* * 写数据---输出流---由控制台向文件中写数据 */ public class IOFileWriterdemo01 { public static void main(String[...
JAVA进阶之IO
yzpbright的博客
07-31 168
参考： Java IO流史上最全详细汇总，确定不来瞅瞅吗！！(内容稍长，建议亲这边收藏慢慢看哦。)
Java进阶之IO框架
yzpbright的博客
08-07 192
IO框架 Java IO的学习是一件非常艰巨的任务。 它的挑战是来自于要覆盖所有的可能性。不仅存在各种I/O源端还有想要和他通信的接收端（文件/控制台/网络链接），而且还需要以不同的方式与他们进行通信（顺序/随机存取/缓冲/二进制/字符/行/字 等等）这些情况综合起来就给我们带来了大量的学习任务，大量的类需要学习。 我们要学会所有的这些java 的IO是很难的，因为我们没有构建一个关于IO的体系，要构建这个体系又需要深入理解IO库的演进过程，所以，我们如果缺乏历史的眼光，很快我们会对什么时候应该使用IO中的
JAVA基本IO操作
Z372819342的博客
05-04 750
JAVA 基本IO操作
java——IO流技术.pdf
04-03
javaIO流
Java进阶IO流讲义大全.docx
09-09
Java进阶IO流讲义大全.docx
Java进阶教程之IO基础
09-04
主要介绍了Java进阶教程之IO基础,这里只是对Java IO的基本介绍,包含读取和写入等操作,需要的朋友可以参考下
java基础——IO流及File-RandomAccessFile对象.docx
01-02
java基础——IO流及File-RandomAccessFile对象.docx
【Java 基础篇】Java IO流详解
繁依Fanyi的博客
06-26 2531
本文详细介绍了Java IO流的原理、分类、使用场景和常用类。IO流提供了一种统一的方式来处理输入和输出操作，无论是从文件、网络连接还是内存中。通过使用不同的IO流类，我们可以实现数据的读取和写入，满足不同的需求。希望本文对你理解和应用Java IO流有所帮助！
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1008
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 804
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 296
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 260
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
Java面向数据编程1.1版本
极道Jdon的技术博客
05-28 510
虽然将所有这些方法都集中在 Item 上似乎是合理的，因为它们都与购买流程交互，但增加了 predictLowStock（与基于机器学习的预购系统交互）、registerForRecommendations（另一个 ML 系统，这次是物品建议）和 reportPurchase（登记潜在危险物品的购买），让我们怀疑所有这些操作是否真的属于同一个接口。：这是不同上下文场景的方式，放在Item一个类或接口中肯定不对，如同学生借书，将借书这个动作建模在学生这个类或接口一样，借书时一种具体场景。
java多线程创建方式
weixin_57763462的博客
05-28 1076
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
java测试题io流
04-21
Java中的IO流是用于处理输入和输出的机制。它提供了一种方便的方式来读取和写入数据。下面是一些关于Java IO流的测试题： 1. 什么是Java中的IO流？ 2. Java中的IO流分为几种类型？分别是什么？ 3. 什么是字节流和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

java小豪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值