Java IO详解

已于 2024-06-05 00:29:06 修改
阅读量87 收藏
点赞数
分类专栏： 笔记 文章标签： java java-ee
于 2021-07-13 17:15:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34013719/article/details/118705752
版权

流的分类

  1. 按方向
  • 输入流：存储设备->内存
  • 输出流：内存->存储设备

  1. 按单位

    • 字节流：以字节为单位，可以读写所有数据
    • 字符流：以字符为单位，只能读写文本数据（一个字符可能有好几个字节）

  2. 按功能

    • 节点流：具有实际传输数据的读写功能
    • 过滤流：在节点流的基础之上增强功能

字节流

InputStream

OutputStream

文件字节流

FileInputStream

  1. 一个字节一个字节地读取

    //1.指定文件路径
        FileInputStream fis = new FileInputStream("E:\\test.txt");

        //2.一个字节一个字节地读取数据
        int data=0;
        while((data=fis.read())!=-1){
            System.out.print((char)data);
        }

        //3.关闭
        fis.close();

  2. 一次读取多个字节

    //1.指定文件路径
        FileInputStream fis = new FileInputStream("E:\\test.txt");

        //2.一次读取多个字节长度
        int len = 0;
        byte[] buf = new byte[4];
        while((len=fis.read(buf))!=-1){
            System.out.print(new String(buf,0,len));
        }

        //3.关闭
        fis.close();
FileOutputStream

需要将字符串转为字节流再写入文件

getBytes()

FileOutputStream构造方法的第二个参数为true，则再文件末尾接着写入（不覆盖原有数据）

// 1. 指定文件路径
        FileOutputStream fos = new FileOutputStream("E:\\a.txt");
		//FileOutputStream fos = new FileOutputStream("E:\\a.txt",true);

        // 2. 写入数据
        fos.write(97);      //写入字符‘a’
        fos.write('b');     //写入字符‘b’

        String str = "Hello FileOutputStream";
        fos.write(str.getBytes());      //将字符串转为字节流写入文件


        // 3. 关闭
        fos.close();
