java磁盘操作与IO流（序列化、Properties类）

        File f1 = new File("D:\\IoTest\la.txt");--传入一个string path路径
        File f2 = new File("D:\|IOTest","a.txt");//传入两个路径，分别时父路径和子路径
        File f3 = new File(new File( "D:\\IoTest"), "a.txt"); //传入两个路径第一个为File类型的对象，第二个为子路径

（2）获取文件信息：

（2.1） public String getName() ：获取文件的名称，带后缀

（2.2） public long length() ：获取文件长度（即：字节数---真实的大小）。不能获取目录的长度--仅表示当前操作系统为保存目录所涉及的长度。

（2.3） public long lastModified() ：获取最后一次的修改时间，毫秒值使用new Date(f1.lastModified());// 返回的是当天时间

package com.yuan.file;

import java.io.File;
import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        //存在的目录路径
        // 小贴士:
        // 1.一个File对象代表指向硬盘中的一个文件或者目录路径(举例，只代表此路径，不代表里面的内容。举例:地址不是房子，File对象指向地
        // 2.无论该路径下是否存在文件或者目录，都不影响File对象的创建。
        File f1 = new File( "D:\\IoTest");
        System.out.println(f1);
        ///存在的文件路径
        File f2 = new File( "D:\\IoTest\\a.txt");
        System.out.println(f2);
        //不存在的目录路径
        File f3 = new File( "D:\\IoTest\\aaa");
        System.out.println(f3);
        //不存在的文件路径
        File f4 = new File( "D:\\IoTest\\a.jpg");
        System.out.println(f4);

        String str="文件名是:%s 文件大小是:%d  文件最后一次修改时间是:%s\n";
        //public string getName():获取文件的名称，带后缀
        //public long length():获取文件长度(即:字节数---真实的大小)。不能获取目录的长度--仅表示当前操作系统为保存目录所涉及的长度
        //public long lastModified():获取最后一次的修改时间，毫秒值

        System.out.printf(str,f1.getName(),f1.length(),new Date(f1.lastModified()));
        System.out.printf(str,f2.getName(),f2.length(),new Date(f2.lastModified()));
        System.out.printf(str,f3.getName(),f3.length(),new Date(f3.lastModified()));
        System.out.printf(str,f4.getName(),f4.length(),new Date(f4.lastModified()));
    }
}

（2.4）public String getAbsolutePath()：获取文件的绝对路径

（2.5） public String getPath() ：获取路径,返回定义文件时使用的路径

（2.6）public String getCannoicalPath() 获取规范路径

package com.yuan.file;

import java.io.File;
import java.io.IOException;

public class Demo02 {
    public static void main(String[] args) throws IOException {
      
        File f1 = new File(new File( "D:\\IoTest"), "a.txt");
       
        System.out.println("文件绝对路径"+f1.getAbsolutePath());
        System.out.println("文件使用路径"+f1.getPath());
        System.out.println("文件规范路径"+f1.getCanonicalPath());  //编译时异常

        //.表示当前路径 .. 表示当前路径的上一层路径
        File f2 = new File(".\\a.txt");
        System.out.println("文件绝对路径"+f2.getAbsolutePath());
        System.out.println("文件使用路径"+f2.getPath());
        System.out.println("文件规范路径"+f2.getCanonicalPath());  //编译时异常


    }
}

（2.7）public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组---注意返回类型

（2.8）public File[] listFiles() ：获取指定目录下的所有文件或者目录的File数组----返回时File

  public static void main(String[] args) {
        //查看目录下的文件及文件夹
        //public String[] list();获取指定目录下的文件或者文件目录的名称数组
        File f1=new File("D:\\IoTest");
        String[] names=f1.list();
        System.out.println(Arrays.toString(names));

        //public File[] listFiles():获取指定目录下的所有文件或者目录的File数组--返回File路径对象
        File[] files=f1.listFiles();
        System.out.println(Arrays.toString(files));
    }

