File文件操作类

Java中的File类是用来操作文件和目录的类，它提供了一系列方法来创建、删除、重命名、判断文件是否存在等操作。

//先创建文件对象
File file = new File("e:\\news1.txt");

//调用相应的方法，得到对应信息
System.out.println("文件名字=" + file.getName());
//getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory
System.out.println("文件绝对路径=" + file.getAbsolutePath());
System.out.println("文件父级目录=" + file.getParent());
System.out.println("文件大小(字节)=" + file.length());
System.out.println("文件是否存在=" + file.exists());//T
System.out.println("是不是一个文件=" + file.isFile());//T
System.out.println("是不是一个目录=" + file.isDirectory());//F

IO流原理及流的分类

Java中的IO流是用来处理输入输出的机制。它允许程序通过流的方式读取和写入数据。

流是一种数据传输的方式，数据在程序和外部设备之间通过流进行传输。

流可以分为输入流和输出流，输入流用于从外部设备读取数据，输出流用于向外部设备写入数据。

IO流按传输数据类型不同可分为字节流和字符流两种类型。字节流以字节为单位进行数据传输，适用于处理二进制数据，如图片、音频等。字符流以字符为单位进行数据传输，适用于处理文本数据。

IO流按是否封装可以分为节点流和处理流（封装流）。

节点流是直接与数据源或目标进行连接的流，它们是最基本的流类型。节点流可以从文件、内存、网络等数据源读取数据，或将数据写入文件、内存、网络等目标。常见的节点流包括FileInputStream、FileOutputStream、FileReader、FileWriter等。

处理流是对节点流的包装，通过对节点流进行包装，处理流可以提供更高级的功能。处理流本身不具备读写数据的能力，它们通过包装节点流来实现数据的读写操作。处理流可以进行数据的过滤、转换、缓冲等操作，使得数据的处理更加方便和高效。常见的处理流包括BufferedInputStream、BufferedOutputStream、ObjectInputStream、ObjectOutputStream等。

节点流

FileInputStream

FileInputStream是用于读取文件的字节流类。它继承自InputStream抽象类，可以用于从文件中读取字节数据。

