Java进阶-IO（4）

File(String path)：如果 path 是实际存在的路径，则该 File 对象表示的是目录；如果 path 是文件名，则该 File 对象表示的是文件。
File(String path, String name)：path 是路径名（目录），name 是文件名。
File(File dir, String name)：dir 是路径对象（目录），name 是文件名。

canRead()    测试程序是否能从指定的文件中读取
canWrite()    测试程序是否能写当前文件
delete()    删除指定的文件
exists()    测试当前 File 是否存在
getAbsolutePath()    返回文件的绝对路径名
getName()    返回对象的文件名或路径名（如果是路径，则返回最后一级子路径名）
getParent()    返回当前 File 对象所对应目录（最后一级子目录）的父目录名
isAbsolute()    测试文件是否为一个绝对路径名。
isDirectory()    测试文件是否为一个路径（目录）
isFile()    测试文件是否为一个“普通”文件
lastModified()    返回文件最后修改的时间
length()    返回文件长度
list()    返回指定的路径文件列表
list(FilenameFilter)    返回指定的目录中满足指定过滤器的文件列表
mkdir()    创建一个目录，它的路径名由当前 File 对象指定
mkdirs()    创建一个目录（多级目录），它的路径名由当前 File 对象指定
renameTo(File)    将文件更名为给定参数 File 指定的路径名

创建：createNewFile()
删除：delete()
注：在创建或删除前都先用exists()方法判断文件是否存在

创建：mkdir() 
注：创建多级目录（即目录中还包含目录），用mkdirs
删除：delete()
注：在创建或删除前都先用exists()方法判断目录是否存在

String[] list()：返回由 File 对象表示目录中所有文件和子目录名称组成的字符串数组，如果调用的 File 对象不是目录，则返回 null。（list() 方法返回的数组中仅包含文件名称，而不包含路径）
String[] list(FilenameFilter filter)：返回数组中仅包含符合 filter 过滤器的文件和目录，如果 filter 为 null，则接受所有名称。

首先创建文件过滤器，该过滤器必须实现 java.io.FilenameFilter 接口。
在 accept() 方法中指定允许的文件类型。

import java.io.File; // 导包
import java.util.Date;
//获取文件属性
public class FlieDemo {
    public static void main(String[] args){
        String path="D:\\Ultimate JavaCode\\src\\test6"; // 文件路径
        File f=new File(path,"date1_24.txt"); // File(String path, String name)构造方法实例化File对象
        System.out.println("D:\\Ultimate JavaCode\\src\\test6\\date1_24.txt文件信息如下：");
        System.out.println("============================================"); //以下通过实例化对象f调用Flie类常用方法
        System.out.println("文件名称："+f.getName());
        System.out.println("文件路径："+f.getPath());
        System.out.println("绝对路径："+f.getAbsoluteFile());
        System.out.println("文件长度："+f.length()+"字节");
        System.out.println("文件或者目录："+(f.isFile()?"是文件":"不是文件"));//三元表达式(boolean x?x=true时执行该部分:x=false时执行该部分)
        System.out.println("文件或者目录：" + (f.isDirectory() ? "是目录" : "不是目录"));
        System.out.println("是否可读："+(f.canRead()?"可读取":"不可读取"));
        System.out.println("是否可写："+(f.canWrite()?"可写入":"不可写入"));
        System.out.println("是否隐藏："+(f.isHidden()?"是隐藏文件":"不是隐藏文件"));
        System.out.println("最后修改日期："+new Date(f.lastModified())); // 实例化日期对象
    }
}

D:\Ultimate JavaCode\src\test6\date1_24.txt文件信息如下：
============================================
文件名称：date1_24.txt
文件路径：D:\Ultimate JavaCode\src\test6\date1_24.txt
绝对路径：D:\Ultimate JavaCode\src\test6\date1_24.txt
文件长度：72字节
文件或者目录：是文件
文件或者目录：不是目录
是否可读：可读取
是否可写：可写入
是否隐藏：不是隐藏文件
最后修改日期：Tue Jan 24 11:33:48 CST 2023

import java.io.File; //导包
import java.io.IOException;

