Java笔记(10)-文件操作

1. Lambda表达式标准格式：

1. 有三部分组成
    a. 一些参数
    b. 一个箭头
    c. 一段代码
2. 格式：
    (参数列表)->{
        //一些重写方法的代码
    }
    ()：接口抽象方法的参数列表，没有则空；有则逗号隔开
    ->：将参数传递给方法体
    {}：重写接口的抽象方法

2. File类是与操作系统无关的类

1. 路径分隔符
    static String pathSeparator;//与系统有关的路径分隔符
    static char pathSeparatorChar;
    //Windows下为分号(;)，Linux下为冒号(:)
    
    static String separator;//与系统有关的默认名称分隔符
    static char separatorChar;
    //Windows下为反斜杠，Linux下为正斜杠
    
    因此操作路径不能写死
2. 判断方法：
    1. 判断构造方法中的路径是否存在：exists()
        File f1 = new File("File Path");
        boolean b1 = f1.exists();
    2. 判断是否是文件夹：isDirectory()
    3. 判断是否为文件：isFile()
    电脑硬盘中数据，要么是文件，要么是文件夹
    判文件和盘文件夹是互斥的
    如果构造方法中的路径不存在，则三个判断都是false
3. mkdir和mkdirs -- 仅创建文件夹：
    mkdir：创建单级空文件夹
    mkdirs：创建多级空文件夹
4. delete方法是在硬盘删除，不走回收站。
5. 遍历文件夹目录
    a. public String[] list();
        遍历构造方法中给定的目录，获取目录中的所有文件/文件夹名称，把获取到的多个名称存储到一个String类型数组中
    b. public List() listFiles();
        遍历构造方法中给定的目录，获取目录中的所有文件/文件夹对象，把获取到的对象存储到一个File类型数组中

3. 字符流和字节流

1. 字符流：
    a. 字符输入流：
        InputStream
    b. 字符输出流：
        OutputStream
2. 字节流：
    a. 字节输入流：
        Reader
    b. 字节输入流：
        Writer
3. 一切皆为字节
4. java程序写入内容
    java程序 -> JVM -> OS操作系统 -> OS调用自己写数据的方法 -> 内存
5. 字节输出流使用步骤：
    a. 创建一个字节输出流的实现类对象(例如FileOutputStream)
        1. 构造方法创建对象的同时，会依据传递构造方法的参数创建相应的空的文件
        2. 会将流对象指向创建好的文件
    b. 调用字符输出流的通用方法write，将数据写入到文件中
    c. 释放资源

4. 写数据的方式

1. 追加写(续写)：
    FileOutputStream(String name, boolean append);
    FileOutputStream(File file, boolean append);
    append：如果为true则追加写
            如果为false则创建一个新文件覆盖写
    Windows下换行符：\r\n
    Linux下换行符：/n
    Mac下换行符：/r
    fos.write("\r\n".getBytes());

5. 使用字节流注意事项

1. 使用字节流读取中文文件
    a. 1个中文：
         GBK：占用两个字节
         UTF-8：占用三个字节
    b. 如果使用字节流读取单个字符，则转化字符时将显示乱码

6. 字符流

1. 字符流一次读取写入一个字符
2. FileReader extends InputStreamReader extends Reader
    InputStreamReader是中间的一个转换
3. 使用字符数组循环读取文件
    char[] ch = new char[1024];
    while((int len = fr.read(ch)) != -1){
        sout(new String(ch,0,len));//将读取的数值码转化为字符显示
    }
4. 字符输出流使用步骤：
    1. 创建字符输出流实现类对象(例如FileWriter)，构造方法中写入绑定的数据写入目的地
    2. 使用FileWriter中的方法write方法，将数据写入到内存缓冲区中
        -- 由于内存中存储的为字节流形式内容，因此有个字符流转字节流的过程
    3. 使用FileWriter中的方法flush，将内存中的数据刷新到文件中去
    4. 释放资源 -- 会先将缓冲区的文件刷新到文件中，再关闭释放资源
5. 常用的字符流写入方式：
    a. void write(char[] cbuf);
    b. void write(char[] cbuf,int off, int len);
    c. void write(String str);

7. try/catch处理流对象

1. 在JDK 7开始据有新特性
    a. 在try后边可以增加一个括号()，在括号中定义流对象，
        则这个流对象在整个try代码块中有效，且try代码块执行完毕后自动释放流对象，不用finally释放
    格式：
        try(定义流对象；定义流对象...){
            //可能会产生异常代码
        }catch (异常对象 变量名)
        {
            //异常处理
        }
2. 在JDK 9开始的新特性：
    a. 在try的前面可以定义流对象，在try后面的括号中直接引入流对象的名称(变量名)
        在truy代码执行完后，流对象自动释放，不用finally释放
    格式：
        A a = new A();
        B b = new B();
        try(a;b){
           //可能会产生异常代码
        }catch (异常对象 变量名)
        {
            //异常处理
        }
    b. 但是在定义流对象时仍然需要throw异常

8. 属性集：Properties extends Hashtable<K,b> implements Map<K,v>

1. Properties类表示了一个持久的属性集。它可以保存在流中或从流中加载
2. Properties是唯一一个和IO流相结合的集合
    可以使用Properties集合中的store方法，将集合中的临时数据，持久化写入硬盘中存储
    可以使用Properties集合中的load方法，把硬盘中保存的文件(键值对)，读取到集合中使用