（3）判断文件

（3.1） public boolean exists() ：判断是否存在

（3.2） public boolean isDirectory()：判断是否是目录

（3.3）public boolean isFile() ：判断是否是文件

package com.yuan.file;

import java.io.File;

public class Demo03 {
    public static void main(String[] args) {
        //存在的文件和目录
        File f1 = new File("D:\\IoTest");
        File f2 = new File( "D:\\IoTest\\a.txt");
        //不存在的文件和目录
        File f3 = new File( "D:\\IoTest\\aaa");
        File f4 = new File(  "D:\\IoTest\\a.jpg");
        //判断是否存在
        String str ="【%s】是否存在%s,是否是文件%s,是否是目录%s\n";
      
        //public boolean isFile():判断是否是文件
        System.out.printf(str,f1.getName(),f1.exists(),f1.isFile(),f1.isDirectory());
        System.out.printf(str,f2.getName(),f2.exists(),f2.isFile(),f2.isDirectory());
        System.out.printf(str,f3.getName(),f3.exists(),f3.isFile(),f3.isDirectory());
        System.out.printf(str,f4.getName(),f4.exists(),f4.isFile(),f4.isDirectory());
    }
}

（3.4）public boolean canRead() ：判断是否可读

（3.5）public boolean canWrite() ：判断是否可写

（3.6） public boolean isHidden() ：判断是否隐藏

package com.yuan.file;

import java.io.File;

public class Demo04 {
    public static void main(String[] args) {
      
        File f1=new File("D\\IoTest\\a.txt");
        System.out.println("是否可读"+f1.canRead());
        System.out.println("是否可写"+f1.canWrite());
        System.out.println("是否隐藏"+f1.isHidden());
    }
}

（4）删除文件

（4.1）public boolean delete()：删除此抽象路径名表示的文件或者文件夹

注意：delete方法只删除文件和空文件夹，是直接删除不走回收站

public class Demo05 {
    public static void main(String[] args) {

        //delete 方法删除后不进回收站
        File f1=new File("D:\\IoTest\\b.txt");
        File f2=new File("D:\\IoTest\\fileStudy");

        //删除文件时，要求文件必须存在才能进行删除
        boolean b1 =f1.delete();System.out.println("f1是否删除成功:"+b1);
        //只能删除存在的空目录
        boolean b2=f2.delete();System.out.println("f2是否删除成功:"+b2);


    }
}

（5）创建文件：

（5.1）public boolean createNewFile()：创建文件。若文件存在，则不创建，返回false

（5.2）public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。

（5.3）public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建

public class Demo06 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("D:\\IoTest\\b.txt");
        File f2 = new File("D:\\IoTest\\资料");
        File f3 = new File("D:\\IoTest\\aaa\\资料");

        //1.创建文件createNewFile()，文件路径存在，文件不存在的时候为true
        boolean b1=f1.createNewFile();
        System.out.println("创建f1对象是否成功:"+b1);
        //2.创建文件夹,当文件夹不存在,且父路径存在的时候就可以创建
        boolean b2 =f2.mkdir();
        System.out.println("创建f2对象是否成功:"+b2);
        //3.创建文件来，如果父路径不存在，则一并创建
        boolean b3 =f3.mkdirs();
        System.out.println("创建f3对象是否成功:"+b3);



    }
}

2、Files工具类：

在 Java NIO（New IO）中，java.nio.file.Files 是一个非常实用的工具类，提供了大量静态方法用于操作文件和目录，包括创建、删除、复制、移动、读取、写入等操作。它通常与 Path 接口配合使用，是处理文件系统的重要工具。以下是 Files 工具类的一些常用方法：

（1）字符操作：

（1.1）List<String> list readAllLine(Path path) 按行读取指定路径中的内容

（1.2） write(Path path, List<String> list) 写入字符到指定的路径