public class FileDemo1 {
    public static void main(String[] args) throws IOException { // 抛出IO异常
        String path="D:\\Ultimate JavaCode\\src\\test6"; // 文件路径
        File f1=new File(path,"date1_24_1.txt"); // File(String path, String name)构造方法实例化File对象
        if(f1.exists()){ // 判断文件是否存在
            f1.delete(); // 存在先删除
        }
        f1.createNewFile(); // 再创建
    }
}

import java.io.File; //导包
import java.io.IOException;

public class FileDemo1 {
    public static void main(String[] args) throws IOException { // 抛出IO异常
        String path="D:\\Ultimate JavaCode\\src\\test6"+File.separator+"date1_24_1.txt"; // 文件路径，用 File.separator
        File f1=new File(path); // File(String path)构造方法实例化File对象
        if(f1.exists()){ // 判断文件是否存在
            f1.delete(); // 存在先删除
        }
        f1.createNewFile(); // 再创建
    }
}

import java.io.File; //导包

public class FileDemo2 {
    public static void main(String[] args){
        String path="D:/Date1_24/"; // 指定目录位置
        File f=new File(path); // File(String path)构造方法创建File对象
        if (f.exists()){
            f.delete();
        }
        f.mkdir(); // 创建目录
    }
}
// 结果：会发现D盘下多了一个Date1_24的空文件夹

import java.io.File; //导包

public class FileDemo3 {
    public static void main(String[] args){
         File f=new File("D:/"); // File(String path)构造方法创建File对象
         System.out.println("文件名称\t\t文件类型\t\t文件大小");
         System.out.println("===================================================");
         String fileList[]=f.list(); // 调用不带参数的list()方法，返回一个数组
         for(int i=0;i<fileList.length;i++){ // 遍历返回的字符数组
             System.out.print(fileList[i]+"\t\t");
             //三元表达式对文件类型归类(文件或文件夹)
             System.out.print((new File("D:/",fileList[i])).isFile()?"文件"+"\t\t":"文件夹"+"\t\t");
             System.out.println((new File("D:/",fileList[i])).length()+"字节");
             //由于 list() 方法返回的字符数组中仅包含文件名称，要获取文件类型和大小，必须先转换为 File 对象再调用其方法。
         }
    }
}

文件名称        文件类型        文件大小
===================================================
$RECYCLE.BIN        文件夹        0字节
360downloads        文件夹        4096字节
360RecycleBin        文件夹        4096字节
360安全浏览器下载        文件夹        0字节
Anaconda        文件夹        24576字节
Android        文件夹        0字节
apache-tomcat-8.5.83        文件夹        4096字节
BaiduNetdiskDownload        文件夹        0字节
centbrowser_4.3.9.248        文件夹        0字节
Date1_24        文件夹        0字节
Dev-Cpp        文件夹        4096字节
HBuilderX.3.3.11.20220209        文件夹        0字节
ideaIU-2021.3.3.win        文件夹        4096字节
Maven        文件夹        0字节
Microsoft Visio        文件夹        0字节
MSOCache        文件夹        0字节
mydrivers        文件夹        0字节
mysql        文件夹        4096字节
Node.js        文件夹        4096字节

public class ImageFilter implements FilenameFilter {
    // 实现 FilenameFilter 接口
    @Override
    public boolean accept(File dir, String name) {
        // 指定允许的文件类型
        return name.endsWith(".sys") || name.endsWith(".txt") || name.endsWith(".bak");
    }
}

RandomAccessFile(File file, String mode)：访问参数 file 指定的文件，访问形式由参数 mode 指定，mode 参数有两个常用的可选值 r 和 rw（ r 表示只读，rw 表示读写）
RandomAccessFile(String name, String mode)：访问参数 name 指定的文件，mode含义同上。