案例：实现文件复制
// 1.文件字节输入
        FileInputStream fis = new FileInputStream("E:\\photos\\head.jpg");
        // 2.文件字节输出
        FileOutputStream fos = new FileOutputStream("E:\\head.txt");

        // 3.读写
        byte[] buf = new byte[1024];
        int count = 0;
        while((count = fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }

        // 4.关闭
        fos.close();
        fis.close();

字节缓冲流

提高读取效率

BufferedInputStream
//1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("E:\\test.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);

        //2.读取
        int data = 0;
        while((data=bis.read())!=-1){
            System.out.print((char)data);
        }

        //3.关闭  关闭BufferedInputStream会自动关闭FileInputStream
        bis.close();
BufferedOutputStream

先写到缓冲区，再写入内存设备

//1.创建BufferedOutputStream
        FileOutputStream fos = new FileOutputStream("E:\\test.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //2.写入缓冲区(缓冲区大小：8K)
        for(int i=0;i<10;++i){
            bos.write("hellow BufferedOutputStream\n".getBytes());
        }
        //3.写入硬盘
        bos.flush();

        //4.关闭
        bos.close();

对象流

使用流传输对象的过程称为序列化、反序列化

注意事项：

  • 被序列化的类必须实现Serializable接口
  • 被序列化的类中的对象属性也必须实现Serializable接口
  • 使用transient修饰的属性将不会被序列化，反序列化时该属性被赋值为默认值
  • 静态属性不能被序列化
  • 序列化多个对象可以使用集合
  • 序列化版本号ID用于保证序列化和反序列化的类是同一个类

被序列化的类实现如下：

//实现Serializable接口才可序列化
public class Student implements Serializable {

    //序列化版本号ID
    private static final long serialVersionUID = 100L;

    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
ObjectOutputStream

序列化

FileOutputStream fos = new FileOutputStream("E:\\student.dat");
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        Student s1 = new Student("Jack",17);
        oos.writeObject(s1);

        oos.close();
ObjectInputStream

反序列化

FileInputStream fis = new FileInputStream("E:\\student.dat");
        ObjectInputStream ois = new ObjectInputStream(fis);

        Student s1 = (Student)ois.readObject();

        ois.close();

        System.out.println(s1);

字符流

仅能读写文本文件

Reader

Writer

文件字符流

类比文件字节流

FileReader

  1. 一次读取一个字符

    FileReader fr = new FileReader("E:\\test.txt");

        int data = 0;
        while((data=fr.read())!=-1){
            System.out.print((char)data);
        }

        fr.close();

  2. 一次读取多个字符

    FileReader fr = new FileReader("E:\\test.txt");

        char[] buf = new char[1024];
        int count = 0;
        while((count=fr.read(buf))!=-1){
            System.out.print(new String(buf,0,count));
        }

        fr.close();
FileWriter
FileWriter fw = new FileWriter("E:\\test.txt");

        fw.write("你好");
        fw.flush();         //刷新

        fw.close();
案例：实现文件复制

只能复制文本文件

FileReader fr = new FileReader("E:\\test.txt");
        FileWriter fw = new FileWriter("E:\\hhh.txt");

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

        fw.close();
        fr.close();

字符缓冲流

BufferedReader
FileReader fr = new FileReader("E:\\test.txt");
        BufferedReader br = new BufferedReader(fr);

        String data = null;
        while((data=br.readLine())!=null){
            System.out.println(data);
        }

        br.close();
BufferedWriter
FileWriter fw = new FileWriter("E:\\test.txt");
        BufferedWriter bw = new BufferedWriter(fw);

        for (int i=0;i<10;++i) {
            bw.write("Hello BufferedWriter and BufferedReader");
            bw.newLine();       //换行
            bw.flush();         //将缓存写入文件
        }

        bw.close();

PrintWriter

PrintWriter pw = new PrintWriter("E:\\test.txt");

        pw.println(97);     //打印数字
        pw.println(4.556);
        pw.println('a');    //打印字符
        pw.println("hello world");//打印字符串

        pw.close();

转换流

字节流与字符流转换

InputStreamReader

是字节流通向字符流的桥梁

// 以utf-8编码方式读取
        FileInputStream fis = new FileInputStream("E:\\test.txt");
        InputStreamReader isr = new InputStreamReader(fis,"utf-8");

        int data = 0;
        while((data=isr.read())!=-1){
            System.out.print((char)data);
        }

        isr.close();

OutputStreamWriter

是字符流通向字节流的桥梁

FileOutputStream fos = new FileOutputStream("E:\\test.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");

        for (int i = 0; i < 10; i++) {
            osw.write("hello\n");
        }

        osw.close();

File类

代表物理盘符中的一个文件或文件夹

分隔符

  • 路径分隔符：;

  • 名称分隔符：\

    System.out.println("路径分隔符："+ File.pathSeparator);
        System.out.println("名称分隔符："+ File.separator);

文件操作

// 1.创建文件对象
        File file = new File("E:\\file.txt");
        System.out.println(file.toString());        //打印文件路径

        // 2.创建文件
        if(!file.exists()){
            boolean b = file.createNewFile();
            System.out.println("创建结果："+b);
        }

        // 3.删除文件
        /// 3.1 直接删除
        //file.delete();  //返回boolean
        /// 3.2 JVM退出时删除
        file.deleteOnExit();
        Thread.sleep(3000);     //休眠3秒便于观察

        // 4.获取文件信息
        System.out.println(file.getAbsoluteFile()); //绝对路径
        System.out.println(file.getPath());         //获取创建文件对象时输入的路径
        System.out.println(file.getName());         //获取文件名
        System.out.println(file.getParent());       //父级名称
        System.out.println(file.length());          //文件长度
        System.out.println(new Date(file.lastModified()).toLocaleString());//创建时间

        // 5.判断
        System.out.println(file.canWrite());        //是否可写
        System.out.println(file.isFile());          //是否是文件
        System.out.println(file.isHidden());        //是否隐藏

文件夹操作

delete()只能删除空文件夹（文件夹中不能有文件夹或者文件）

// 1. 创建文件夹对象
        File dir = new File("E:\\test\\demo");

        // 2. 创建文件夹
        if(!dir.exists()){
            //dir.mkdir();      //创建单级目录
            System.out.println("创建结果：" + dir.mkdirs());       //创建多级目录
        }

        // 3. 删除文件夹     只能删除最底层的一级目录，而且该目录下不能有文件
        /// 3.1 直接删除
        //dir.delete();
        /// 3.2 JVM关闭时删除
        dir.deleteOnExit();
        //Thread.sleep(3000);

        // 4. 获取文件夹信息
        System.out.println(dir.getAbsolutePath());      //绝对路径
        System.out.println(dir.getPath());              //获取创建文件夹对象时输入的路径
        System.out.println(dir.getName());              //文件夹名称
        System.out.println(dir.getParent());            //父级目录
        System.out.println(new Date(dir.lastModified()).toLocaleString());//创建时间

        // 5. 判断
        System.out.println(dir.isDirectory());          //是否是文件夹
        System.out.println(dir.isHidden());             //是否隐藏

        // 6. 遍历文件夹
        File dir2 = new File("E://photos");
        String[] filesName = dir2.list();
        for(String str:filesName){
            System.out.println(str);
        }

FileFilter接口

实现FileFilter接口的accept方法可以实现对文件/文件夹的过滤

例：打印E:\photos下的所有jpg文件

File dir2 = new File("E://photos");
        File[] files = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if(pathname.getName().endsWith("jpg")){
                    return true;
                }
                return false;
            }
        });

        for(File file : files){
            System.out.println(file.getName());
        }