public class FilesReadWriteExample {
    public static void main(String[] args) {
        // 定义文件路径
        Path filePath = Paths.get("example.txt");
        
        try {
            // 1. 写入内容到文件
            List<String> contentToWrite = new ArrayList<>();
            contentToWrite.add("第一行内容");
            contentToWrite.add("第二行内容");
            contentToWrite.add("第三行内容");
            
            // 使用write方法写入列表内容到文件
            Files.write(filePath, contentToWrite);
            System.out.println("文件写入成功！");
            
            // 2. 从文件按行读取内容
            List<String> readLines = Files.readAllLines(filePath);
            System.out.println("\n文件读取内容如下：");
            for (String line : readLines) {
                System.out.println(line);
            }
            
        } catch (IOException e) {
            System.out.println("文件操作出错：" + e.getMessage());
            e.printStackTrace();
        }
    }
}

（2）字节操作：

（2.1）byte[] readAllBytes(Path path) 读取文件中的所有字节。

public class Demo01 {
    public static void main(String[] args) throws IOException {
        Path p1=new File("D:\\IoTest\\a.txt").toPath();
        //byte[] readAllBytes(Path path) 读取文件中的所有字节
        byte[] bytes= Files.readAllBytes(p1);
        System.out.println(Arrays.toString(bytes));

        //字符读的方式： 只能读取纯文本类型
        List<String> list=Files.readAllLines(p1);
        System.out.println(list);
    }
}

（2.2） Path write(Path path, byte[] bytes) 写入字节到指定的路径

public class Demo02 {
    public static void main(String[] args) throws IOException {
        Path p1 = new File( "D:\\IoTest\\a.txt").toPath();

        //写 Path write(Path path,byte[] bytes) 写入字节到指定的路径
        byte[] bytes="我本将心向明月".getBytes();
        Files.write(p1,bytes);

        ArrayList<String> list =new ArrayList<>();
        for (int i =0; i <30 ; i++) {
            list.add(UUID.randomUUID().toString());
        }
        // write(Path path，List<String>list)写入字符到指定的路径
        Files.write(p1,list, StandardOpenOption.APPEND);
        System.out.println("写出结束");
    }
}

二、IO流：

在 Java 中，IO（Input/Output）流是用于处理设备间数据传输的机制，比如文件读写、网络通信等。IO 流按不同维度可分为多种类型，以下是其核心分类及常用操作示例：

1、IO流的概念：

（1） I 表示Input ，把硬件文件的数据读入到内存的过程，称之输入，负责读。

（2）O表示output ，把内存中的数据写出到硬盘文件的过程称之输出负责写

2、字节操作（字节流）：操作最小单元为字节，可以包含音频视频图片

（1）输入流：InputStream（读）：常用实现类：FileInputStream类、BufferedInputStream类、ObjectInputStream类（反序列化）等。

（1.1）FileInputStream类：基于磁盘中字节内容的输入流。

构造方法：

1.FileInputStream(File file)；通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。

2、FileInputStream(String name) 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

public class Demo01 {
    public static void main(String[] args) throws FileNotFoundException {
        //注意路径： 一定是一个文件路径，路径一定要存在，如果不存在则出异常
        //public  FileInputStream（String name）
        InputStream is1=new FileInputStream("D:\\IoTest\\a.txt");
        System.out.println(is1);  //获取输入流对象

        //FileInputStream(File file)
        InputStream is2=new FileInputStream(new File("D:\\IoTest\\a.txt"));
        System.out.println(is2);

    }
}

（1.2） BufferedInputStream类：带有缓冲区的输入流。

作用：没有缓冲区，就好像逛超市没有推车，一次只拿一样东西区结账，缓冲区可以暂时放一堆数据到满为止

（1.3）ObjectInputStream类：对象输入流，进行反序列化操作

（1.4）常用方法：

（1.4.1）int read（）：一个字节一个字节读取，赋值给返回值，植脂末未返回-1

