一篇文章带你爆杀Javase-IO流部分！

014.

于 2024-05-05 22:18:47 发布

阅读量976

点赞数 20

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2301_79104307/article/details/138475331

版权

一、知识点

文件、IO流。

二、目标

掌握File类常用API。
掌握IO流常用类的使用。
掌握字符流和字节流的区别。

三、内容分析

重点
- File类。
- IO流常用类。
难点
- 灵活使用字符流、字节流。

四、内容

1、文件

File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法。比如我们做一个上传图片的功能，使用日期作为文件夹，那么我们就需要File类来动态创建文件夹。

1.1 获取文件信息

File file = new File("D:\\xxx\\xx\\1.txt");

System.out.println(file.getName()); // 获取文件名
System.out.println(file.exists()); // 判断文件是否存在
System.out.println(file.getParent()); // 获取文件父级路径
System.out.println(file.isDirectory()); // 判断是否是文件夹
System.out.println(file.isFile()); // 判断是否是文件

1.2 创建文件

File file = new File("D:\\xxx\\xx\\1.txt");

// 判断本地硬盘中是否在已经存在要创建的文件
if(!file.exists()) {
    try {
        file.createNewFile();
    } catch (IOException e) {
        e.printStackTrace(); // 当系统路径不存在时抛异常
    }
}

1.3 创建目录

File file = new File("D:\\xxx\\xx\\test");

if(!file.exists()) {
    file.mkdir(); // 创建单级目录
}

File file1 = new File("D:\\xxx\\xx\\test1\\test2");

if(!file1.exists()) {
    boolean sign = file1.mkdirs(); // 创建多级目录
    System.out.println(sign);
}

1.4 删除文件

File file = new File("D:\\xxx\\xx\\1.txt");

if(file.exists()) {			
    file.delete();
}

1.5 文件重命名

File file = new File("D:\\xxx\\xx\\1.txt");
File file1 = new File("D:\\xxx\\xx\\2.txt");

if(file.exists()) {			
    file.renameTo(file1);
}

1.6 文件获取

File file = new File("D:\\xxx\\xx");

String[] strArr = file.list(); // 获取目录下所有的文件夹/文件名

for(String str:strArr) {
    System.out.println(str);
}

File[] fileArr = file.listFiles(); // 获取目录下所有的文件对象
for(File f:fileArr) {
    System.out.println(f.getName());
}

2、IO流

java的IO（input/output）是实现输入和输出的基础，可以方便的实现数据的输入和输出操作。

在java中把不同的输入/输出源（键盘，文件，网络连接等）抽象表述为“流”(stream)。

通过流的形式允许java程序使用相同的方式来访问不同的输入/输出源。

流是一种有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两个设备间的传输成为流，流的本质是数据传输。

在java.io包中操作文件内容主要有两大类：字节流、字符流，两类都分为输入和输出操作。

如果是音频文件、图片、歌曲、就用字节流好点，如果关系到中文的，用字符流好点。字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串，字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流可以。

2.1 字符流

2.1.1 字符输出流

FileWriter，BufferedWriter是字符输出流常用的类。

FileWriter

字符输出流。

FileWriter writer = null;

