IO流：文件处理（二）

最新推荐文章于 2024-06-04 23:11:16 发布
最新推荐文章于 2024-06-04 23:11:16 发布
阅读量145 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CWVCW/article/details/106054864
版权

摘要：字节流、字符流；图片、文本复制；IO流异常处理；Properties配置读写

一、IO的分类

1.输入流、输出流

以内存为基准

  • 输入流：内存 <----硬盘
  • 输出流：内存 ----->硬盘

2.字节流、字符流

  • 字节流：以字节为单位，读写数据的流
    主要处理图片、视频类
  • 字符流：以字符为单位，读写数据的流
    主要处理文本数据

二、字节流

顶级父类：

  • java.io.InputStream
  • java.io.OutputStream

常用实现类：

  • FileInputStream
  • FileOutputStream

(1)FileInputStream fis使用demo:

/**
 *  以字节流的形式读取文件：java.io.FileInputStream;
 *  （1）创建输入流：FileInputStream fis = new FileInputStream(File/pathName);
 *  （2）用字节数组作为缓存，读取文件：
 *      byte[] b = new byte[1024];
 *      while ((len = fis.read(b)) != -1){
 *             fos.write(b,0,len);  //将文件写到目标文件中。
 *      }
 *
 */
public class FISRead {
    public static void main(String[] args) throws IOException {
        createFile();
        writeFile();
        //read1();  // 通过fis.read()读取单个字节，并返回字节int形式
        read2();
    }

    /*以字节数组的形式：读文件*/
    private static void read2() throws IOException {
        FileInputStream fis = new FileInputStream("read.txt");
        int len ;  //每次读取有效字节的长度
        byte[] bytes = new byte[2];  // 定义字节数组，作为装字节数据的容器
        while ((len = fis.read(bytes)) != -1){
            System.out.println(new String(bytes,0,len));    //这里从0写到len长度的数据。因为最后一次读取的数据len有效长度不定。
        }

    }

}

(2)FileOutputStream fos使用demo:

/**
 * 文件输出流：java.io.FileOutputStream;
 * 构造方法：
 *         （1）FileOutputStream fos = new FileOutputStream(new File("a.txt"));  //文件对象
 *         （2）FileOutputStream fos = new FileOutputStream("a.txt");  //文件路径
 *         （3）public FileOutputStream(File file, boolean append);   //append = true (追加写) false (覆盖写)
 * 基本方法：
 *         （1）public void close() ：     关闭此输出流并释放与此流相关联的任何系统资源。
 *         （2）public void flush() ：     刷新此输出流并强制任何缓冲的输出字节被写出。
 *         （3）public void write(byte[] b) ： 将 b.length字节 从指定的字节数组写入此输出流。
 *  （***） （4）public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输 出到此输出流。（常用）
 */

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        //使用文件对象创建文件流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
        //创建字节数组
        byte[] bytes = {97,98,99,100,101};
        for (int i = 0; i < bytes.length; i++) {
            //写入单个字节
            fos.write(bytes[i]);
            //mac下的换行符
            fos.write("\n".getBytes());
        }
        fos.close();

    }
}

（3）图片复制demo:字节流读写

public class PicCopy {
    public static void main(String[] args) throws IOException {
        //1.创建文件io流
        FileInputStream fis = new FileInputStream("/Users/caowei/Desktop/屏幕快照/1.jpg");
        FileOutputStream fos = new FileOutputStream("pictureCopy.jpg");
        //2.读写文件
        //读取的有效数据的长度
        int len ;
        //数据缓冲区
        byte[] b = new byte[1024];
        while ((len = fis.read(b)) != -1){
            fos.write(b,0,len);
            //System.out.println(Arrays.toString(b));
        }
        //3.关闭流
        fos.close();
        fis.close();
    }
}

三、字符流

顶级父类：

  • java.io.Reader
  • java.io.Writer

常用实现类：

  • FileReader
  • FileWriter

(1)FileReader使用