（1.4.2）int read(byte b[])每次读取N个字节，将字节放到字节数组中，读取到末尾返回值-1

（1.4.3）public void close() ：关闭此输入流，并释放与此流相关联的任何系统资源。原因：在IO流进行操作时，当前IO流回占用到一定的内存，由于系统资源宝贵，因此在进行IO操作结束后，调用close方法关闭流，从而释放资源。

package com.yuan.inputstream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

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

        InputStream is = new FileInputStream("D:\\IoTest\\a.txt");
        //1、int read()  一个字节一个字节读取，赋值给返回值，植脂末未返回-1
//        int data1 = is.read();
//        System.out.println(data1);
//        int data2 = is.read();
//        System.out.println(data2);
//        int data3 = is.read();
//        System.out.println(data3);
//        int data4 = is.read();
//        System.out.println(data4);
//
//        int data;
//        while ((data = is.read()) != -1) {
//            System.out.println((char) data);
//        }
        //2.int read(byte b[])每次读取N个字节，将字节放到字节数组中，读取到末尾返回值-1
        byte[] bytes = new byte[10];//存放每次读取到的字节信息
        int len;//每次读取的长度1/读取操作
        while ((len = is.read(bytes)) != -1) {
            System.out.print("读取到的长度为:" + len + "读到的内容:" + new String(bytes, 0, len)+"\n");
        }
        is.close();

    }
}

（2）输出流：OutputStream（写）：常用实现类：FileOutStream类、BufferedOutStream类、ObjectOutputStream类（序列化）等。

（2.1）FileOutStream类：基于磁盘中字节内容的输出流

构造方法：

public class Demo04 {
    public static void main(String[] args) throws FileNotFoundException {
        //1、字节输出流路径一定要是一个文件路径
        //2、输出流文件对象可以不存在，的但是父路径一定要存在
        //FileOutputStream（String name）如果路径中有内容，会将路径中的内容覆盖掉
        OutputStream os=new FileOutputStream("D:\\IoTest\\b.txt");
        System.out.println(os);

        //FileOutputStream(File file)
        OutputStream os1=new FileOutputStream(new File("D:\\IoTest\\b.txt"));
        System.out.println(os1);
    }
}

（2.2）BufferedOutStream类：带有缓冲区的输入流：

（2.3）ObjectOutputStream类：对象输出流，进行序列化操作

（2.4）常用方法：

（2.4.1）write(int b)：写入一个字节

（2.4.2）write(byte b[ ])：把这个b字节数组中的所有数据写到关联的设备中(设备包括文件、网络或者其他任何地方)。

（2.4.3）write(byte b[], int off, int len)：把数组b字节中的数据从下标off位置开始往出写，共计写len个元素
（2.4.4）public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。close方法，当完成流的操作时，必须调用此方法，释放系统资源。

