AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【文件IO】 File类的用法和 InputStream OutputStream 的用法

2023-11-21 96
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【文件IO】 File类的用法和 InputStream OutputStream 的用法

File常见方法和属性

属性

修饰符及类型 属性 说明
static String pathSeparator 依赖于系统的路径分隔符，String 类型的表示
static char pathSeparator 依赖于系统的路径分隔符，char类型的表示

构造方法

方法 说明
File(File parent, String child) 根据父目录 + 子文件路径，创建一个新的 File 实例
File(String parent, String child) 根据文件路径创建一个新的 File 实例，路径可以是绝对路径或者 相对路径
File(String parent, String child) 根据父目录 + 子文件路径，创建一个新的 File 实例，父目录用 路径表示

方法

返回值 方法名 说明
String getParent() 返回 File 对象的父目录文件路径
String getName() 返回 FIle 对象的纯文件名称
String getPath() 返回 File 对象的文件路径
String getAbsolutePath() 返回 File 对象的绝对路径
String getCanonicalPath() 返回 File 对象的修饰过的绝对路径
boolean exists() 判断 File 对象描述的文件是否真实存在
boolean isDirectory() 判断 File 对象代表的文件是否是一个目录
boolean isFile() 判断 File 对象代表的文件是否是一个普通文件
boolean createNewFile() 根据 File 对象，自动创建一个空文件。成功创建后返 回 true
返回值 方法名 说明
boolean delete() 根据 File 对象，删除该文件。成功删除后返回 true
void deleteOnExit() 根据 File 对象，标注文件将被删除，删除动作会到 JVM 运行结束时才会进行
String[] list() 返回 File 对象代表的目录下的所有文件名
File[] listFiles() 返回 File 对象代表的目录下的所有文件，以 File 对象表示
boolean mkdir() 创建 File 对象代表的目录
boolean mkdirs() 创建 File 对象代表的目录，如果必要，会创建中间目录
boolean renameTo(File dest) 进行文件改名，也可以视为我们平时的剪切、粘贴操 作
boolean canRead() 判断用户是否对文件有可读权限
boolean canWrite() 判断用户是否对文件有可写权限

观察下面的代码:

示例一：

import java.io.File;
import java.io.IOException;
public class Demo1 {
    public static void main(String[] args) throws IOException {
        File file = new File("./test.txt");
        System.out.println(file.getName());//返回file对象的纯文件名
        System.out.println(file.getParent());//返回file对象的父目录文件路径
        System.out.println(file.getPath());//返回file对象的文件路径
        System.out.println(file.getAbsolutePath());//返回file对象的绝对路径
        System.out.println(file.getCanonicalPath());//返回file对象的修饰过的绝对路径
    }
}

示例二：

import java.io.File;
import java.io.IOException;
public class Demo2 {
    public static void main(String[] args) throws IOException {
        File file = new File("d:/test.txt");
        System.out.println(file.exists());//判断file对象描述的文件是否真实存在
        System.out.println(file.isDirectory());//判断file对象是否是一个目录
        System.out.println(file.isFile());//判断file对象是否是一个普通文件
        //创建一个text文件
        boolean newFile = file.createNewFile();
        System.out.println("newFile = "+newFile);
        System.out.println(file.exists());
        System.out.println(file.isDirectory());
        System.out.println(file.isFile());
    }
}

示例三：

import java.io.File;
public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        File file = new File("d:/test.txt");
//        boolean delete = file.delete();//删除file文件 成功则返回true
//        System.out.println(delete);
        //进程结束后删除file
        file.deleteOnExit();
        Thread.sleep(5000);//5秒后删除创建的test.txt
    }
}

示例四：

import java.io.File;
import java.util.Arrays;
public class Demo4 {
    public static void main(String[] args) {
        File file = new File("d:/");
        //返回file对象代表的的目录下所有的文件名 (包括一些隐藏的文件)
        String[] fs = file.list();
        System.out.println(Arrays.toString(fs));
    }
}

示例五：

import java.io.File;
public class Demo5 {
    public static void main(String[] args) {
        File file = new File("d:/aaa/bbb/ccc");
        //创建file对象代表的目录
        boolean mkdirs = file.mkdirs();
        System.out.println(mkdirs);
    }
}

示例六：

import java.io.File;
public class Demo6 {
    public static void main(String[] args) {
        //源文件
        File srcFile = new File("d:/test.txt");
        //目标文件
        File destFile = new File("d:/test1.txt");
        //将源文件名改成目标文件
        boolean renameTo = srcFile.renameTo(destFile);
        System.out.println(renameTo);
    }
}