import java.io.FileReader;
import java.io.IOException;
/**
 * 字符输入流：java.io.Reader
 * 实现类：java.id.FileReader  extends OutputStreamReader  extends Reader
 * 构造方法：
 *      FileReader(File file) ：
 *      FileReader(String fileName) ：
 * 常用方法：
 *      read():每次读取一个字符，返回：字符的int型，游标自动下移，读至末尾，返回-1
 *      read(char[] cbuf) 使用字符数组，作为容器。每次读取cbuf.length()的长度个字符到数组中，返回读取到的有效字符个数.
 *
 */
public class FileRead {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("read.txt");    // 字符流，常用来处理文本信息。
        int len;
        char[] c = new char[1024];            //字符数组作为数据容器
        while ((len = fr.read(c)) != -1){
            System.out.println(new String(c,0 ,len));      //打印有效数据，len为有效数据长度。
            //这里也可以定义一个输出流，将数据写到硬盘中。
        }
    }
}

(2)FileWriter的使用步骤

/**
 * 字符输入流：java.io.Writer
 * 实现类：java.id.FileWriter
 * 构造方法：
 *      FileWriter(File file) ：
 *      FileWriter(String fileName) ：
 * 常用方法：
 *       //写字符数组
 *       write(char[] cbuf)
 *       write(char[] cbuf, int off, int len)
 *       //写字符串
 *       fs.write("字符串");
 *       fs.write("字符串，startIndex ,len")
 *
 * 使用步骤：
 *      1.创建FileWriter对象，构造方法绑定数据写入的目的地
 *      2.使用writer方法将数据写入到内存缓冲区中（不同于字节流）-->字符转换为字节的过程
 *      3.使用flush()方法，将内存缓冲区的数据刷新到文件中（大文件读写，应该及时刷新数据，不要占用内存缓冲区）
 *      4.释放资源：close()会先将缓冲区数据刷新到内存，再关闭资源。
 *
 */

public class FileWrite {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("read.txt");    // 字符流，常用来处理文本信息。
        FileWriter fw = new FileWriter("write.txt");
        int len;
        char[] c = new char[1024];            //字符数组作为数据容器
        while ((len = fr.read(c)) != -1){
            fw.write(c,0,len);    //将数据写到了内存的缓冲区。还没有刷新到硬盘中，不同于字节流！
        }
        //在使用字符流时，没有使用时flush，或者close是无法将数据从缓冲加到硬盘的。
        fw.close();
        fr.close();
    }
}

flush() 和 close()的区别： flush 刷新缓冲区，流对象可以继续使用; close 先刷新缓冲区，然后通知系统释放资源，流对象关闭

四、IO的异常处理

在实际的开发中，通常不会将异常抛出，而是捕获处理。

1.在jdk1.7之前，使用try catch finally 处理流中的异常的，步骤
       try{
           //可能产生异常的代码
       }catch(){
           //异常的处理逻辑
       }finally{
           //一定会执行的代码
           //释放资源
       }