public class Demo07 {
    public static void main(String[] args) {
        //使用追加写的方式进行字书流的输出，不会对文件信息进行覆盖
        try (OutputStream os = new FileOutputStream( "D:\\IoTest\\a.txt",  true);
        BufferedOutputStream bos = new BufferedOutputStream(os);){
            //window换行号:r\n
            // linux换行:Ir
            // mac换行:n
            bos.write('a');//写出一个字节信息
            bos.write("rin".getBytes());//写出一个换行信息
            bos.write("我本将心向明月\r\n".getBytes());//写出一个字节数组信息

            //获取系统换行
            String str=System.lineSeparator();
            for(int i=0;i<5;i++) {
                String s1 = UUID.randomUUID().toString().substring(0, 8);
                bos.write((s1 + str).getBytes());
            }
            //bos.flush()://删新缓冲流
            // bos.close();关闭流
                bos.write("站着还能睡着吗".getBytes());
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

3、字符操作（字符流）：操作最小单位：txt文本文件或者java文件

（1）输出流：Writer（写）：常用实现类：FileWriter类、BufferedWriter类

（1.1）FileWriter类：也带有缓冲区：缓冲区长度为8192

构造方法：

（1.1.1）public FileWriter(String path);

（1.1.2）public FileWriter(File path);

（1.1.3）public FileWriter(String path,boolean append);

（1.1.4） public FileWriter(File path,boolean append);

public class Demo01 {
    public static void main(String[] args) throws IOException {
        //字符
        //FileWriter(String filename)覆盖写
        Writer w1=new FileWriter("D:\\IoTest\\a.txt");
        System.out.println(w1);

        //FileWriter(File file)覆盖写
        Writer w2=new FileWriter(new File("D:\\IoTest\\a.txt"));
        System.out.println(w2);
        //FileWriter(String filename) 不覆盖写
        Writer w3=new FileWriter("D:\\IoTest\\a.txt",true);
        System.out.println(w3);
        //FileWriter(String filename) 不覆盖写
        Writer w4=new FileWriter("D:\\IoTest\\a.txt",true);
        System.out.println(w4);
    }
}

常用方法：

（1.1.5）void write(String str) 写出一整行

（1.1.6） void newLine( ) 创建新行，输出换行符（根据操作系统不同，输出不同的换行符，windows是\r\n，Linux和Mac OS是\n）

public class Demo03 {
    public static void main(String[] args) {
        try (BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\IoTest\\c.txt"));){
            bw.write("你好");
            bw.newLine();// 自带换行方法
            bw.write("白日依山尽",0,3);
            bw.newLine();
            bw.flush();//刷新
            bw.close();//关闭，用try-with-resource, 所以不用关了
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

（1.2）BufferedWriter类：带缓冲区的流，与FileWriter相差不大，多了一个bw.newLine()方法自带换行方法

（2）输入流：Reader(读)：常用实现类：FileReader类、BufferedReader类、

（2.1）FileReader类：

构造方法：

（2.1.1）public FileReader(String path);

（2.1.2）public FileReader(File path);

public class Demo01 {
    public static void main(String[] args) throws FileNotFoundException {
        //创建字符输入流
        Reader r1=new FileReader("D:\\IoTest\\b.txt");
        System.out.println(r1);
        Reader r2=new FileReader(new File("D:\\IoTest\\b.txt"));
        System.out.println(r2);
    }
}

（2.2）常用方法：

（2.2.1）int read（）读取一个字符的数据，如果没有数据则返回-1

（2.2.2）int read(char buf[]) 读取数据存入char数组中，返回读取的长度，如果没有数据则返回-1

（2.2.3）void close(); 关闭此流并释放与此流相关联的任何系统资源。

public class Demo02 {
    public static void main(String[] args) {
        try (Reader r1 = new FileReader("D:\\IOTest\\b.txt")) {
            // 读取单个字符，返回字符对应码表值，当为 -1 读取结束
            int data = r1.read();
            System.out.println((char) data);

            // 循环读取
//            int data;
//            while ((data = r1.read()) != -1) {
//                System.out.print((char) data);
//            }

            // int read(char buf[])  读取数据存入 char 数组中，返回读取的长度，如果没有数据则返回 -1
            char[] chars = new char[10];
            int len;
            while ((len = r1.read(chars)) != -1) {
                System.out.print(new String(chars, 0, len));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

（2.3）BufferedReader类：多了一个String readLine( )方法，读取一整行，读取至末尾，返回null

三、Serializable序列化与反序列化：

1、序列化：对象--->二进制

（1）如果想要让某个对象进行序列化操作，要求类必须要实现Serializable接口。

（2）在进行序列化和反序列化时要求类的信息不能有任何的改动，否则会出异常。

（3）如果不能确保类不发生任何变动，则可以加序列化码（成员常量）保证类信息一致

（4）如果不想某个成员变量序列化出去，可以使用transient进行成员变量的修饰（

（5）要求成员变量也标题四要可序列化

public class Person implements Serializable {

    private static final long serialVersionUID = 6710117445303992336L;
    private String name;
    private transient int age;
    private Money money;

    public Person(String name, int age, Money money) {
        this.name = name;
        this.age = age;
        this.money = money;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", money=" + money +
                '}';
    }
}

// 注意：假设 Money 类也需要实现 Serializable 接口才能支持 Person 类的完整序列化，
// 这里补充 Money 类的示例实现（如果实际项目中有该类，需确保其正确实现）
class Money implements Serializable {
    private double Balance;
    private String bz;

    public Money(double balance, String bz) {
        Balance = balance;
        this.bz = bz;
    }
}

public class Demo01 {
    public static void main(String[] args) {
        // 序列化：对象->二进制
        // out
        // 反序列化：对象<-二进制
        try (ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("a.txt"));) {
            Person p1 = new Person("张三", 20, new Money(1768937, "人民币"));
            // 写出一个对象，序列化。将对象写出到指定的文件中
            os.writeObject(p1);
            System.out.println("序列化完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2、反序列化：二进制--->对象

public class Demo02 {
    public static void main(String[] args) {
        // 二进制-->对象
        // 输入流
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));) {
            Object obj = ois.readObject();
            if (obj instanceof Person) {
                Person p1 = (Person) obj;
                System.out.println(p1);
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

四、Properties类：Properties extends Hashtable<Object,Object>，实例化对象一键值对存储。

1、常用方法：

（1）Object setProperty(String key, String value)给对象赋值

（2）getProperty(String key)获取键对应的值

（3）getProperty(String key, String defaultValue)获取键对应的值，没有该键，返回默认值

（4）Set<String> stringPropertyNames()获取所有的键

public class Demo01 {
    public static void main(String[] args) {
        Properties p1=new Properties();
        //Object setProperty(String key, String value)给对象赋值
        p1.setProperty("姓名","张三");
        p1.setProperty("年龄","12");
        System.out.println(p1);

        //getProperty(String key)获取键对应的值
        String name=p1.getProperty("姓名");
        System.out.println(name);

        //getProperty(String key, String defaultValue)获取键对应的值，没有该键，返回默认值
        String name1=p1.getProperty("姓名1","不知道");
        System.out.println(name1);

        //获取所有的键
        Set<String> set=p1.stringPropertyNames();
        System.out.println(set);
    }
}

2、将输出流OutputStram和Properties对象p1对象结合，进行p1对象的输出：

public class Demo02 {
    public static void main(String[] args) throws IOException {
        Properties p1=new Properties();
        p1.setProperty("姓名","张三");
        p1.setProperty("年龄","12");
        p1.setProperty("性别","男");

        Writer w1=new FileWriter("b.txt");
        //将输出流和p1对象结合，进行p1对象的输出
        p1.store(w1,"helloWorld");
        w1.close();
    }
}

3、将输入流InputStream获取到的所有信息传递给p1对象

public class Demo03 {
    public static void main(String[] args) throws IOException {
        Properties p1=new Properties();
        Reader r1=new FileReader("b.txt");
        //将输入流获取放到的所有信息传递给p1对象
        p1.load(r1);
        Set<String> set=p1.stringPropertyNames();
        for (String s:set) {
            System.out.println(s+"__"+p1.getProperty(s));
        }
    }
}

4、Class对象的getResourceAsStream()可以从classpath中读取指定资源:

public class Demo04 {
    public static void main(String[] args) throws IOException {
        //Class对象的getResourceAsStream()可以从classpath中读取指定资源:
        InputStream is = Demo04.class.getResourceAsStream("/jdbc.properties");
        Properties p1 = new Properties();
        p1.load(is);//输入流和p1对象结合//打印链值对
        for (String key : p1.stringPropertyNames()) {
            System.out.println(key + "__" + p1.getProperty(key));
        }
        is.close();
    }
}