案例1：递归遍历文件夹

public static void listDir(File dir){
        File[] files = dir.listFiles();
        if(files!=null && files.length>0){
            for(File file : files){
                if(file.isDirectory()){     //如果是文件夹，则递归遍历
                    listDir(file);
                }
                else{
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
        else{
            System.out.println("文件夹不存在或者为空文件夹");
        }
    }

案例2：递归删除文件夹

先删除文件夹中的文件再删除文件夹

public static void deleteDir(File dir){
        File[] files = dir.listFiles();
        if(files==null){
            System.out.println("文件夹不存在");
            return;
        }

        if(files.length>0){
            for(File file : files){
                if(file.isDirectory()){
                    deleteDir(file);
                }
                else{           //如果是文件，则直接删除
                    System.out.println("删除文件："+file.getAbsolutePath()+" : "+file.delete());
                }
            }
        }
        //删除文件夹
        System.out.println("删除文件夹："+dir.getAbsolutePath()+" : "+dir.delete());

    }

Properties属性集合

特点：

  • 存储属性名和属性值
  • 属性名和属性值都是字符串类型
  • 和流有关
  • 线程安全

Properties集合的基本使用

// 1.创建集合
        Properties properties = new Properties();

        // 2.添加数据
        properties.setProperty("username","Jack");
        properties.setProperty("age","21");
        System.out.println(properties);

        // 3.遍历
        //可以使用keySet entrySet StringPropertyNames()遍历
        Set<String> pronames = properties.stringPropertyNames();
        for(String str:pronames){
            System.out.println(str + " == "+properties.getProperty(str));
        }

Properties集合与流有关的方法

  • list方法
  • store方法
  • load方法
// list 列表
        PrintWriter pw = new PrintWriter("E:\\print.txt");
        properties.list(pw);
        pw.close();

        // store 保存
        FileOutputStream fos = new FileOutputStream("E:\\print.properties");
        properties.store(fos,"这里是注释");
        fos.close();

        // load 加载
        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("E:\\print.properties");
        properties2.load(fis);
        fis.close();
        System.out.println(properties2);
Valieo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础——IO详解
qq_45821255的博客
03-21 2905
本文介绍了IO流的具体内容，包括总结了常用的IO流，把它们做成了体系图。根据体系图分别介绍了它们的使用场景...
java-io概述
weixin_48767006的博客
08-05 185
问题：数据是存储到内存中的，当我们程序运行结束时，数据就没了，此时就需要把数据存储起来。I：input 输入（读）O：output 输出（写）java.io 包。
java IO部分详解
11-23
java IO部分详解各种流的解析例如 InputStream
java IO
weixin_30692143的博客
12-17 185
java IO 主要内容 java.io.File类的使用 IO原理及流的分类 文件流 FileInputStream / FileOutputStream / FileReader / FileWriter 缓冲流 BufferedInputStream / BufferedOutputStream / Buffered...
详解JAVA IO
Joker_ZJN的博客
02-20 404
JAVA IO中的各种类、各种流，一口气讲明白。
32.9、java io详解1
08-08
Java IO 之字节流和字符流的区别 Java 中的 IO 操作是指对文件、网络或其他输入/输出设备的读写操作。Java 中的 IO 操作可以分为两大类：字节流和字符流。字节流和字符流是 Java 中的两种基本的 IO 操作方式，它们...
Java教程之javaIO详解
09-12
Java IO 详解 Java IO（Input/Output）是 Java 语言中用于处理输入输出操作的类库，提供了大量的类和方法来实现文件、网络、字节流等方面的输入输出操作。下面对 Java IO 中的重要知识点进行详细说明。 一、File ...
JAVA_IO详解_包括讲解IO中各种流及其用法.pdf
06-18
java IO流总结文档。总要总结了 java IO 流的主要基本操作和使用到的类及方法。对于入门比较有用，如果对 IO 流比较了解，就没必要看了。
javaio详解【2】.pdf
10-03
Java IO 是Java平台中用于处理输入输出操作的重要部分，它提供了丰富的类库，使得开发者能够高效地读写数据。在Java中，IO是以流为基础进行的，数据被串行化写入输出流或从输入流读取。Java的IO体系分为字节流和字符...
java io 详解
11-09
### Java IO 详解 #### 一、Java IO体系概述 Java IO（Input/Output）是Java编程语言中处理输入输出的基础。它主要包括两大类：字节流和字符流。字节流主要处理二进制数据，如图片、音频等；字符流则用于处理文本...
JAVA IO详解
caixiexin的专栏
08-25 1621
学习JAVA的IO时整理的一些资料：   Java 流在处理上分为字符流和字节流。 字符流处理的单元为 2 个字节的 Unicode 字符，分别操作字符、字符数组或字符串，而字节流处理单元为 1 个字节（byte），操作字节和字节数组。 Java 内用 Unicode
JavaIO详解
isbn0123的博客
07-29 2601
IO/NIO/BIO 简介 无论是Socket的读写还是文件的读写，在Java层面的应用开发或者是linux系统底层开发，都属于输入input和输出output的处理，简称为IO读写。在原理上和处理流程上，都是一致的。区别在于参数的不同。 用户程序进行IO的读写，基本上会用到read&write两大系统调用。可能不同操作系统，名称不完全一样，但是功能是一样的。 先强调一个基础知识：read系统调用，并不是把数据直接从物理设备，读数据到内存。write系统调用，也不是直接把数据，写入到物理设备。 re
Java IO最详解
Kong的博客
05-31 373
初学Java，一直搞不懂java里面的io关系，在网上找了很多大多都是给个结构图草草描述也看的不是很懂。而且没有结合到java7 的最新技术，所以自己来整理一下，有错的话请指正，也希望大家提出宝贵意见。 首先看个图：（如果你也是初学者，我相信你看了真个人都不好了，想想java设计者真是煞费苦心啊！）   这是Java io 比较基本的一些处理流，除此之外我们还会提到一些
Java基础（6）- Java代码笔记3
最新发布
weixin_47062560的博客
08-30 1243
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
Java IO 详解：从BIO到NIO
Java IO 体系是Java平台中用于输入输出操作的基础框架，涵盖了从简单的文件读写到复杂的网络通信等多种场景。本文将逐步解析Java IO的核心概念，并深入探讨两种主要的IO模型：传统的 Blocking I/O (BIO) 和 New I/O ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值