例子

 public static void main(String[] args)  {
        //提高变量的作用域，让finally可以使用
        //定义变量的时候可以没有值，但是使用的时候必须有值。
        FileReader fr = null;
        FileWriter fw = null;
        try{
            //可能会产生异常的代码
             fr = new FileReader("read.txt");
             fw = new FileWriter("a.txt",false);

            int len = 0;
            char[] c = new char[1024];
            while ((len = fr.read(c)) != -1){
                fw.write(c,0,len);
            }

        }catch (IOException e){
            //异常的处理逻辑
            System.out.println(e);
        }finally {
            try {
                //执行close()的时候也有可能产生异常，捕获抛出异常
                fw.close();
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
2.JDK7异常处理

JDK7新特性：try(){}catch(){} 在try后新增加()括号，可以在其中定义流对象，作用范围为try{},try{}中代码执行完毕后，自动释放资源。不用写finally了。

public class TryCatchByJDK7 {
    public static void main(String[] args)  {
        //提高变量的作用域，让finally可以使用
        //定义变量的时候可以没有值，但是使用的时候必须有值
        try(FileReader fr = new FileReader("read.txt");
            FileWriter fw = new FileWriter("a.txt",false);
            ){
            //可能会产生异常的代码
            int len = 0;
            char[] c = new char[1024];
            while ((len = fr.read(c)) != -1){
                fw.write(c,0,len);
            }
        }catch (IOException e){
            //异常的处理逻辑
            System.out.println(e);
        }

    }
}
  • JDK9: 可以在try前面定义流对象，在try()的小括号中接收参数。

五、属性集Properties类

1.概念：

java.util.Properties 继承于 Hashtable ，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其 对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时， System.getProperties 方法就是返回 一个 Properties 对象。

2.基本方法
  1. 构造函数：
    public Properties() :创建一个空的属性列表。
  2. 存键值对：
    public Object setProperty(String key, String value) ： 保存一对属性。
  3. 取值：
    public String getProperty(String key) ：使用此属性列表中指定的键搜索属性值。
  4. 获取键的集合：遍历取值；
    public Set stringPropertyNames() ：所有键的名称的集合。

使用，类似其超类Map的put()/get()/keySet()方法

3.与IO流相关的两个重要方法

load()/store():两种方法都有不同的重载形式，主要区别在于是否支持中文参数与。

  • void load(InputStream inStream)
    从输入流中读取属性列表（键和元素对）。
  • void load(Reader reader)
    按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
  • void store(OutputStream out, String comments)
    以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
  • void store(Writer writer, String comments)
    以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。

读写配置文件的示例

public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        writeProp();  //写配置文件
        readProp();  //读取配置文件
    }

    /*读取配置文件，并打印*/
    private static void readProp() throws IOException {
        //1.创建Properties集合对象
        Properties prop = new Properties();
        //2.使用load()方法读取，并保存文件为键值对。
        prop.load(new FileReader("prop.txt"));
        //3.遍历prop集合
        Set<String> strings = prop.stringPropertyNames();
        for (String key : strings) {
            String value = prop.getProperty(key);
            System.out.println(value);
        }

    }

    /*写配置文件*/
    public static  void writeProp() throws IOException {
        //1.创建Properties集合，添加数据
        Properties prop = new Properties();
        prop.setProperty("ip","127.0.0.1");
        prop.setProperty("port","442");

        //2.创建字符输出流，构造函数绑定输出地址
        FileWriter fw = new FileWriter("prop.txt");

        //3.使用Properties集合中的store()方法，将集合中的临时数据写入到硬盘中
        prop.store(fw,"save data");

        //4.释放资源
        fw.close();
    }
}
UP青年
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java io流读取文件_java的几种IO流读取文件方式
weixin_39701768的博客
02-16 5927
一、超类：字节流： InputStream(读入流) OutputStream(写出流)字符流： Reader(字符 读入流) Writer (字符写出流)二、文件操作流字节流： FileInputStream ，FileOutputStream字符流： FileReader, FileWriter(用法与字节流基本相同，不写)//1.指定要读 的文件目录及名称File file =...
Java-IO流/Stream流总结
07-12
内容：IO流及其分类、分类比较、转换流、缓存流、IO流异常处理、Stream流、Properties教程等。 适合人群：有编程基础及Java基础伙伴 适用场景：Java中的流是随处可见的，涉及文件的操作必须使用IO流，Stream流可以对...
流文件的处理
qq_45277352的博客
08-27 411
后端返回流文件的时候的处理： axios.get(url, { ...config, headers: { platform: 'pc' }, params, responseType: 'blob', }); //这里的responseType: 'blob',确定了返回的类型为流 //处理流的方法 getFailData({ uuid }) // .then(res=>res.blob()) .then((res) => {
流的概念及应用于处理文件
White__River的博客
03-05 407
参考：《Big C++ 》 输入/输出库是基于流的概念。 输入流是数据的源头 输出流是数据的汇集/数据的目标 最常见的数据源头和数据目标是————硬盘上的文件· 三种类型的文件流 ifstream（input file stream） ofstream fstream 在这里插入代码片 要包含**< fstream >**head文件 对于文件流的操作 5. 从文件流中读取内容 1.1. open string filename; cin>> filename; ifstrea
前后端处理流文件请求
weixin_34376562的博客
02-13 395
知识点 nodeAPI——stream nodeAPI——fs koa——response封装 服务端返回流文件 koa 请求响应流文件 this.ctx.body = fs.createReadStream(`${__dirname}/../../index.js`); 复制代码koa/lib/application.js 源码中，有判断body是否为流对象，然后 pipe 到响应对象中去 ...
前端处理文件流（下载，上传）
s1012544671的博客
03-21 6385
下载(接口返回的是文件流的) 首先配置请求的地方加上responseType:"blob" ！！！ export function downloadTestExcel() { return crewordRequest({ url: "路径", method: "get", responseType: "blob", }); } 然后绑定点击事件 async downLoad(){ const res = await downloadTestEx
JS处理文件流
我是渣渣
11-14 3万+
最近做一个项目，遇到了一个问题，就是导出Excel功能。多普通呀，多大众化，哪里都有，可惜我们后台说给我JSON数据，自己处理。我果断拒绝了，拒绝的里有是我菜，实现不了啊。然后后台开发看不下去了，就是转成文件流给我吧。他们那里是分布式部署，也没有办法持久化存储。遂发生了一下的故事 百度 没有怎么做过，肯定是百度啦，然后找打了一段代码,代码内容如下 function download() {...
IO流：节点流和处理流详细归纳。
yzh2776680982的博客
07-03 3233
目录一、节点流和处理流二、处理流1、BufferedReader 字符流2、BufferedWriter 字符流3、利用二者进行文件拷贝4、BufferedInputStream 字节流5、BufferedOutputStream 字节流三、ObjectOutputStream、ObjectInputStream 1、序列化和反序列化 2、 ObjectOutputStream 3、ObjectInputStream 4、注意事项 5、标准输入流和输出流 四、转换流 1、基本介绍 2、把 FileInput
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 14万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
C# IO流读写文件操作
qq_45728730的博客
05-18 3134
C# IO流读写文件操作 1、创建文件流 2、创建文件读写器 3、执行读写操作 4、关闭文件读写器和文件流 1、创建文件流 string filePath = AppDomain.CurrentDomain.BaseDirectory + @"..\..\..\TextFile1.txt";//文件相对路径 string filePath2 = @"D:\file\TextFile2.txt";//文件绝对路径 FileStream fs =new FileStream( filePath,FileMode
Java中文件IO流.pdf
07-11
Java中文件IO流.pdf 学习资料 复习资料 教学资源
python知识点，IO流，文件处理方法
10-11
python知识点，IO流，文件处理方法
Java中的IO流
12-22
IO流按照流向分类可分为输入和输出，按照文件操作处理单元分类可分为字节流和字符流。 FileInputStream 文件操作输入字节流 FileOutputStream 文件操作输出字节流 FileReader 文件操作输入字符流 FileWriter 文件...
node-socket-file:借助socket.io进行文件处理
05-27
在帮助下进行文件处理。 安装 npm i socket-file --save 如何使用？ const socketFile = require ( 'socket-file' ) ; const http = require ( 'http' ) ; const express = require ( 'express' ) ; const io = ...
java环境部署
JiuMeilove的博客
06-04 369
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
java中Overload和Override的区别
codedadi的博客
06-04 547
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
JavaScript第九讲：BOM编程
最新发布
星途码客的博客
06-04 1402
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
Itmastergo的博客
05-31 1246
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Spring异步任务@Async的默认线程池执行器是如何初始化的
简放视野的专栏
06-03 621
Spring异步任务@Async的默认线程池执行器，是从哪里来？是如何初始化的？ 【结论】异步任务@Async的默认线程池执行器是通过TaskExecutionAutoConfiguration#applicationTaskExecutor自动注入的。
java io流读文件
03-29
IO流主要分为字节流和字符流，其中字节流用于处理二进制数据，而字符流则用于处理文本数据。以下是读取文件的一般步骤： 1. **导入相关类**：首先需要导入java.io包中的相关类，如FileInputStream、BufferedReader...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值