当前位置： 首页 > article >正文

JavaIO流操作

article 2024/11/2 6:41:18

目录

简介

字节输入流

获取字节输入流

读

关闭输入流

字节输出流

获取字节输出流

写

换行符

刷新

关闭输出流

字符流输入流

获取字符输入流

读

关闭输入流

字符输出流

获取字符输出流

写

换行符

刷新

关闭输出流

简介

IO流分为两大派系：
    1.字节流：字节流又分为字节输入流、字节输出流
    2.字符流：字符流由分为字符输入流、字符输出流

什么叫输入流？

我们可以认为，把文件内容拿到java代码中，文件的内容输入到了java代码内，这种被称为输入流。

什么叫输出流？

我们可以认为，把java代码内输入的一些内容，保存到java代码外的文件中，这种被称为输入流。

字节输入流

获取字节输入流

FileInputStream fileInputStream = new FileInputStream(String str,);

str：文件的地址路径。

// 案例
FileInputStream fileInputStream = new FileInputStream("../io-demo/abc/2.txt");

读

方案一：

int len = fileInputStream.read(byte[] b);

根据数组大小读取文件内容。

len：当前读取字节的个数。

b：byte数组，每次读几个字节取决于定义的byte数组，读取到的内容后，会放入定义好的byte数组（不设置默认读1个字节）。

案例：按照数组大小读取内容

package com.zsh;

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

/**
 * IO字节输入流
 */