示例七：

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Demo7 {
    public static void main(String[] args) {
        try (Writer writer = new FileWriter("d:/test1.txt",true)){
            //直接使用write写入数据
            writer.write("计算机操作系统IO");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

InputStream

InputStream 是一个抽象类，要使用还需要具体的实现类。关于 InputStream 的实现类有很多，基本可以认为不同的输入设备都可以对应一个 InputStream 类，我们现在只关心从文件中读取，所以使用 FileInputStream。

方法

返回值 方法名 说明
int read() 读取一个字节的数据，返回 -1 代表已经完全读完了
int read(byte[] b) 最多读取 b.length 字节的数据到 b 中，返回实际读到的数 量；-1 代表以及读完了
int read(byte[] b, int off, int len) 最多读取 len - off 字节的数据到 b 中，放在从 off 开始，返 回实际读到的数量；-1 代表以及读完了
void close() 关闭字节流

FileInputStream

构造方法

方法名 说明
FileInputStream(File file) 利用 File 构造文件输入流
FileInputStream(String name) 利用文件路径构造文件输入流

示例八：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class Demo8 {
    public static void main(String[] args) {
        try (InputStream inputStream = new FileInputStream("d:/test1.txt")) {
            byte[] buffer = new byte[1024];
            int read = inputStream.read(buffer);
            System.out.println(read);
            for (int i = 0; i < read; i++) {
                System.out.printf("%x\n",buffer[i]);//以十六进制打印文件里的内容
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

示例九：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Test {
    // 需要先在项目目录下准备好一个 test1.txt 的文件  里面填充 "Hello"
    public static void main(String[] args) throws IOException {
        try (InputStream is = new FileInputStream("d:/test1.txt")) {
            while (true) {
                int b = is.read();
                if (b == -1) {
                    break;
                }
                System.out.printf("%c", b);
            }
        }
    }
}

示例十：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Test {
    // 需要先在项目目录下准备好一个 test1.txt 的文件  里面填充 "Hello"
    public static void main(String[] args) throws IOException {
        try (InputStream is = new FileInputStream("d:/test1.txt")) {
            byte[] buf = new byte[1024];
            int len;
            while (true) {
                len = is.read(buf);
                if (len == -1) {
                    break;
                }
                for (int i = 0; i < len; i++) {
                    System.out.printf("%c", buf[i]);
                }
                // 每次使用 3 字节进行utf8解码 得到中文字符利用 String 中的构造方法完成
               // for (int i = 0; i < len; i+=3) {
                  //  String s = new String(buf, i, 3, "UTF-8");
                  //System.out.printf("%s", s);
                }
            }
        }
    }
}
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) throws IOException {
        try (InputStream is = new FileInputStream("d:/test1.txt")) {
            try (Scanner scanner = new Scanner(is, "UTF-8")) {
                while (scanner.hasNext()) {
                    String s = scanner.next();
                    System.out.print(s);
                }
            }
        }
    }
}

OutputStream

OutputStream 同样只是一个抽象类，要使用还需要具体的实现类。我们现在还是只关心写入文件中，所以使用 FileOutputStream。

返回值 方法名 说明
void write(int b) 写入要给字节的数据
void write(byte[] b) 将 b 这个字符数组中的数据全部写入 os 中
int write(byte[] b, int off, int len) 将 b 这个字符数组中从 off 开始的数据写入 os 中，一共写 len 个将 b 这个字符数组中从 off 开始的数据写入 os 中，一共写 len 个
void close() 关闭字节流
void flush() I/O 的速度是很慢的，所以，大多的 OutputStream 为 了减少设备操作的次数，在写数据的时候都会将数据先暂时写入内存的 一个指定区域里，直到该区域满了或者其他指定条件时才真正将数据写 入设备中，这个区域一般称为缓冲区。但造成一个结果，就是我们写的数据，很可能会遗留一部分在缓冲区中。需要在最后或者合适的位置， 调用 flush（刷新）操作，将数据刷到设备中。

利用 OutputStreamWriter 进行字符写入

示例一：

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        try (OutputStream os = new FileOutputStream("d:/test1.txt")) {
            os.write('H');
            os.write('e');
            os.write('l');
            os.write('l');
            os.write('o');
            os.flush();
        }
    }
}

示例二：

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        try (OutputStream os = new FileOutputStream("d:/test1.txt")) {
            byte[] b = new byte[]{
                    (byte) 'H', (byte) 'e', (byte) 'l', (byte) 'l',(byte) 'o'
            };
            os.write(b);
            os.flush();
        }
    }
}

示例三：

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        try (OutputStream os = new FileOutputStream("d:/test1.txt")) {
            byte[] b = new byte[]{
                    (byte) 'G', (byte) 'o', (byte) 'o', (byte) 'd', (byte) 'B',
                    (byte) 'a', (byte) 'd'
            };
            os.write(b, 0, 4); //Good
            os.flush();
        }
    }
}

示例四：

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        try (OutputStream os = new FileOutputStream("d:/test1.txt")) {
            String s = "hello word";
            byte[] b = s.getBytes();
            os.write(b);
            os.flush();
        }
    }
}

