蓝旭春季培训第三周预习博客（Java IO流）

JavaIO流

File类

在Java中，File 类是 java.io 包的一部分，它用于表示文件和目录的路径名。File 类本身并不直接涉及文件的读取或写入操作，但它提供了用于创建、删除、查询文件和目录的方法。这使得 File 类成为文件I/O操作的一个重要组成部分，因为它帮助开发者管理和操作文件系统的文件和目录。

注意：File 类只能操作文件的属性，文件的内容是不能操作的。

构造方法

1. File(File parent,String child)：父抽象路径名和子路径名字符串创建新的 File 实例。
2. File(String pathname)：通过将给定的路径名字符串转换为抽象路径名来创建新的 File 实例。
3. File(String parent,String child)：从父路径名字符串和子路径名字符串创建新的 File 实例。
4. File(URI url)：通过将给定的 file:URL 转换为抽象路径名来创建新的 File 实例。

package test2;

import java.io.File;
import java.net.URI;
import java.net.URISyntaxException;

public class IoTest {
    public static void main(String[] args) {
        File file = new File("kunkun");
        File fileChild = new File(file, "ikun");
        File fileChild2=new File("/kunkun/ikun","basketball.txt");
        System.out.println("file文件路径"+file.getAbsolutePath());
        System.out.println("fileChild文件路径"+fileChild.getAbsolutePath());
        System.out.println("fileChild2文件路径"+fileChild2.getAbsolutePath());
        try {
            URI fileURL=new URI("file:/kunkun/ikun");
            File file2=new File(fileURL);
            System.out.println("file2文件路径"+file2.getAbsolutePath());
        }catch (URISyntaxException e){
            //处理异常
            e.printStackTrace();
        }

    }
}

运行结果

file文件路径E:\Java\java practise\practise\kunkun
fileChild文件路径E:\Java\java practise\practise\kunkun\ikun
fileChild2文件路径E:\kunkun\ikun\basketball.txt
file2文件路径E:\kunkun\ikun

常用方法

• exists(): 检查此 File 表示的文件或目录是否实际存在。
• isFile(): 判断此 File 是否表示一个文件（而不是目录）。
• isDirectory(): 判断此 File 是否表示一个目录（而不是文件）。
• getName(): 返回由此抽象路径名表示的文件或目录的名称。
• getPath(): 返回此抽象路径名的路径名字符串。
• getAbsolutePath(): 返回此抽象路径名的绝对路径名字符串。
• length(): 返回此抽象路径名表示的文件的长度（以字节为单位）。
• lastModified(): 返回此抽象路径名表示的文件最后一次被修改的时间。
• createNewFile(): 当且仅当不存在具有此抽象路径名的文件时，创建一个新的空文件。
• mkdir(): 创建此抽象路径名指定的目录。
• mkdirs(): 创建此抽象路径名指定的目录，包括创建必需但不存在的父目录。
• delete(): 删除此抽象路径名表示的文件或目录。
• listFiles(): 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件和目录。
• renameTo(File dest): 重命名此抽象路径名表示的文件。
• canRead(), canWrite(), canExecute(): 测试应用程序是否可以读取、写入或执行此抽象路径名表示的文件

package test2;

import java.io.File;
import java.net.URI;
import java.net.URISyntaxException;
import java.io.IOException;

public class IoTest {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\homework\\kunkun");
        File fileChild = new File(file, "ikun");
        File file1 = new File("E:\\homework\\kunkun\\ikun\\rapper.txt");
        //创建一个文件并返回创建结果
        boolean result=file1.createNewFile();
        File fileChild2 = new File("E:\\homework\\kunkun\\ikun", "basketball.txt");
        //获取绝对路径
        System.out.println("file文件路径" + file.getAbsolutePath());
        System.out.println("fileChild文件路径" + fileChild.getAbsolutePath());
        System.out.println("file1文件"+result+" " + file1.getAbsolutePath());
        System.out.println("fileChild2文件路径" + fileChild2.getAbsolutePath());
        try {
            URI fileURL = new URI("file:\\E:\\homework\\kunkun\\ikun\\new.txt");
            File file2 = new File(fileURL);
            System.out.println("file2文件路径" + file2.getAbsolutePath());
        } catch (URISyntaxException e) {
            //处理异常
            e.printStackTrace();
        }
        //判断文件是否存在
        if (fileChild2.exists()) {
            System.out.println("fileChild2文件存在");
        } else {
            System.out.println("fileChild2文件不存在");
        }
        //判断file是文件还是目录
        if (file.isFile()) {
            System.out.println("file是文件");
        } else {
            System.out.println("file是目录");
        }
        //获取文件大小
        long length = fileChild2.length();
        System.out.println("fileChild2 length是 " + length + " bytes.");
        //获取文件最后一次修改的时间
        long lastModify = fileChild2.lastModified();
        System.out.println("最后一次修改的时间是" + new java.util.Date(lastModify));

    }
}