3. Properties集合中的key和value默认都是字符串
4. 常用方法：
    Object setProperty(String key, String value);//调用Hashtable中的put方法
    String getProperty(String key); //返回指定键的值
    Set<String> stringPropertyNames(); //返回属性列表中的键集
    
    void store(OutputStream out, String comments);
    void store(Writer writer, String comments);
    //OutputStream out：字节输出流，不能写入中文
    //Writer writer：字符输出流，可以写中文
    //String comments：注释，用来结束说明保存的文件是做什么用的。不能使用中文，默认Unicode编码。一般使用空字符串
5. store使用方法：
    1. 创建一个Properties对象，添加数据
    2. 创建字符输出/字节输出流对象，构建方法中绑定要输出的目的地
    3. 使用Properties集合中的方法store，把集合中的临时数据，写入到硬盘中存储
    4. 释放资源
6. load使用方法：
    a. 函数原型
        void load(InputStream inStream);//字节输入流，不能读取含有中文的文件
        void load(Reader reader);//字符输入流，能读取含有中文的键值对
    b. 读取存储文件
        1. 存储键值对的文件中，键与值默认的连接符号可以使用等号/空格/(其他符号)
        2. 存储键值对的文件中，可以使用#进行注释，被注释的键值对不会再被读取
        3. 文件中，键与值默认都是字符串
        

9. 缓冲流

1. 增加一个数组，用于增强之前的4个流
    BufferedInputStream,BufferedOutputStream
    BufferedWriter,BufferedReader
2. 缓冲流继承自OutputStream/Writer/Reader
    a. 继承自父类的共性方法
    b. 构造方法：
        BufferedOutputStream(OutputStream out);//默认大小的缓冲区 -- 1024
        BufferedOutputStream(OutputStream out, int size);//指定大小的缓冲区
        
        BufferedInputStream(InputStream inStream);//默认大小的缓冲区 -- 1024
        BufferedInputStream(InputStream inStream, int size);//指定大小的缓冲区
        
        BufferedWriter(Writer out);
        BufferedWriter(Writer out,int sz);
        
        BufferedReader(Reader reader);
        BufferedReader(Reader reader,int sz);
    c. buf字符流特有成员方法：
        BufferedWriter：
            void newLine();//写入一个分隔符。会依据操作系统获取不同的分隔符
        BufferedReader：
            String readLine();//读取一行文本，返回字符串，不包含行终止符
3. 使用步骤：
    1. 创建一个文件流对象
    2. 创建一个Buf流对象
    3. 写入并刷新缓冲区
    4. 释放资源

10. 解决文件编码问题：转换流

1. 转换流
    InputStreamReader：是字节流通向字符流的桥梁，可以指定编码表将字节转化为字符
    OutputStreamWriter：字符流通向字节流的桥梁，可以指定编码表将字符转化为字节
2. 构造方法：
    OutputStreamWriter(OutputStream out);//创建使用默认字符编码的对象
    OutputStreamWriter(OutputStream out, String charseName);//创建使用指定编码表的对象
3. 使用步骤：
    1. 创建流对象 -- 一般可以使用匿名流对象直接作为参数创建转换流对象
    2. 流对象传入构造方法创建转换流对象
    3. 调用转换流成员方法
    4. 释放转换流资源
4. 释放资源时，一般先是否写流，再是否读流。

11. 序列化流/反序列化流：序列化和反序列化的类必须实现Serializable接口，否则抛出NotSerializableException异常

1. 序列化流：将对象以流的方式写到文件中保存 -- ObjectOutputStream
2. 反序列化流：将文件中保存的对象，以流的方式读取出来 -- ObjectInputStream
3. ObjectOutputStream：
    a. 构造方法：最终都是以字节流写入
        ObjectOutputStream(OutputStream out);
    b. 特有成员方法：
        void writeObject(Object obj);//将指定对象写入ObjectOutputStream
    c. 使用步骤
        1. 创建ObjectOutputStream对象，构造方法中传递字节流对象
        2. 使用ObjectOutputStream中的成员方法writeObject，把对象写入到文件中
        3. 释放资源
    d. 写入对象到文件中后，以二进制存储，因此直接查看是乱码格式。
4. ObjectInputStream：
    a. 构造方法：传入一个字节输入流
        ObjectInputStream(InputStream in);//创建从指定InputStream读取的ObjectInputStream
    b. 特有的成员方法：
        Object readObject();//从ObjectInputStream读取对象
    c. 使用步骤：
        1. 创建ObjectInputStream对象，构造方法中传递字节输入流
        2. 使用ObjectInputStream对象的成员方法readObject读取保存对的文件
        3. 释放资源
5. 如果序列化后，对class进行修改后进行反序列化操作，则抛出异常
    -- 为了避免出现此异常，在序列化类对象定义中，定义一个ID用于标记该对象
    -- private static final long serialVersionUID = <number>L;//随便一个long类型number标记该序列化对象

12. transient关键字：瞬态关键字

1. static关键字修饰：
    静态优先于非静态加载到内存中(静态优先于对象加载到内存中)
    被static修饰的成员变量不能被序列化，序列化的都是对象
2. transient关键字修饰：
    如果希望成员变量不被序列化，但又不是静态成员变量，则用transient关键字修饰

13. 打印流PrintStream

1. 直接向文件中输出内容
2. 可以改变输出语句的目的地(打印的流向)
    输出语句默认在控制台输出，使用System.setOut方法改变输出流
    PrintStream ps = new PrintStream(String FileName);
    System.setOut(ps);
    sout("此时会输出到FileName文件中去");