boolean readBoolean()    从文件中读取一个 boolean 值
byte readByte()    从文件中读取一个带符号位的字节
char readChar()    从文件中读取一个字符
int readlnt()    从文件中读取一个带符号位的整数
long readLong()    从文件中读取一个带符号位的 long 值
String readLine()    从文件中读取下一行文本
void seek(long pos)    指定从文件起始位置开始的指针偏移量
void writeBoolean(boolean v)    以字节的形式向文件中写入一个 boolean 值
void writeByte(int v)    以单字节的形式向文件中写入一个 byte 值
void writeChar(int v)    以双字节的形式向文件中写入一个 char 值
void writelnt(int v)    以4字节的形式向文件中写入一个整数
writeLong(long v)    以8字节的形式向文件中写入一个 long 值
void writeBytes(String s)    以字节序列的形式向文件中写入一个字符串
void skipBytes(int n)    以当前文件指针位置为起始点，跳过 n 字节

import java.io.File; // 导包
import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileDemo {
    public static void main(String[] args) throws IOException { // 抛出异常
        // 先创建一个空的“weather.txt“文件
        File file=new File("D:\\Ultimate JavaCode\\src\\test6\\weather.txt");//指定文件路径
        if(file.exists()){ // 判断文件是否存在
            file.delete();
            file.createNewFile(); // 创建文件
        }
        file.createNewFile();

        // 再创建RandomAccessFile对象并写入字符串
        RandomAccessFile rf=new RandomAccessFile(file,"rw"); // rw表示读写
        String str1="晴天，阴天，多云，小雨，大风，中雨，小雪，雷阵雨"; // 要写入的字符串
        // 编码转换，防止乱码
        String str2=new String(str1.getBytes("GBK"),"ISO_8859_1");
        rf.writeBytes(str2); // 写入文件

        // 最后从第 6 个字节开始读取并输出
        System.out.println("当前文件指针的位置："+rf.getFilePointer());
        rf.seek(6); // 设置指针偏移量为6，即移动6个字节
        System.out.println("从文件头跳过6个字节后，文件的内容如下：");
        // 定义一个长度为2的byte数组，进行内容的循环读取
        byte[] b=new byte[2];
        int len=0;
        while ((len=rf.read(b,0,2))!=-1){
            System.out.print(new String(b,0,len));
        }
        rf.close(); // 关闭文件，释放资源
    }
}

1.当字节和字符之间有转换动作时；
2.流操作的数据需要编码或解码时；
- 编码：字节/字节数组---->字符/字符数组
- 解码：字符/字符数组---->字节/字节数组

转换流作用：提供字节流与字符流之间的转换，通常使用转换流来处理文件乱码问题，实现编码和解码的功能。

objectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream

void writeObject(Object obj)：将指定的对象写入ObjectOutputStream

import java.io.Serializable;

public class Student implements Serializable { // 创建一个学生类
    private String name; // 封装成员变量
    private int age;

    public Student() { // 无参构造方法
    }
    public Student(String name, int age) { // 带全部参数的构造方法
        this.name = name;
        this.age = age;
    }
    // 提供get()和set()方法
    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;
    }
}

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
// NotSerializableException:当实例需要具有Serializable接口时抛出。 序列化运行时或实例的类可以抛出此异常。
// 一个对象要想被序列化，该对象所属的类必须实现Serializable接口，否则会报NotSerializableException错误
public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        // 创建序列化流对象
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("D:\\Ultimate JavaCode\\src\\test8\\oos.txt"));
        // 创建学生对象
        Student s=new Student("林青霞",20);
        oos.writeObject(s); // 调用writeObject()方法将对象写入序列化流
        // 释放资源
        oos.close();
    }
}
// result：打开文件发现存在乱码问题，因此需要使用反序列化流转换才能读懂

ObjectInputStream
- ObjectInputStream反序列化前先使用ObjectOutputStream编写的原始数据和对象

构造方法
ObjectInputStream(InputStream in)
- 创建从指定的InputStream读取的ObjectInputStream

反序列化对象的方法
Object readObject()
- 从ObjectInputStream读取一个对象

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

public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 创建反序列化流对象
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("D:\\Ultimate JavaCode\\src\\test8\\oos.txt"));
        // 调用readObject()方法将对象读入反序列化流
        Object obj = ois.readObject();
        Student s=(Student) obj; // 大转小强转，向下转型
        System.out.println(s.getName()+","+s.getAge());
        //释放资源
        ois.close();
    }
}
// result(经过对象反序列化后输出不会再乱码)
// 林青霞,20

import java.util.Properties;
import java.util.Set;