运行结果：

file文件路径E:\homework\kunkun
fileChild文件路径E:\homework\kunkun\ikun
file1文件true E:\homework\kunkun\ikun\rapper.txt
fileChild2文件路径E:\homework\kunkun\ikun\basketball.txt
fileChild2文件存在
file是目录
fileChild2 length是 12 bytes.
最后一次修改的时间是Fri Apr 05 10:15:10 CST 2024

Path接口

在Java中，Path接口是java.nio.file包的一部分，它代表了文件系统中的路径。与java.io.File类相比，Path接口提供了更强大、更灵活的文件系统操作功能，并且支持更多的文件系统特性，包括符号链接和更复杂的文件属性查询。

构造和获取Path对象

使用Paths类的静态方法get来构造一个Path对象

Path path = Paths.get(“path/to/file.txt”);

通过File对象来获取一个Path对象

Path path = file.toPath();

查询路径信息

• getFileName(): 返回路径中的最后一部分（文件名或目录名）。
• getParent(): 返回路径的父路径。
• getRoot(): 返回路径的根组件。
• toAbsolutePath(): 返回此路径的绝对路径。
• toRealPath(LinkOption…): 解决路径中的任何符号链接，返回路径的真实路径。

package test2;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class IoTest {
    public static void main(String[] args) throws IOException {


        /*
        1.getFileName(): 返回路径中的最后一部分（文件名或目录名）。
        2.getParent(): 返回路径的父路径。
        3.getRoot(): 返回路径的根组件。
        4.toAbsolutePath(): 返回此路径的绝对路径。
         */

        Path path = Paths.get("E:homework\\kunkun\\ikun\\dancing.txt");
        System.out.println("path路径->" + path);
        System.out.println("文件名->" + path.getFileName());
        System.out.println("父路径->" + path.getParent());
        System.out.println("根组件->" + path.getRoot());
        System.out.println("绝对路径->" + path.toAbsolutePath());

    }
}

运行结果

path路径->E:homework\kunkun\ikun\dancing.txt
文件名->dancing.txt
父路径->E:homework\kunkun\ikun
根组件->E:
绝对路径->E:\Java\java practise\practise\homework\kunkun\ikun\dancing.txt

文件和目录检查

• toFile(): 返回表示此路径的File对象。
• isAbsolute(): 检查此路径是否是绝对的。
• isDirectory(LinkOption…): 检查此路径是否是一个目录。
• isFile(LinkOption…): 检查此路径是否是一个文件。

遍历目录和文件

• iterate(): 返回一个目录流，用于遍历目录内容。

package test2;