try {

    // 构造器可以直接接收路径字符串，也可以接收Flie文件对象
    // fileWriter = new FileWriter(new File("D:\\xxx\\xxx\\1.txt"));
    writer = new FileWriter("D:\\xxx\\xxx\\1.txt");
    writer.write("abc"); // 写入字符串
    writer.write("abcdef", 2, 2); // 写入内容的时候可以只截取部分写入，写入cd
    writer.write(new char[]{'a', 'b', 'c'}); // 写入字符数组
    writer.write(new char[]{'a', 'b', 'c', 'd', 'e'}, 2, 2);
    writer.write(99); // Ascii码值

} catch (IOException e) {
    e.printStackTrace();
} finally {
    if(fileWriter != null) {
        try {
            fileWriter.close(); // 记得关闭资源
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

BufferedWriter

高效字符输出流，使用方法基本与FileWriter相同。

BufferedWriter writer = new BufferedWriter(new FileWriter("D:\\xxx\\xxx\\1.txt"));

writer.write("abc");
writer.write("abcdef", 2, 2);
writer.write(new char[]{'a', 'b', 'c'});
writer.write(new char[]{'a', 'b', 'c', 'd', 'e'}, 2, 2);
writer.write(99);
writer.newLine(); // 换行

FileWriter和BufferedWriter区别
FileWriter和BufferWriter写入的都是字符流;
FileWriter和BufferWriter都有缓冲区，FileWriter的缓冲区大小是8192个字节，BufferWriter缓冲区大小是8192个字符;
FileWriter和BufferWriter调用write方法时都没有真正往硬盘里写数据，存入的都是缓冲区，只有调用flush或者close时才会刷新缓冲区并写入硬盘；
FileWriter每调用一次write就会进行一次转码，而BufferedWriter只有在缓冲区满了才会转码，这才是BufferedWriter高效的真正原因。

2.1.2 字符输入流

FileReader，BufferedReader是字符输入流常用的类。

FileReader

字符输入流。

read() : 每调用一次read()就返回一个字符对应的ascii码，如果结束就返回-1。

read(字符数组): 传入字符数组接收读取到的内容，返回读取到的个数，如果结束就返回-1。

// read()
FileReader reader = null;

try {
    reader = new FileReader("D:\\xxx\\xxx\\1.txt");

    int num1 = reader.read(); // 返回值ascii
    System.out.println((char)num1); // ascii码强转为字符
    int num2 = reader.read();
	System.out.println((char)num2);

    // 循环读取，获取文件全部的内容
    int num = -1;
    while((num = reader.read()) != -1) {
    		System.out.print((char)num);
    }
    
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        reader.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

// read(字符数组)
FileReader reader = null;

try {
    reader = new FileReader("D:\\xxx\\xxx\\1.txt");

    //    char[] c = new char[3];
    //    reader.read(c);
    //    System.out.println(new String(c));
    //    reader.read(c);
    //    System.out.println(new String(c));
    //    reader.read(c);
    //    System.out.println(new String(c));
    //    reader.read(c);
    //    System.out.println(new String(c));
    
    //    获取真实数据
    //    char[] c = new char[3];
    //    int num1 = fileReader.read(c);
    //    System.out.println(new String(c, 0, num1));
    //    int num2 = fileReader.read(c);
    //    System.out.println(new String(c, 0, num2));
    //    int num3 = fileReader.read(c);
    //    System.out.println(new String(c, 0, num3));

    // 数据过多循环读取全部内容
    char[] c = new char[3];
    int num = -1;
    while((num = reader.read(c)) != -1) {
        System.out.print(new String(c,0, num)); // 利用String构造器把字符数组转为字符串
    }

} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        reader.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

BufferedReader

高效字符输入流，使用方法与FileReader相似，多了一个readLine()，直接读取一行。

BufferedReader reader = new BufferedReader(new FileReader("D:\\xxx\\xxx\\1.txt"));

String str = null;
while((str = reader.readLine()) != null) {
    System.out.println(str);
}

2.2 字节流

2.2.1 字节输出流

FileOutputStream，BufferedOutputStream是字节输出流常用的类。

FileOutputStream

OutputStream outputStream = new FileOutputStream("D:\\xxx\\xxx\\1.txt");

outputStream.write(new byte[]{97,98,99});

BufferedOutputStream

BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream("D:\\xxx\\xxx\\1.txt"));

outputStream.write(new byte[]{97,98,99});

2.2.2 字节输入流

FileInputStream，BufferedInputStream是字节输入流常用的类。

FileInputStream

InputStream inputStream = new FileInputStream("D:\\xxx\\xxx\\1.txt");

byte[] bt = new byte[3];
int num = -1;
while((num = inputStream.read(bt)) != -1) {
    System.out.print(new String(bt,0, num));
}

BufferedInputStream

BufferedInputStream input = new BufferedInputStream(new FileInputStream("D:\\xxx\\xxx\\1.txt"));

byte[] bt = new byte[3];
int num = -1;
while((num = input.read(bt)) != -1) {
    System.out.println(new String(bt, 0, num));
}

案例：实现复制文件。

BufferedInputStream input = null;
BufferedOutputStream output = null;
try {

    input = new BufferedInputStream(new FileInputStream("D:\\xxx\\xxx\\1.txt"));
    output = new BufferedOutputStream(new FileOutputStream("D:\\xxx\\xxx\\2.txt"));

    byte[] bt = new byte[1024 * 30];
    int num = -1;
    while((num = input.read(bt)) != -1) {
        System.out.println(num);
        output.write(bt, 0, num);
    }

} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if(input != null) {
            input.close();
        }
        if(output != null) {
            output.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

本小节主要介绍Java操作文件的相关方法，主要用于处理数据的传输，也是Java中的核心内容之一，需要注意区分IO流相关类。