java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java I/O流

Java I/O流使用示例详解

作者：世界尽头与你

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。本文将通过示例为大家详细讲讲 I/O流的使用教程，需要的可以参考一下

1.java IO包

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。

Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

文件依靠流进行传输，就像快递依托于快递员进行分发

Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。

下图是一个描述输入流和输出流的类层次图。

2.创建文件

方式一：

/**
 * 创建文件，第一种方式
 */
@Test
public void createFile01() {
    String filePath = "D://1.txt";
    File file = new File(filePath);
    try {
        file.createNewFile();
        System.out.println("文件创建成功！");
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

第二种方式：

/**
 * 创建文件，第二种方式
 */
@Test
public void createFile02() {
    File parentFile = new File("D:\\");
    String fileName = "news.txt";
    File file = new File(parentFile, fileName);
    try {
        file.createNewFile();
        System.out.println("文件创建成功！");
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

第三种方式：

/**
 * 创建文件，第三种方式
 */
@Test
public void createFile03() {
    String parentPath = "D:\\";
    String fileName = "my.txt";
    File file = new File(parentPath, fileName);
    try {
        file.createNewFile();
        System.out.println("文件创建成功！");
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

3.获取文件信息

示例代码：

/**
 * 获取文件信息
 */
@Test
public void info() {
    // 创建文件对象
    File file = new File("D:\\news.txt");
    // 获取文件名字
    System.out.println(file.getName());
    // 获取文件路径
    System.out.println(file.getAbsolutePath());
    // 获取文件父亲目录
    System.out.println(file.getParent());
    // 获取文件大小（字节）
    System.out.println(file.length());
    // 文件是否存在
    System.out.println(file.exists());
    // 是不是一个文件
    System.out.println(file.isFile());
    // 是不是一个目录
    System.out.println(file.isDirectory());
}

4.目录操作

案例一：判断指定目标是否存在，如果存在就删除

// 判断指定目标是否存在，如果存在就删除
String filePath = "D:\\news.txt";
File file = new File(filePath);
if (file.exists()) {
    if (file.delete()) {
        System.out.println("删除成功！");
    } else {
        System.out.println("删除失败！");
    }
} else {
    System.out.println("文件不存在！");
}

案例二：判断目录是否存在，如果存在即删除

// 判断目录是否存在，如果存在即删除
String dirPath = "D:\\demo";
File file1 = new File(dirPath);
if (file1.exists()) {
    if (file1.delete()) {
        System.out.println("删除成功！");
    } else {
        System.out.println("删除失败！");
    }
} else {
    System.out.println("目录不存在！");
}

案例三：判断指定目录是否存在，不存在就创建目录

// 判断指定目录是否存在，不存在就创建目录
String persondir = "D:\\demo\\a\\b\\c";
File file2 = new File(persondir);
if (file2.exists()) {
    System.out.println("该目录存在！");
} else {
    if (file2.mkdirs()) {
        System.out.println("目录创建成功！");
    } else {
        System.out.println("目录创建失败！");
    }
}

注意：创建多级目录，使用mkdirs，创建一级目录使用mkdir

5.字节输入流InputStream

InputStream抽象类是所有类字节输入流的超类

FileInputStream

文件输入流，从文件中读取数据，示例代码：

单个字节的读取，效率较低：

/**
 * read()读文件
 */
@Test
public void readFile01() throws IOException {
    String filePath = "D:\\hacker.txt";
    int readData = 0;
    FileInputStream fileInputStream = null;
    try {
        fileInputStream = new FileInputStream(filePath);
        // 读文件，一个字符一个字符读取，返回字符的ASCII码，文件尾部返回-1
        while ((readData = fileInputStream.read()) != -1) {
            System.out.print((char)readData);
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        // 关闭流资源
        fileInputStream.close();
    }
}

注意：使用字节流的方式，无法读取文件中的中文字符，如需读取中文字符，最好使用字符流的方式

使用byte数组的方式读取，这使得可以读取中文，并且有效的提升读取效率：

/**
 * read(byte[] b)读文件
 * 支持多字节读取，提升效率
 */
@Test
public void readFile02() throws IOException {
    String filePath = "D:\\hacker.txt";
    int readData = 0;
    int readLen = 0;
    // 字节数组
    byte[] bytes = new byte[8]; // 一次最多读取8个字节

    FileInputStream fileInputStream = null;
    try {
        fileInputStream = new FileInputStream(filePath);
        // 读文件，从字节数组中直接读取
        // 如果读取正常，返回实际读取的字节数
        while ((readLen = fileInputStream.read(bytes)) != -1) {
            System.out.print(new String(bytes, 0, readLen));
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        // 关闭流资源
        fileInputStream.close();
    }
}

6.字节输出流FileOutputStream

使用示例：（向hacker.txt文件中加入数据）

/**
 * FileOutputStream数据写入文件
 * 如果该文件不存在，则创建该文件
 */
@Test
public void writeFile() throws IOException {
    String filePath = "D:\\hacker.txt";
    FileOutputStream fileOutputStream = null;
    try {
        fileOutputStream = new FileOutputStream(filePath);
        // 写入一个字节
        // fileOutputStream.write('G');
        // 写入一个字符串
        String s = "hello hacker!";
        // fileOutputStream.write(s.getBytes());
        // 写入字符串指定范围的字符
        fileOutputStream.write(s.getBytes(),0,3);
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    } finally {
        assert fileOutputStream != null;
        fileOutputStream.close();
    }
}

我们发现，使用这样的FileOutputStream构造器无法实现向文件中追加内容，只能进行覆盖，我们可以在初始化对象的时候这样解决：

fileOutputStream = new FileOutputStream(filePath,true);

7.模拟文件拷贝

我们可以结合字节输入和输出流模拟一个文件拷贝的程序：

/**
 * 文件拷贝
 * 思路：
 * 创建文件的输入流，将文件读取到程序
 * 创建文件的输出流，将读取到的文件数据写入到指定的文件
 */
@Test
public void Copy() throws IOException {
    String srcFilePath = "D:\\hacker.txt";
    String destFilePath = "D:\\hello.txt";
    FileInputStream fileInputStream = null;
    FileOutputStream fileOutputStream = null;
    try {
        fileInputStream = new FileInputStream(srcFilePath);
        fileOutputStream = new FileOutputStream(destFilePath);
        // 定义字节数组，提高效率
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = fileInputStream.read(buf)) != -1) {
            // 边读边写
            fileOutputStream.write(buf, 0, readLen);
        }
        System.out.println("拷贝成功！");
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        if (fileInputStream != null){
            fileInputStream.close();
        }
        if (fileOutputStream != null) {
            fileOutputStream.close();
        }
    }
}

8.字符输入流FileReader

字符输入流FileReader用于从文件中读取数据

示例：

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

/**
 * 字符输出流
 */
public class FileWriteTest {
    public static void main(String[] args) throws IOException {
        String filePath = "D:\\hacker.txt";
        // 创建对象
        FileWriter fileWriter = null;
        try {
            char[] chars = {'a', 'b', 'c'};
            fileWriter = new FileWriter(filePath, true);
            // 写入单个字符
            // fileWriter.write('H');
            // 写入字符数组
            // fileWriter.write(chars);
            // 指定数组的范围写入
            // fileWriter.write(chars, 0, 2);
            // 写入字符串
            // fileWriter.write("解放军万岁！");
            // 指定字符串的写入范围
            fileWriter.write("hacker club", 0, 5);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            // FileWriter是需要强制关闭文件或刷新流的，否则数据会保存失败
            fileWriter.close();
        }
    }
}

9.字符输出流FileWriter

字符输出流FileWrite用于写数据到文件中：

示例：

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

/**
 * 字符输出流
 */
public class FileWriteTest {
    public static void main(String[] args) throws IOException {
        String filePath = "D:\\hacker.txt";
        // 创建对象
        FileWriter fileWriter = null;
        try {
            char[] chars = {'a', 'b', 'c'};
            fileWriter = new FileWriter(filePath, true);
            // 写入单个字符
            // fileWriter.write('H');
            // 写入字符数组
            // fileWriter.write(chars);
            // 指定数组的范围写入
            // fileWriter.write(chars, 0, 2);
            // 写入字符串
            // fileWriter.write("解放军万岁！");
            // 指定字符串的写入范围
            fileWriter.write("hacker club", 0, 5);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            // FileWriter是需要强制关闭文件或刷新流的，否则数据会保存失败
            fileWriter.close();
        }
    }
}

使用FileWriter，记得关闭文件或者刷新流！

到此这篇关于Java I/O流使用示例详解的文章就介绍到这了,更多相关Java I/O流内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文