import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class IoTest {
    public static void main(String[] args) {
        Path directory = Paths.get("directory");
        try(DirectoryStream<Path> stream= Files.newDirectoryStream(directory)) {
            for(Path path:stream){
                System.out.println(path);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• Files.walk(Path start, FileVisitOption… options): 遍历目录树。
• try (Stream<Path> paths = Files.walk(startPath, FileVisitOption.NOFOLLOW_LINKS)) { // ... }
  注：当处理大量文件或目录时，使用 Files.walk() 可能会消耗大量内存，因为它会立即加载整个目录树。在这种情况下，你可以使用 Files.walkFileTree() 方法，它提供了一个更灵活的遍历方式，允许你控制遍历的深度，以及处理每个文件和目录时的行为。

文件操作

• Files.createDirectories(Path dir): 创建目录，包括任何必要的父目录。
• Files.delete(Path path): 删除文件或目录。
• Files.copy(Path source, Path target, CopyOption… options): 复制文件或目录。
• Files.move(Path source, Path target, CopyOption… options): 移动或重命名文件或目录。
• Files.readAllLines(Path path): 读取文件的所有行到列表中。
• Files.write(Path path, byte[] bytes): 将字节写入文件。

package test2;


import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

public class IoTest {
    public static void main(String[] args) throws IOException {
        
        //Files.createDirectories(Path dir): 创建目录，包括任何必要的父目录。
        
        Path dir= Paths.get("kunkun\\ikun\\directory");
        Files.createDirectories(dir);
        
        //- Files.delete(Path path): 删除文件或目录。
        
        Path delDir=Paths.get("kunkun\\ikun\\directory");
        Files.delete(delDir);
        
        //- Files.copy(Path source, Path target, CopyOption... options): 复制文件或目录。
        
        Path source=Paths.get("kunkun\\ikun\\dance.txt");
        Path target=Paths.get("kunkun\\ikun\\basket.txt");
        Files.copy(source,target);
        
        // - Files.readAllLines(Path path): 读取文件的所有行到列表中。
        
        Path file = Paths.get("kunkun\\ikun\\dance.txt");
        List<String> lines = Files.readAllLines(file);
        
        //- Files.write(Path path, byte[] bytes): 将字节写入文件。
        
        Path file1 = Paths.get("kunkun\\ikun\\file1.bin");
        byte[] data = new byte[]{1, 2, 3, 4};
        Files.write(file1, data);

    }
}

流

1. 创建流对象：根据需求创建合适的输入流或输出流对象。
2. 进行读写操作：使用流对象的方法读取或写入数据。
3. 关闭流：在完成IO操作后，记得关闭流以释放资源

字节流（Byte Streams）

1. 字节流主要用于处理二进制数据。
2. 主要类：InputStream 和 OutputStream 是所有字节输入流和输出流的超类。
3. 常见的实现类：FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream、DataInputStream、DataOutputStream 等

字节输入流

import java.io.FileInputStream;  
import java.io.IOException;  
  
public class FileInputStreamExample {  
    public static void main(String[] args) {  
        String filePath = "home\\kunkun\\ikun\\ko.txt"; // 替换为你的文件路径  
        FileInputStream inputStream = null;  
          
        try {  
            inputStream = new FileInputStream(filePath);  
            int data;  
            while ((data = inputStream.read()) != -1) {  
                // 将读取到的字节转换为字符并打印
                System.out.print((char) data);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            if (inputStream != null) {  
                try {  
                    inputStream.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  
}

字节输出流

import java.io.FileOutputStream;  
import java.io.IOException;  
  
public class FileOutputStreamExample {  
    public static void main(String[] args) {  
        String filePath = "outkunkun.txt"; // 输出文件的路径  
        byte[] data = "Hello, Outkunkun!".getBytes(); // 要写入的数据  
        FileOutputStream outputStream = null;  
          
        try {  
            outputStream = new FileOutputStream(filePath);  
            outputStream.write(data); // 将数据写入文件  
            System.out.println("数据成功写入.");  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            if (outputStream != null) {  
                try {  
                    outputStream.close(); // 关闭流并释放资源  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  
}

字符流（Character Streams）

1. 字符流主要用于处理文本数据。
2. 主要类：Reader 和 Writer 是所有字符输入流和输出流的超类。
3. 常见的实现类：FileReader、FileWriter、BufferedReader、BufferedWriter、InputStreamReader、OutputStreamWriter 等。

注：

1. 使用流时，通常遵循“先开后关”的原则，即先使用 new 关键字创建流对象，使用完毕后调用其 close() 方法关闭流。
2. 为了提高性能，Java 提供了缓冲流（如 BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter），它们可以一次性读取或写入多个字节或字符，减少了与底层 IO 设备的交互次数。
3. 对于需要从字节流中读取字符或从字符流中写入字节的情况，可以使用 InputStreamReader和 OutputStreamWriter 作为桥梁

字符输入流

import java.io.FileReader;  
import java.io.IOException;  
  
public class CharacterInputStreamExample {  
    public static void main(String[] args) {  
        String fileName = "kunkun.txt"; // 要读取的文件名  
        FileReader fr = null;  
  
        try {  
            // 创建 FileReader 对象来读取文件  
            fr = new FileReader(fileName);  
  
            // 读取字符直到文件的末尾  
            int character;  
            while ((character = fr.read()) != -1) {  
                // 将读取到的字符转换为对应的字符并输出  
                System.out.print((char) character);  
            }  
        } catch (IOException e) {  
            // 处理可能发生的异常  
            e.printStackTrace();  
        } finally {  
            // 关闭流  
            try {  
                if (fr != null) {  
                    fr.close();  
                }  
            } catch (IOException ex) {  
                ex.printStackTrace();  
            }  
        }  
    }  
}

字符输出流

import java.io.BufferedWriter;  
import java.io.FileWriter;  
import java.io.IOException;  
  
public class BufferedWriterExample {  
    public static void main(String[] args) {  
        String fileName = "outko.txt";  
        String data = "Hello, world!";  
        BufferedWriter writer = null;  
          
        try {  
            writer = new BufferedWriter(new FileWriter(fileName));  
            writer.write(data);  
            writer.newLine(); // 写入一个新行  
            writer.write("另一行.");  
            System.out.println("使用BufferedWriter写入文件的数据.");  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            if (writer != null) {  
                try {  
                    writer.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  
}