public class IoInputStream {
    public static void main(String[] args) {
        try (
                // 创建文件字节输入流管道，与源文件接通。
                FileInputStream fileInputStream = new FileInputStream("../io-demo/abc/2.txt")
        ) {
            // 定义byte数组，设置一次读取多少个字节(当前每次从文件中读取3个字节出来)
            byte[] buf = new byte[3];

            // 定义变量，接收当前读取内容的长度     .read()没有数据返回-1
            int len;

            // 循环读取文件中的所有内容
            while ((len = fileInputStream.read(buf)) != -1){
                // 读取到的内容会被放到前面定义好的byte数组中
                System.out.println(new String(buf));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

方案二：

byte[] bytes = fileInputStream.readAllBytes();

读取全部内容。

.readAllBytes();在jdk1.8以后才有。

一次性读取文件中全部的内容，如果文件内存过大会导致内存溢出，不建议使用！！！

案例： 一次性读取全部内容

package com.zsh;

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

/**
 * IO字节输入流
 */
public class IoInputStream {
    public static void main(String[] args) {
        try (
                // 创建文件字节输入流管道，与源文件接通。
                FileInputStream fileInputStream = new FileInputStream("../io-demo/abc/2.txt")
        ) {
            // 一次性读取全部内容
            byte[] bytes = fileInputStream.readAllBytes();
            System.out.println(new String(bytes));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

关闭输入流

方案一：

fileInputStream.close();

手动关闭输入流。

// 案例
// 定义FileInputStream对象
FileInputStream fileInputStream = null;
// 创建文件字节输入流管道，与源文件接通。
try {
    fileInputStream = new FileInputStream("../io-demo/abc/2.txt");
} catch (FileNotFoundException e) {
    System.out.println("找不到文件");
} finally {
    if(fileInputStream != null){
        try {
            // 关闭字节输入流
            fileInputStream.close();
        } catch (IOException e) {
            System.out.println("文件读取异常");
        }
    }
}

方案二：

把FileInputStream fileInputStream = new FileInputStream("../io-demo/abc/2.txt");放到try-with-resources中可以不用手动关闭流。

选中FileInputStream fileInputStream = new FileInputStream(String str);按crtl + alt + t，选择try-with-resources即可。

只要是继承了AutoCloseable接口的类，就可以放到try的()中，不用手动.close();

只需要在catch中处理异常即可。

// 案例
try (
    // 创建文件字节输入流管道，与源文件接通。
    FileInputStream fileInputStream = new FileInputStream("../io-demo/abc/2.txt");
) {
    // 这里正常写代码逻辑



} catch (IOException e) {
    System.out.println("文件读取异常");
}

字节输出流

获取字节输出流

FileOutputStream fileOutputStream= new FileOutputStream(String str,boolean append);

如果文件不存在则会创建文件。

str：文件输出的地址路径，要保存到哪。

append：可以设置为true，默认是false，设置为true以后，文件写入不会顶替掉之前的内容，而是继续追加内容。

// 案例
// 创建文件
FileOutputStream fileOutputStream = new FileOutputStream("../io-demo/abc/2.txt");

// 不覆盖文件内的内容，继续向文件中追加内容
FileOutputStream fileOutputStream = new FileOutputStream("../io-demo/abc/2.txt",true);

写

方案一：

fileOutputStream.write(int i);

写入单个字节。

i：要写入的内容

案例： 写入单个字节

package com.zsh;

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

/**
 * IO字节输出流
 */
public class IoOutStream {
    public static void main(String[] args) {
        try (
                // 获取字节输出流
                FileOutputStream fileOutputStream = new FileOutputStream("../io-demo/abc/3.txt", true);
        ) {
            // 写入单个字节
            fileOutputStream.write(97);
            fileOutputStream.write(98);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

方案二：

fileOutputStream.write(byte[] b);

byte数组写入文件。

b：要写入的字节数组。

案例：byte数组写入文件

package com.zsh;

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

/**
 * IO字节输出流
 */
public class IoOutStream {
    public static void main(String[] args) {
        try (
                // 获取字节输出流
                FileOutputStream fileOutputStream = new FileOutputStream("../io-demo/abc/3.txt", true);
        ) {
            // byte写入文件
            byte[] bytes = new byte[]{66,67,68,69,70};
            fileOutputStream.write(bytes);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

方案三：

fileOutputStream.write(byte[] b,int off,int len);

根据下标写入数据。

b：要写入的字节数组。

off：要从数组的第几位下标开始写。

len：截至到哪。

案例：根据下标写入数组中的内容

package com.zsh;

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

/**
 * IO字节输出流
 */
public class IoOutStream {
    public static void main(String[] args) {
        try (
                // 获取字节输出流
                FileOutputStream fileOutputStream = new FileOutputStream("../io-demo/abc/3.txt", true);
        ) {
            // byte写入文件
            byte[] bytes = new byte[]{66,67,68,69,70};
            // 根据下标写入数组中的内容
            fileOutputStream.write(bytes,0,2);    // 写入66，67
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

换行符

fileOutputStream.write("\r\n".getBytes());

案例：

fileOutputStream.write("\r\n".getBytes());

刷新

fileOutputStream.flush();

这个是刷新，与.close();关闭有所不同。

写入内容如果不刷新也不关闭流，写入的内容不会保存到文件中，而是存储在内存中，文件中是看不到的。只有刷新或者关闭流，写入的内容才会到文件中。

刷新之后还可以继续写入内容，关闭之后不能写入内容。

案例：

// 调用write方法写数据，写入单个数据
fileOutputStream.write(97);
fileOutputStream.write(98);
        
// 刷新（将当前写入的内容保存到文件）
fileOutputStream.flush();

// 调用write方法写数据，写入单个数据
fileOutputStream.write(99);
fileOutputStream.write(100);

// 刷新（将当前写入的内容保存到文件）
fileOutputStream.flush();

关闭输出流

方案一：

fileOutputStream.close();

手动关闭输出流。

// 案例
// 定义FileInputStream对象
FileOutputStream fileOutputStream = null;
// 创建文件字节输入流管道，与源文件接通。
try {
    fileOutputStream = new FileOutputStream("../io-demo/abc/2.txt");
} catch (FileNotFoundException e) {
    System.out.println("找不到文件");
} finally {
    if(fileOutputStream != null){
        try {
            // 关闭字节输入流
            fileOutputStream.close();
        } catch (IOException e) {
            System.out.println("文件写入异常");
        }
    }
}

方案二：

把FileOutputStream fileOutputStream = new FileOutputStream("../io-demo/abc/1.txt",true);放到try-with-resources中可以不用手动关闭流。

选中FileOutputStream fileOutputStream = new FileOutputStream("../io-demo/abc/1.txt",true);按crtl + alt + t，选择try-with-resources即可。

只要是继承了AutoCloseable接口的类，就可以放到try的()中，不用手动.close();

只需要在catch中处理异常即可。

// 案例
try (
    // 创建文件字节输入流管道，与源文件接通。
    FileOutputStream fileOutputStream = new FileOutputStream("../io-demo/abc/1.txt",true);
) {
    // 这里正常写代码逻辑



} catch (IOException e) {
    System.out.println("文件写入异常");
}

字符流输入流

获取字符输入流

FileReader fileReader = new FileReader(String str);

str：文件的路径地址。

// 案例
FileReader fileReader = new FileReader("abc/FileWriter.txt");

读

方案一：

int len = fileReader.read(char[] cbuf);

len：当前读取字符的个数。

cbuf：char数组，每次读取几个字符取决于自定义的char数组，读取到内容后，会当如定义好的char数组（不设置默认读取1个字符）。

案例：按照数组大小读取内容

package com.zsh;

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

/**
 * 字符流输入流
 */
public class IoFileInputDemo {
    public static void main(String[] args) {
        try (
                // 获取字符输入流对象
                FileReader fileReader = new FileReader("abc/FileWriter.txt");
        ) {
            // 定义char数组，设置一次读取多少字符（当前每次从文件中读取3个字符出来）
            char[] txt = new char[3];

            // 定义变量，接受当前读取内容的长度 .read()没有数据返回-1
            int len;

            // 循环读取文件中的所有内容
            while ((len = fileReader.read(txt)) != -1){
                // 读取道德内容会被放到前面定义好的char数组中
                System.out.println(txt);
            }
        } catch (IOException e) {
            System.out.println("文件读取异常");
        }
    }
}

关闭输入流

方案一：

fileReader.close();

手动关闭输入流。

// 案例
// 定义FileReader对象
FileReader fileReader = null;
// 创建文件字节输入流管道，与源文件接通。
try {
    FileReader = new FileReader("abc/FileWriter.txt");
} catch (FileNotFoundException e) {
    System.out.println("找不到文件");
} finally {
    if(fileReader != null){
        try {
            // 关闭字符输入流
            fileReader.close();
        } catch (IOException e) {
            System.out.println("文件读取异常");
        }
    }
}

方案二：

把FileReader fileReader = new FileReader("abc/FileWriter.txt");放到try-with-resources中可以不用手动关闭流。

选中FileReader fileReader = new FileReader("abc/FileWriter.txt");按crtl + alt + t，选择try-with-resources即可。

只要是继承了AutoCloseable接口的类，就可以放到try的()中，不用手动.close();

只需要在catch中处理异常即可。

package com.zsh;

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

/**
 * 字符流输入流
 */
public class IoFileInputDemo {
    public static void main(String[] args) {
        try (
                // 获取字符输入流对象
                FileReader fileReader = new FileReader("abc/FileWriter.txt");
        ) {
            // 这里正常写代码逻辑



        } catch (IOException e) {
            System.out.println("文件读取异常");
        }
    }
}

字符输出流

获取字符输出流

FileWriter fileWriter = new FileWriter(String str,boolean append);

如果文件不存在则会创建文件。

str：文件输出的地址路径，要保存到哪。

append：可以设置为true，默认是false，设置为true以后，文件写入不会顶替掉之前的内容，而是继续追加内容。

// 案例
// 创建文件
FileWriter fileWriter = new FileWriter("abc/FileWriter2.txt");

// 不覆盖文件内的内容，继续向文件中追加内容
FileWriter fileWriter = new FileWriter("abc/FileWriter2.txt",true);

写

方案一：

fileWriter.write(String str);

字符串写入文件。

str：要写入的字符串。

案例：字符串写入文件

package com.zsh;

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

/**
 * 字符输出流
 */
public class IoFileOutDemo {
    public static void main(String[] args) {
        try (
                FileWriter fileWriter = new FileWriter("abc/FileWriter2.txt");
        ) {
            // 字符串写入文件
            fileWriter.write("你的代码爆红了！！！");
        } catch (IOException e) {
            System.out.println("文件写入异常");
        }
    }
}

方案二：

fileWriter.write(char[] cbuf);

byte数组写入文件。

cbuf：要写入的数组

案例：byte数组写入文件

package com.zsh;

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

/**
 * 字符输出流
 */
public class IoFileOutDemo {
    public static void main(String[] args) {
        try (
                FileWriter fileWriter = new FileWriter("abc/FileWriter2.txt");
        ) {
            // char数组写入文件
            fileWriter.write("123".toCharArray());
        } catch (IOException e) {
            System.out.println("文件写入异常");
        }
    }
}

换行符

fileWriter.write("\r\n".getBytes());

案例：

fileWriter.write("\r\n");

刷新

fileWriter.flush();

这个是刷新，与.close();关闭有所不同。

写入内容如果不刷新也不关闭流，写入的内容不会保存到文件中，而是存储在内存中，文件中是看不到的。只有刷新或者关闭流，写入的内容才会到文件中。

刷新之后还可以继续写入内容，关闭之后不能写入内容。

案例：

// 调用write方法写数据，写入数据
fileWriter.write("你的代码报红了！！！");
fileWriter.write("123");
        
// 刷新（将当前写入的内容保存到文件）
fileWriter.flush();

// 调用write方法写数据，写入数据
fileWriter.write("你的代码正在运行！！！");
fileWriter.write("123");

// 刷新（将当前写入的内容保存到文件）
fileWriter.flush();

关闭输出流

方案一：

fileWriter.close();

手动关闭输出流。

// 案例
// 定义FileReader对象
FileWriter fileWriter = null;
// 创建文件字节输入流管道，与源文件接通。
try {
    fileWriter = new FileWriter("abc/FileWriter.txt");
} catch (FileNotFoundException e) {
    System.out.println("找不到文件");
} finally {
    if(fileReader != null){
        try {
            // 关闭字符输入流
            fileWriter.close();
        } catch (IOException e) {
            System.out.println("文件写入异常");
        }
    }
}

方案二：

把FileWriter fileWriter = new FileWriter("abc/FileWriter2.txt");放到try-with-resources中可以不用手动关闭流。

选中FileWriter fileWriter = new FileWriter("abc/FileWriter2.txt");按crtl + alt + t，选择try-with-resources即可。

只要是继承了AutoCloseable接口的类，就可以放到try的()中，不用手动.close();

只需要在catch中处理异常即可。

package com.zsh;

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

/**
 * 字符输出流
 */
public class IoFileOutDemo {
    public static void main(String[] args) {
        try (
                FileWriter fileWriter = new FileWriter("");
        ) {
            // 这里正常处理代码


        } catch (IOException e) {
            System.out.println("文件写入异常");
        }
    }
}


http://www.kler.cn/a/375478.html

相关文章：

  • TypeScript 和 JavaScript 的区别
  • Oracle与SQL Server的语法区别
  • ubuntu运行gazebo导致内存越来越少
  • 防火墙技术应用
  • Qt指定程序编译生成文件的位置
  • C++STL详解（九）map和set的使用
  • BGP路由优选+EVPN
  • npm入门教程6：npm脚本
  • PHP实现雪花算法生成唯一ID
  • 【银河麒麟高级服务器操作系统】虚拟机lvm分区丢失现象分析及解决建议
  • 初始JavaEE篇——多线程（7）：定时器、CAS
  • ＜meta property=“og:type“ content=“website“＞
  • 高级java每日一道面试题-2024年10月26日-JVM篇-JVM的类加载机制是什么?
  • 【机器学习】26. 聚类评估方法
  • Ubuntu 系统、Docker配置、Docker的常用软件配置（下）
  • Docker-in-Docker（DinD）
  • 4：arm汇编语言4：bits/byte的介绍（ASCII码）与二进制补位
  • 【数据结构】guard
  • PyMOL中常用的命令列表
  • 代理人工智能如何应对现代威胁的速度和数量
  • 重载与重写的区别
  • wireshark复制数据
  • 极简实现酷炫动效：Flutter隐式动画指南第二篇之一些酷炫的隐式动画效果
  • 高清解压视频素材从哪儿下载？推荐5个高清推文素材资源网站
  • Unity3D Shader实现法线贴图功能详解
  • 【论文阅读】FUNNELRAG：一个从粗到精的逐级检索范式