示例五：

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
public class Test {
    public static void main(String[] args) {
        try (OutputStream outputStream = new FileOutputStream("d:/test1.txt",true)) {
            //把字节流转为字符流
            PrintWriter printWriter = new PrintWriter(outputStream);
            printWriter.println("hello");
            //把写在缓冲区的数据冲入内存
            printWriter.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

总结

按字节读取数据

try (InputStream is = new FileInputStream("d:/test1.txt")) {
  byte[] buf = new byte[1024];
    int n;
  while (true) {
    n = is.read(buf);
    if (n == -1) {
      break;
    }
    // 处理读取到的数据
  }
}

按字节写入数据

try (OutputStream os = new FileOutputStream("d:/test1.txt")) {
  byte[] buf = new byte[1024];
  while (/* 还有未完成的业务数据 */) {
    // 将业务数据填入 buf 中，长度为 n
    int n = ...;
    os.write(buf, 0, n);
  }
    // 进行数据刷新操作
  os.flush(); 
}

按字符读取数据

try (InputStream is = new FileInputStream("d:/test1.txt")) {
  try (Scanner scanner = new Scanner(is, "UTF-8")) {
    while (scanner.hasNextLine()) {
      String line = scanner.nextLine();
      // 对line进行操作
    }
  }
}

按字符写入数据

try (OutputStream os = new FileOutputStream("d:/test1.txt")) {
  try (OutputStreamWriter osWriter = new OutputStreamWriter(os, "UTF-8")) {
    try (PrintWriter writer = new PrintWriter(osWriter)) {
      while (/* 还有未完成的业务数据 */) {
        writer.println(...);
      }
            // 进行数据刷新操作
      writer.flush(); 
    }
  }
}
文章标签：
Java
关键词：
文件io
io文件
io file
io file类
io类
努力的小徐
目录
相关文章
三三是该溜子
|
1天前
|
存储 Java API
【JavaEE】——文件IO（万字长文）
文件路径，文本文件，二进制文件，File类，文件流，字节流（InputStream，OutputStream）字符流(Reader,Writer)
三三是该溜子
12 0
六月的雨在钉钉
|
1月前
|
Java 测试技术 Maven
Maven clean 提示文件 java.io.IOException
在使用Maven进行项目打包时，遇到了`Failed to delete`错误，尝试手动删除目标文件也失败，提示`java.io.IOException`。经过分析，发现问题是由于`sys-info.log`文件被其他进程占用。解决方法是关闭IDEA和相关Java进程，清理隐藏的Java进程后重新尝试Maven clean操作。最终问题得以解决。总结：遇到此类问题时，可以通过任务管理器清理相关进程或重启电脑来解决。
六月的雨在钉钉
52 5
杀死一只知更鸟debug
|
3月前
|
存储 Java
序列化流 ObjectInputStream 和 ObjectOutputStream 的基本使用【 File类+IO流知识回顾④】
这篇文章介绍了Java中ObjectInputStream和ObjectOutputStream类的基本使用，这两个类用于实现对象的序列化和反序列化。文章解释了序列化的概念、如何通过实现Serializable接口来实现序列化，以及如何使用transient关键字标记不需要序列化的属性。接着，通过示例代码演示了如何使用ObjectOutputStream进行对象的序列化和ObjectInputStream进行反序列化。
杀死一只知更鸟debug
67 2
序列化流 ObjectInputStream 和 ObjectOutputStream 的基本使用【 File类+IO流知识回顾④】
椰椰椰耶
|
2月前
|
搜索推荐 索引
【文件IO】实现：查找文件并删除、文件复制、递归遍历目录查找文件
【文件IO】实现：查找文件并删除、文件复制、递归遍历目录查找文件
椰椰椰耶
50 2
椰椰椰耶
|
2月前
|
编解码 Java 程序员
【文件IO】文件内容操作
【文件IO】文件内容操作
椰椰椰耶
60 2
椰椰椰耶
|
2月前
|
存储 Java API
【文件IO】文件系统操作
【文件IO】文件系统操作
椰椰椰耶
53 1
椰椰椰耶
|
2月前
|
存储 Java 程序员
【Java】文件IO
【Java】文件IO
椰椰椰耶
42 0
热爱技术的小郑
|
4月前
|
存储 Java
【IO面试题 四】、介绍一下Java的序列化与反序列化
Java的序列化与反序列化允许对象通过实现Serializable接口转换成字节序列并存储或传输，之后可以通过ObjectInputStream和ObjectOutputStream的方法将这些字节序列恢复成对象。
热爱技术的小郑
60 2
weixin_836869520
|
5月前
|
Java 大数据
解析Java中的NIO与传统IO的区别与应用
解析Java中的NIO与传统IO的区别与应用
weixin_836869520
97 1
Java开发者
|
3月前
|
Java 大数据 API
Java 流(Stream)、文件(File)和IO的区别
Java中的流（Stream）、文件（File）和输入/输出（I/O）是处理数据的关键概念。`File`类用于基本文件操作，如创建、删除和检查文件；流则提供了数据读写的抽象机制，适用于文件、内存和网络等多种数据源；I/O涵盖更广泛的输入输出操作，包括文件I/O、网络通信等，并支持异常处理和缓冲等功能。实际开发中，这三者常结合使用，以实现高效的数据处理。例如，`File`用于管理文件路径，`Stream`用于读写数据，I/O则处理复杂的输入输出需求。
Java开发者
246 12