Java笔记之IO流（二十六）

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

学习目录

一、基本介绍

1.基本概念

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

2.常用文件操作

序号操作基本格式
1根据路径构建一个File对象new File（String pathname）
2根据父目录文件+子路径构建new File（File parent，String child）
3根据父目录+子路径构建new File（String parent，String child）
4获取文件大小file.length()
5获取文件名file.getName()
6获取文件绝对路径file.getAbsolutePath()
7获取文件的父Filefile.getParent()
8判断是不是文件file.isFile()
9判断是不是目录file.isDirectory()
10判断文件是否存在file.exists()
11创建一级目录，返回值为布尔file.mkdir()
12创建多级目录，返回值为布尔file.mkdirs()
13删除空目录或文件file.delete()

目录本质也是文件，一种特殊的文件

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

public class test {
    public static void main(String[] args) throws InterruptedException {
        //操作1
        File file1 = new File("F:\\test1.txt");
        try {
            file1.createNewFile();
            System.out.println("文件1创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

        //操作2
        File file2 = new File("F:\\","test2.txt");
        try {
            file2.createNewFile();
            System.out.println("文件2创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

        //操作3
        File file3 = new File("F:/","test3.txt");
        try {
            file3.createNewFile();
            System.out.println("文件3创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

        //操作4-10
        System.out.println("test1.txt "+file1.length());
        System.out.println("test1.txt "+file1.getName());
        System.out.println("test1.txt "+file1.getAbsolutePath());
        System.out.println("test1.txt "+file1.getParent());
        System.out.println("test1.txt "+file1.isFile());
        System.out.println("test1.txt "+file1.isDirectory());
        System.out.println("test1.txt "+file1.exists());

        //操作11-13
        File file4 = new File("F:\\Test");
        System.out.println(file4.mkdir());
        System.out.println(file4.exists());

        File file5 = new File("F:\\Test1\\Demo");
        System.out.println(file5.mkdirs());
    }
}

二、IO流

1.基本概念

I/O：即是Input和Output的缩写，I/O技术是非常实用的技术，用于处理数据的传输。如读写文件，网络通讯等。
Java程序中，对于数据的输入/输出操作以“流（stream）”的方式进行。
java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据。

注意：文件流使用完以后，要记得关闭文件流，释放资源

IO流的分类

  1. 按操作数据单位分为：字节流（如：二进制文件）和字符流（如：文本文件）
  2. 按数据流的流向分为：输入流和输出流
  3. 按流的角色的不同分为：节点流、处理流和包装流
抽象基类字节流字符流
输入流InputStreamReader
输出流OutputStreamWriter

2.IO流常用的类

InputStream：直接输入流，抽象类是所有字节输入流的超类，下面是InputStream常用的子类

  1. FileInputStream：文件输入流
  2. BufferedInputStream：缓冲字节输入流
  3. ObjectInputStream：对象字节输入流

OutputStream：直接输出流，抽象类是所有字节输出流的超类，下面是OutputStream常用的子类

  1. FileOutputStream：文件输出流
  2. BufferedOutputStream：缓冲字节输出流
  3. ObjectOutputStream：对象字节输出流

三、FileInputStream和FileOutputStream

1.FileInputStream

FileInputStream： 即文件输入流，从文件系统中的某个文件中获得输入字节，方法使用如下图，具体详细的使用说明请看API

在这里插入图片描述

举例说明：对一个文件进行读取，并输出在控制台

import java.io.FileInputStream;
import java.io.IOException;

public class test {
    public static void main(String[] args) throws InterruptedException {
        FileInputStream();
        System.out.println();
        FileInputStream1();
    }

    /**
     * 读取指定路径文件的内容,
     * 使用read方法是一个字节一个字节的读取，效率比较低
     */
    public static void FileInputStream(){
        String Path = "F:\\test.txt";
        int readData = 0;
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(Path);
            //read()方法，如果到达文件末尾则返回-1，表示读取完毕
            while ((readData = fileInputStream.read()) != -1){
                System.out.print((char)readData);   //转换为char显示
            }
        } catch (IOException e) {
            //原本异常为FileNotFoundException，这里设置为IOException，为扩大异常范围
            e.printStackTrace();
        }finally {
            //关闭文件流，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 使用read(byte[] b)方法，最多b.length个字节的数据读入一个byte数组中，效率比较高
     */
    public static void FileInputStream1(){
        String Path = "F:\\test.txt";
        int readlen = 0;
        FileInputStream fileInputStream = null;
        byte[] bytes = new byte[8]; //一次读取8个字节
        try {
            fileInputStream = new FileInputStream(Path);
            //read(byte[] b)方法，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。
            //如果读取正常，返回实际读取的字节数
            while ((readlen = fileInputStream.read(bytes)) != -1){
                System.out.print(new String(bytes,0,readlen));   //转换为char显示
            }
        } catch (IOException e) {
            //原本异常为FileNotFoundException，这里设置为IOException，为扩大异常范围
            e.printStackTrace();
        }finally {
            //关闭文件流，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.FileOutputStream

FileOutputStream： 即文件输出流，是用于将数据写入 File 或 FileDescriptor 的输出流。

在这里插入图片描述

举例说明：对一个文件进行写入数据，如果没有则创建

import java.io.FileOutputStream;
import java.io.IOException;

public class test {
    public static void main(String[] args) throws InterruptedException {
        FileOutputStream();
//        FileOutputStream1();
//        FileOutputStream2();
    }

    /**
     * 将数据写到文件中，如果没有则创建
     * 写入一个字节
     * new FileOutputStream(filePath)会对原来的内容进行覆盖
     */
    public static void FileOutputStream(){
        String Path = "F:\\test1.txt";
        FileOutputStream fileOutputStream = null;
        try {
            //写入一个字节
            fileOutputStream = new FileOutputStream(Path);
            fileOutputStream.write('J');
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 将数据写到文件中，如果没有则创建
     * 写入多个字节
     * new FileOutputStream(filePath)会对原来的内容进行覆盖
     */
    public static void FileOutputStream1(){
        String Path = "F:\\test1.txt";
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(Path);
            //写入多个字节
            String s = "java";
            //getBytes() 可以把字符串转换为字符数组
            fileOutputStream.write(s.getBytes(),0,s.length());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 将数据写到文件中，如果没有则创建
     * 写入多个字节，进行内容追加
     * new FileOutputStream(filePath,true)会对原来的内容进行追加
     */
    public static void FileOutputStream2(){
        String Path = "F:\\test1.txt";
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(Path,true);
            String s = " scala";
            //getBytes() 可以把字符串转换为字符数组
            fileOutputStream.write(s.getBytes(),0,s.length());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.综合小案例-文件复制

将F盘下的java.jpeg图片复制为java2.jpeg

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

public class test {
    public static void main(String[] args) throws InterruptedException {
        String Path = "F:\\java.jpeg";
        String newPath = "F:\\java2.jpeg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {
            fileInputStream = new FileInputStream(Path);
            fileOutputStream = new FileOutputStream(newPath);

            //定义一个数据，进行多个字节读取，提供效率
            byte[] bytes = new byte[1024];
            int readlen = 0;
            while ((readlen = fileInputStream.read(bytes)) != -1 ){
                //注意：这里复制的是图片，一定要用write(byte[] b, int off, int len)，而不能用write(byte[] b)，否则写入的就不是以前的图片了
                fileOutputStream.write(bytes,0,readlen);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (fileInputStream != null){
                    fileInputStream.close();
                }
                if (fileOutputStream != null){
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

四、FileReader和FileWriter

1.FileReader

常用操作

序号基本格式操作
1new FileReader（File/String）构造器
2read（）每次读取单个字符，返回该字符，如果到文件末尾返回-1
3read（char[]）批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1
4new String（char[]）将char[]转换成String
5new String（char[],off,len）将char[]的指定部分转换成String

快速入门
要求：使用FileReader从文本文件中读取内容，并显示

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

public class test {
    public static void main(String[] args) throws InterruptedException {
//        FileReader();
        FileReader1();
    }

    /**
     * 单字符读取
     */
    public static void FileReader(){
        String path = "F:\\test.txt";
        FileReader fileReader = null;
        int data = 0;
        try {
            fileReader = new FileReader(path);
            while ((data = fileReader.read()) != -1){
                System.out.print((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 批量读取多个字符到数组
     */
    public static void FileReader1(){
        String path = "F:\\test.txt";
        FileReader fileReader = null;
        char[] chars= new char[8];
        int readlen = 0;
        try {
            fileReader = new FileReader(path);
            while ((readlen = fileReader.read(chars)) != -1){
                System.out.print(new String(chars,0,readlen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

显示如下：
在这里插入图片描述

2.FileWriter

常用操作

序号基本格式操作
1new FileWriter（File/String）覆盖模式，相当于流的指针在首段
2new FileWriter（File/String，true）追加模式，相当于流的指针在尾端
3write（int）写入单个字符
4write（char[]）写入指定数组
5write（char[]，off，len）写入指定数组的指定部分
6write（String）写入整个字符串
7write（String，off，len）写入字符串的指定部分

相关API：String类：toCharArray：将String转换成char[]
注意：
FileWriter使用后，必须要关闭（close）或刷新（flush），否则写入不到指定的文件

快速入门
要求：使用不同格式write，向文件中写入数据

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

public class test {
    public static void main(String[] args) throws InterruptedException {
//        FileWriter();
//        FileWriter1();
//        FileWriter2();
//        FileWriter3();
        FileWriter4();
    }

    /**
     * 写入单个字符
     */
    public static void FileWriter(){
        String path = "F:\\test1.txt";
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter(path);  //覆盖的模式
            fileWriter.write('H');
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 写入指定数组
     */
    public static void FileWriter1(){
        String path = "F:\\test1.txt";
        FileWriter fileWriter = null;
        char[] chars = {'a','b','c'};
        try {
            fileWriter = new FileWriter(path);  //覆盖的模式
            fileWriter.write(chars);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 写入指定数组的指定部分
     */
    public static void FileWriter2(){
        String path = "F:\\test1.txt";
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter(path);  //覆盖的模式
            fileWriter.write("java你好".toCharArray(),0,5);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 写入整个字符串
     */
    public static void FileWriter3(){
        String path = "F:\\test1.txt";
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter(path);  //覆盖的模式
            fileWriter.write("java你好,我是scala");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 写入字符串的指定部分
     */
    public static void FileWriter4(){
        String path = "F:\\test1.txt";
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter(path);  //覆盖的模式
            fileWriter.write("我是java",0,2);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
王博1999
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java基础篇之IO流，动力节点老杜详细笔记
qq_45769329的博客
01-21 1180
详细讲解IO流，主要聚焦如何使用、掌握常用方法等
java学习笔记之IO流总结(一）
不懂编程的程序员都是在耍流氓
10-14 3621
输入输出作为所有程序都必需的部分   对于我们的java学习有特别重要的意义，以至于博主辛苦看了三天的流分布，跟大家分享一下 一.首先我们说一下io流的概念 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。简单的说这就是计算机传输数据的方式  输入流主要体现在我们从
Java周记（第四周）IO流
qq_62243433的博客
05-23 222
1.IO流概述： 1.IO：输入、输出（Input、Output） 2.流：是一种抽象概念，是对数据传输的总称，也就是说数据在设备之间的传输称为流，流的本质是数据传输 3.IO流就是用来处理设备之间数据传输问题的 常见的应用：文件复制、文件上传、文件下载 2.IO流的分类 1.按照数据的流向： 输入流：读数据 输出流：写数据 2.按照数据类型来分： 字节流：字节输入流、字节输出流 字符流：字符输入流、字符输出流 如果数据通过Window自带的记事本打开，我们还可以读懂里面的内容，就是
（Java笔记）IO流的六类16种流方式
张松的博客
04-26 2947
IO流的四大类16种流方式
java IO流之BufferedReader和BufferedWriter
学习笔记，相关教程 分享
04-03 6203
笑霸能看懂的学习笔记
javaIO流之转换流
恒二哥的博客
05-19 2172
转换流可以将一个字节流包装成字符流，或者将一个字符流包装成字节流。这种转换通常用于处理文本数据，如读取文本文件或将数据从网络传输到应用程序。转换流主要有两种类型：InputStreamReader 和 OutputStreamWriter。InputStreamReader 将一个字节输入流转换为一个字符输入流，而 OutputStreamWriter 将一个字节输出流转换为一个字符输出流。它们使用指定的字符集将字节流和字符流之间进行转换。常用的字符集包括 UTF-8、GBK、ISO-8859-1 等。
java中的io流
m0_66689823的博客
07-19 9736
流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出 。
java笔记二（IO流与json）
百般回首曾经的相遇，留下的只是一缕残忆
04-07 1890
注：导包问题自行解决 模板类 /* 商家，设计商家模型 */ public class Merchant { //商家名称 private String name; //商家地址 private String address; //商家菜品 private Dishes[] dishes; //经度 private double l...
Java笔记_18(IO流)
weixin_74155781的博客
05-08 1668
IO流存储和读取数据的解决方案用于读写文件中的数据（可以读写文件，或网络中的数据…)纯文本文件：用windows系统自带的记事本打开并且能读懂的文件。
【Java笔记】IO流-数据流（DataInputStream 和 DataOutputStream）
lijibai_的博客
04-23 3031
为了方便地操作 Java 语言的基本数据类型和 String 的数据，可以使用数据流 数据流的使用 数据流有两个类：DataInputStream 和 DataOutputStream，分别 “套接” 在 InputStream 和 OutputStream 子类的流上 数据流用于读取或写入基本数据类型的变量或字符串 注：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致 代码举例 import org.junit.Test; import java.io.*; public
java IO流详细笔记
07-12
Java IO流详解
Java 的 IO流笔记.md
03-08
Java IO流的笔记，写了常用的类和方法的示例，以及部分Apache的commons-io的IO类，如果没有积分，可以到我的博客里查看下载
Java学习笔记之IO流
08-11
详细介绍了IO的用法，基本实现原理，并介绍了序列化与反序列化的实现方法。谢谢
java IO流学习笔记
12-12
java IO流学习笔记
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案
2301_80653026的博客
05-29 1353
CAS全称Compare and swap，字面意思:”比较并交换“，它是一条 CPU 并发原语，用于判断内存中某个值是否为预期值，如果是则更改为新的值，这个过程是原子的。全称 Compare and swap, 即 “比较并交换”. 相当于通过一个原子的操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤. 本质上需要 CPU 指令的支撑。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 870
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1192
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 484
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
黑马程序员io流笔记
07-29
根据提供的引用内容，IO流是Java中用于处理输入和输出的机制。在Java中，有字节流和字符流两种类型的IO流。字节流是以字节为单位进行操作的，而字符流是以字符为单位进行操作的。字节流更加方便且在处理图片、音频等...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

王博1999

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

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

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

打赏作者

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

抵扣说明：

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

余额充值