读取字节数据方式一：

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamExample {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("file.txt"); // 创建FileInputStream对象，指定要读取的文件名
            int data;
            while ((data = fis.read()) != -1) { // 读取文件中的一个字节数据，直到文件末尾
                System.out.print((char) data); // 将字节数据转换为字符并输出
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null) {
                    fis.close(); // 关闭流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

读取字节数据方式二：

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamExample {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("file.txt"); // 创建FileInputStream对象，指定要读取的文件名
            byte[] buffer = new byte[1024]; // 创建一个字节数组作为缓冲区
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) { // 读取文件中的字节数据到缓冲区
                for (int i = 0; i < bytesRead; i++) {
                    System.out.print((char) buffer[i]); // 将字节数据转换为字符并输出
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null) {
                    fis.close(); // 关闭流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileOutputStream

FileOutputStream是用于写入文件的字节流类。它继承自OutputStream抽象类，可以用于向文件中写入字节数据。

写入字节数据：

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamExample {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("file.txt"); // 创建FileOutputStream对象，指定要写入的文件名
            String data = "Hello, World!"; // 要写入的数据
            byte[] bytes = data.getBytes(); // 将字符串转换为字节数组
            fos.write(bytes); // 将字节数组写入文件
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) {
                    fos.close(); // 关闭流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileReader

读取字符数据：

import java.io.FileReader;
import java.io.IOException;

public class FileReaderExample {
    public static void main(String[] args) {
        FileReader fr = null;
        try {
            fr = new FileReader("input.txt"); // 创建FileReader对象，指定要读取的文件名
            int data;
            while ((data = fr.read()) != -1) { // 从文件中读取字符数据，直到文件末尾
                System.out.print((char) data); // 将字符数据转换为字符并输出
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fr != null) {
                    fr.close(); // 关闭读取流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileWriter

写入字符数据：

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

public class FileWriterExample {
    public static void main(String[] args) {
        FileWriter fw = null;
        try {
            fw = new FileWriter("output.txt"); // 创建FileWriter对象，指定要写入的文件名
            String data = "Hello, World!"; // 要写入的数据
            fw.write(data); // 将字符串写入文件
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fw != null) {
                    fw.close(); // 关闭写入流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

处理流

BufferedReader

当需要从字符输入流中读取数据时，BufferedReader提供了更高效的读取方式。它通过缓冲字符来减少对底层输入流的访问次数，从而提高读取数据的效率。

示例代码：

try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (reader != null) {
        try {
            reader.close(); //只需要关闭BufferedReader，底层流会自动关闭
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

BufferedWriter

当需要向字符输出流中写入数据时，BufferedWriter提供了更高效的写入方式。它通过缓冲字符来减少对底层输出流的访问次数，从而提高写入数据的效率。

示例代码：

try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
    writer.write("Hello, World!");
    writer.newLine();
    writer.write("This is a test.");
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (writer != null) {
        try {
            writer.close(); //只需要关闭BufferedWriter，底层流会自动关闭
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

BufferedInputStream

当需要从字节输入流中读取数据时，BufferedInputStream提供了更高效的读取方式。它通过缓冲字节来减少对底层输入流的访问次数，从而提高读取数据的效率。

示例代码：

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamExample {
    public static void main(String[] args) {
        try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream("input.txt"))) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                // 处理读取到的字节数据
                String data = new String(buffer, 0, bytesRead);
                System.out.print(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在try-with-resources语句块中，我们使用了BufferedInputStream对象，这样在代码块执行完毕后，会自动调用BufferedInputStream的close()方法来关闭它，释放底层资源。

BufferedOutputStream

BufferedOutputStream是Java中的处理流，用于将字节数据写入到输出流中，并提供了缓冲功能，以提高写入数据的效率。

示例代码：

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamExample {
    public static void main(String[] args) {
        try (BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
            String data = "Hello, World!";
            byte[] bytes = data.getBytes();
            outputStream.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ObjectInputStream

ObjectInputStream用于从输入流中读取对象数据，并进行反序列化。

示例代码：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInputStreamExample {
    public static void main(String[] args) {
        try (ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("data.obj"))) {
            Object obj = inputStream.readObject();
            // 处理读取到的对象数据
            System.out.println(obj);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

ObjectOutputStream

ObjectOutputStream用于将对象数据写入输出流中，并进行序列化。

示例代码：

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamExample {
    public static void main(String[] args) {
        try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("data.obj"))) {
            Object obj = new MyClass(); // 假设MyClass实现了Serializable接口，是一个可序列化的类
            outputStream.writeObject(obj);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

PrintStream

PrintStream是用于打印数据的输出流类。它是OutputStream的子类，提供了一系列用于打印各种数据类型的方法。

示例代码：

import java.io.PrintStream;

public class PrintStreamExample {
    public static void main(String[] args) {
        // 创建PrintStream对象，将数据打印到控制台
        PrintStream ps = System.out;

        // 打印字符串
        ps.println("Hello World!");

        // 打印整数
        int num = 10;
        ps.println("The number is: " + num);

        // 打印浮点数
        double pi = 3.14159;
        ps.printf("The value of pi is: %.2f%n", pi);

        // 打印布尔值
        boolean flag = true;
        ps.println("The value of flag is: " + flag);

        // 关闭PrintStream对象
        ps.close();
    }
}

PrintWriter

PrintWriter是用于打印数据的输出流类。它是Writer的子类，提供了一系列用于打印各种数据类型的方法。

与PrintStream不同，PrintWriter是面向字符的输出流，可以将字符数据打印到文件、网络或其他字符输出目标。它提供了一些便捷的方法来打印各种数据类型，同时还支持自动刷新缓冲区和自动关闭。

示例代码：

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

public class PrintWriterExample {
    public static void main(String[] args) {
        try {
            // 创建PrintWriter对象，将数据打印到文件
            PrintWriter pw = new PrintWriter(new FileWriter("output.txt"));

            // 打印字符串
            pw.println("Hello World!");

            // 打印整数
            int num = 10;
            pw.println("The number is: " + num);

            // 打印浮点数
            double pi = 3.14159;
            pw.printf("The value of pi is: %.2f%n", pi);

            // 打印布尔值
            boolean flag = true;
            pw.println("The value of flag is: " + flag);

            // 关闭PrintWriter对象
            pw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

标准输入输出流

标准输入输出流是指用于读取和写入数据的预定义流对象。标准输入流（System.in）用于从键盘读取数据，而标准输出流（System.out）用于将数据打印到控制台。

标准输入流（System.in）是一个字节流（InputStream），它继承自InputStream类。可以使用Scanner类来读取标准输入流中的数据。

标准输出流（System.out）是一个字节流（OutputStream），它继承自PrintStream类。可以使用System.out.println()方法将数据打印到控制台。

Properties 类

Properties 类是用于操作属性文件的类，属性文件通常以 .properties 后缀名保存，以键值对的形式（key=value）存储数据。Properties 类继承自 Hashtable 类，所以具备了 Hashtable 类的所有方法。

Properties 类提供了一系列方法来加载、存储和获取属性文件中的键值对数据。下面是一些常用的方法：

1）load(InputStream inStream)：从输入流中加载属性文件。属性文件的格式为键值对的形式，每一行表示一个键值对，以等号（=）分隔键和值。

2）getProperty(String key)：根据键获取属性文件中对应的值。

3）setProperty(String key, String value)：设置属性文件中的键值对。

4）store(OutputStream out, String comments)：将属性文件存储到输出流中。comments 参数是一个注释，可以写一些关于属性文件的说明。

示例代码：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Properties;

public class PropertiesExample {
    public static void main(String[] args) {
        // 加载属性文件
        Properties properties = new Properties();
        try (InputStream inputStream = new FileInputStream("config.properties")) {
            properties.load(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 获取属性值
        String username = properties.getProperty("username");
        String password = properties.getProperty("password");
        System.out.println("Username: " + username);
        System.out.println("Password: " + password);

        // 设置属性值
        properties.setProperty("email", "example@example.com");

        // 存储属性文件
        try (OutputStream outputStream = new FileOutputStream("config.properties")) {
            properties.store(outputStream, "Updated properties");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}