public class PropertiesDemo {
    public static void main(String[] args) {
        // 创建Properties集合对象
        Properties prop=new Properties();
        // 调用父类Map集合的put()方法添加集合键值元素
        prop.put("101","zhangsan");
        prop.put("102","lishi");
        prop.put("103","wangwu");
        // 遍历集合
        Set<Object> keySet=prop.keySet(); // 得到所有keySet的集合
        for(Object key:keySet){
            Object value=prop.get(key); // 获取所有keySet对应的值，注意Map集合的遍历方式，键值遍历
            System.out.println(key+","+value);
        }
    }
}

103,wangwu
102,lishi
101,zhangsan

Object setProperty(String key,String value)：数组集合的键和值，都是String类型，底层调用Hashtable方法 put（设置键值对，可代替父类的put()方法）
String getProperty(String key)：使用此属性列表中指定的键搜索属性（根据键key获取值value）
Set<String> stringPropertyName()：从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串（获取得到所有键的集合）

import java.util.Properties;
import java.util.Set;
// Properties作为集合的特有方法
public class PropertiesDemo1 {
    public static void main(String[] args) {
        // 创建集合Properties对象
        Properties prop=new Properties();
//        prop.put("101","zhangsan"); // 调用父类的put方法添加键值对元素
        // 使用Properties的特有方法setProperty()方法添加键值对元素,键值都为String类型
        prop.setProperty("101","zhangsan");
        prop.setProperty("102","lishi");
        // 使用Properties的特有方法getProperty()方法获取值
//        System.out.println(prop.getProperty("101")); // lishi
//        System.out.println(prop.getProperty("1001")); // null
        // 使用Properties的特有方法stringPropertyName()方法获取所有键的集合,键值都为String类型(关键，重要一步)
        Set<String> names = prop.stringPropertyNames();
        // 增强for循环遍历集合
        for(String key:names){
//            System.out.println(key); // 遍历键
            String value = prop.getProperty(key); // getProperty()方法获取键对应的值
            System.out.println(key+","+value); // 输出键和值信息
        }
    }
}

102,lishi
101,zhangsan

void load(InputStream inStream)：从输入字节流读取属性列表（键和元素对）
void load(Reader reader)：从输入字符流读取属性列表（键和元素对）
void store(OutputStream out,String comments)：将此属性列表（键和元素对）写入此Properties表中，以适合使用load(Reader)方法的格式写入输入字符串（即将Properties集合数据保存到文件中）

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class PropertiesDemo2 {
    public static void main(String[] args) throws IOException{
        // 将Properties集合中的数据保存到文件中
        myStore(); // 演示第二个方法时先将该方法注释，因为文件已经创建成功,没有必要再次创建，浪费资源
        // 将文件中的数据加载到Properties集合中
        myLoad();
    }
    private static void myLoad() throws IOException{
        // 创建Properties对象
        Properties prop=new Properties();
        // void load(Reader reader):从输入字符流读取属性列表（键和元素对）
        // Reader为抽象类，创建其实现类即子类FileReader对象作为参数
        FileReader fr=new FileReader("D:\\Ultimate JavaCode\\src\\test8\\fw.txt");
        // 调用load()方法将文件中的数据加载到Properties集合中
        prop.load(fr);
        // 释放资源
        fr.close();
        // 打印集合，查看是否加载成功
        System.out.println(prop);
    }
    private static void myStore() throws IOException {
        // 创建Properties对象
        Properties prop=new Properties();
        // 使用特有的setProperty()方法设置字符串类型的键值
        prop.setProperty("101","zhangsan");
        prop.setProperty("102","lishi");
        prop.setProperty("103","wangwu");
        // void store(Writer writer,String comments)
        // Writer为抽象类，创建其实现类即子类FileWriter对象作为第一个参数
        FileWriter fw=new FileWriter("D:\\Ultimate JavaCode\\src\\test8\\fw.txt");
        // 调用store()方法将Properties集合中的数据保存到文件中
        prop.store(fw,null); // 第二个参数comments为描述信息，不描述可设置为null
        // 释放资源
        fw.close();
    }
}

{101=zhangsan, 102=lishi, 103=wangwu}