Java IO流学习笔记

2021-6-9

1. File类的使用

• java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关
• File能新建、删除、重命名文件和目录，但File不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入输出流
• 想要在java程序中表示一个真是存在的文件或目录，那么必须有一个File对象，但是java程序中的一个File对象，可能没有一个真是存在的文件或目录
• File对象可以作为参数传递给流的构造器

public class FileTest {
    //创建File类的实例
    @Test
    public void test1(){
        //构造器1：File(String filePath)
        File file1 = new File("hello.txt");
        File file2 = new File("D:/Software/JavaProject/guawa210608/src/xyz/guawaz/io");

        //构造器2：File(String parentPath,String childPath)
        File file3 = new File("D:/Software/JavaProject/guawa210608/src/xyz/guawaz","io");

        //构造器3：File(File parentFile,String childPath)
        File file4 = new File(file3,"hi.txt");
    }
}
    //File类的常用方法
    /*
    1.File类的获取功能
    - public String getAbsolutePath() : 获取绝对路径
    - public String getPath() : 获取路径
    - public String getName() : 获取名称
    - public String getParent() : 获取上层文件目录路径，若无，返回null
    - public long length() : 获取文件长度(即字节数) 不能获取目录的长度
    - public long lastModified() : 获取最后一次修改时间(毫秒值)
    
    - public String[] list() : 获取指定目录下的所有文件或者文件夹的名称数组
    - public File[] listFiles() ：获取指定目录下的所有文件或者文件夹的File数组
    */
    /*
    2.File类的重命名功能
    public boolean renameTo(File dest) 
    file.renameTo(file2);
    */
    @Test
    public void test2(){
        File file1 = new File("hello.txt");
        Flie file2 = new File("D:/io/hi.txt");
        
        boolean rt = file1.renameTo(file2);
        System.out.println(rt); //要保证file1实际存在而file2不存在，则返回true
        //作用是将file1剪切到file2指定的路径下并重命名为file2的文件名
    }
    /*
    3.File类的判断功能
    - public boolean isDirectory() : 判断是否是文件目录
    - public boolean isFile() : 判断是否是文件
    - public boolean exists() : 判断是否存在
    - public boolean canRead() : 判断是否可读
    - public boolean canWrite() : 判断是否可写
    - public boolean isHidden() : 判断是否隐藏
    
    */
    /*
    4.File类的创建功能（在硬盘中实际创建）
    - public boolean createNewFile() : 创建文件，若文件存在，则不创建，返回false
    - public boolean mkdir() : 创建文件目录，如果目录存在，则不创建。如果此文件目录的上层目录不存在，也不创建
    - public boolean mkdirs() : 创建文件目录。如果此文件目录的上层目录不存在，一并创建创建
    
    如果创建文件或者文件目录没有写盘符路径，那么默认在项目路径下
    */
    
    /*
    5.File类的删除功能
    - public boolean delete() : 删除文件或文件夹
    要删除一个文件目录，该文件目录内部不能包含文件或文件目录
    */
    
    @Test
    public void test(){
        //文件的创建删除
        File file1 = new File(hi.txt);
        if(!file1.exists()){
            file1.createNewFile();
            System.out.println("创建成功");
        }else{
            file1.delete();
            System.out.println("删除成功");
        }
    }
    @Test
    public void test(){
        //文件目录的创建删除
        File file1 = new File("d:\\io\\io1\\io2");  
        boolean mkdir = file1.mkdir();  //io1不存在，创建不成功
        if(mkdir){
            System.out.println("创建成功1");
        }
        File file2 = new File("d:\\io\\io1\\io3");
        boolean mkdir = file2.mkdir();  //io1不存在，创建成功
        if(mkdir){
            System.out.println("创建成功2");
        }        
    }
    
    
    //File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、
    //文件大小等方法并未涉及到写入或读取文件内容的操作。如果需要读取
    //或写入文件内容等操作，必须使用IO流来完成
    //后续File类的对象常会作为参数传递到流的构造器中指明读取或写入的 "终点"
    
    /*练习1：判断指定目录下是否有后缀名为.jpg的文件，如果有就输出该文件的名称*/
    
    /*练习2：（1）遍历指定目录所有文件名称，包括子文件目录中的文件
             （2）计算指定目录占用空间大小
             （3）删除指定文件目录机器下所有文件
    */
    
    
    

2. IO流原理及流的分类

• IO是Input和Output的缩写，IO技术是非常实用的技术，用于处理设备之间的数据传输。如读写文件，网络通讯等。
• Java程序中，对于数据的输入输出操作以“流（stream）”的方式进行
• Java.io包下提供了各种“流”类和接口，用以传输不同种类的数据
• 输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中
• 输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中
• 流的分类：

1. 按照数据单位不同分为：字节流（8bit），字符流（16bit）
2. 按照数据流的流向不同分为输入流、输出流
3. 按照流的角色不同分为节点流、处理流

package xyz.guawaz.io;

import org.junit.Test;

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

/**
 * @auther guawaz
 * @create 2021-06-08-16:56
 *
 *
 *
 * 一、流的分类
 * 1.操作数据单位：字节流、字符流
 * 2.数据的流向：输入流、输出流
 * 3.流的角色：节点流、处理流
 * 二、流的体系结构
 * 抽象基类             节点流                 缓冲流（处理流的一种）
 * InputStream          FileInputStream     BufferedInputStream
 * OutputStream         FileOutputStream    BufferedOutputStream
 * Reader               FileReader          BufferedReader
 * Writer               FileWriter          BufferedWriter
 *
 *
 *
 */
public class FileReadWriterTest {
    @Test
    public void testFileReader() throws IOException {
        //1.实例化File类的对象，指明要操作的文件
        File file = new File("hello.txt");
        //2.提供具体的流
        FileReader fr = new FileReader(file);
        //3.数据读入
        //read():返回读入的一个字符，如果达到文件末尾，返回-1
//        int data = fr.read();
//        while(data != -1){
//            System.out.print((char)data);
//            data = fr.read();
//        }
        int data;
        while((data = fr.read())!= -1){
            System.out.println((char)data);
        }
        //4.流的关闭
        fr.close();
    }

}
//为了保证流资源一定可以执行关闭操作，需要使用try-catch-finally来处理，修改如下：
public class FileReadWriterTest {
    @Test
    public void testFileReader() throws {
        FileReader fr = null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("hello.txt");
            //2.提供具体的流
            fr = new FileReader(file);
            //3.数据读入
            //read():返回读入的一个字符，如果达到文件末尾，返回-1
            int data;
            while((data = fr.read())!= -1){
                System.out.println((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //4.流的关闭.
                if (fr!=null)   //防止是fr = new FileReader(file);这一行出了异常
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}
//读入的文件一定要存在，否则就会报FileNotFoundException

//对read()方法的操作升级，使用它的重载方法
    @Test
    public void testFileReader1() {
        FileReader fr = null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("hello.txt");
            //2.提供具体的流
            fr = new FileReader(file);
            //3.数据读入
            //read():返回读入的一个字符，如果达到文件末尾，返回-1
            char[] cbuf = new char[5];
            int len;
            while((len = fr.read(cbuf))!= -1){
                //方式一：
                //错误的写法
                for(int i = 0 ;i < cbuf.length; i++){
                    System.out.println(cbuf[i]);
                }
                //正确的写法
                for(int i = 0 ;i < len; i++){
                    System.out.println(cbuf[i]);
                }
                /*
                //方式二：
                //错误的写法
                String str = new String(cbuf);
                System.out.println(str);
                //正确的写法
                String str = new String(cbuf,0,len);
                System.out.println(str);
                 */
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //4.流的关闭.
                if (fr!=null)   //防止是fr = new FileReader(file);这一行出了异常
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }


    /*
    *从内存中写出数据到硬盘的文件里
    *
    * 1.File对应的硬盘中的文件可以不存在，如果不存在会新建好
    * 2.File对应的硬盘中的文件如果存在
    *       如果流使用的构造器是：FileWriter(file,append：false)/FileWriter(file):输出数据操作会对原有文件内容进行覆盖
    *       如果流使用的构造器是：FileWriter(file,append：true)：输出操作是在原有文件内容上添加内容
    *
    *
    * */
    @Test
    public void testFileWriter(){
        FileWriter fileWriter = null;
        try {
            //1.创建File对象
            File file = new File("hello.txt");
            //2.创建输出流对象
            fileWriter = new FileWriter(file);
            //3.输出数据
            fileWriter.write("I have a dream!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileWriter != null)
                //4.关闭流资源
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
    
    /*
     *先读进来再写出去
     * */
    @Test
    public void testFileReaderFileWriter(){
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        try {
            //1.创建File对象，指明读入和写出的文件
            File srcFile = new File("hello.txt");
            File destFile = new File("hello2.txt");
            //2.创建输入流和输出流对象
            fileReader = new FileReader(srcFile);
            fileWriter = new FileWriter(destFile);
            //3.读取数据、输出数据
            char[] cbuf = new char[5];
            int len;
            while((len = fileReader.read(cbuf)) != -1){
    //            for (int i = 0 ; i < len ; i ++){
    //                fileWriter.write(cbuf[i]);
    //            }
                String str = new String(cbuf);
                fileWriter.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileWriter != null) {
                    //4.关闭流资源
                    fileWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fileReader != null) {
                    //4.关闭流资源
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            //方式二
//            try {
//                if (fileWriter != null) {
//                    //4.关闭流资源
//                    fileWriter.close();
//                }
//            } catch (IOException e) {
//                e.printStackTrace();
//            } finally {
//                try {
//                    if (fileReader != null) {
//                        //4.关闭流资源
//                        fileReader.close();
//                    }
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//
//            }
        }
    }

3. 节点流（或文件流）

• 使用字符流不能处理图片文件

package xyz.guawaz.io;

import org.junit.Test;

import java.io.*;

/**
 * @auther guawaz
 * @create 2021-06-08-20:50
 */
public class FileInputOutputStreamTest {
    @Test
    public void testFileInputOutputStream() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //1.造文件
            File srcfile = new File("dream.png");
            File destfile = new File("dream1.png");
            //2.造流
            fis = new FileInputStream(srcfile);
            fos = new FileOutputStream(destfile);
            //3.读数据写数据
            byte[] buffer = new byte[5];
            int len;
            while((len = fis.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流
            try {
                if (fis != null)
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fos != null)
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

4. 处理流之一：缓冲流

package xyz.guawaz.io;

import org.junit.Test;

import java.io.*;

/**
 * @auther guawaz
 * @create 2021-06-08-23:13
 *
 * 处理流之一：缓冲流的使用
 * 1.缓冲流
 * BufferedInputStream
 * BufferedOutputStream
 * BufferedReader
 * BufferedWriter
 *2.作用：提高流的读取写入速度
 *
 */
public class BufferedTest {
    @Test
    public void bufferedStreamTest(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.造文件
            File srcFile = new File("dream.png");
            File destfile = new File("dream2.png");
            //2.造流
            //2.1造结点流
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destfile);
            //2.2造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //3.读取写入数据
            byte[] buffer = new byte[10];
            int len;
            while((len = bis.read(buffer)) != -1){
                //数据加密
                //for(int i = 0 ; i < len ; i ++){
                //    buffer[i] = (byte)(buffer[i]^5);
                //}
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流 (关闭缓冲流自动会关闭节点流)
            try {
                if (bis != null)
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bos != null)
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

    @Test
    public void bufferedReaderBufferedWriterTest(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //1.造文件
            File srcfile = new File("hello.txt");
            File destfile = new File("hello1.txt");
            //2.造流
            //2.1造结点流
            FileReader fr = new FileReader(srcfile);
            FileWriter fw = new FileWriter(destfile);
            //2.2造缓冲流
            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);
            //3.读取写出数据
            char[] buffer = new char[10];
            int len;
            while((len = br.read(buffer)) != -1){
                bw.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            try {
                if (br != null)
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bw != null)
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
    @Test
    public void bufferedReaderBufferedWriterTest1(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //创建文件及相应的流
            br = new BufferedReader(new FileReader(new File("hello.txt")));
            bw = new BufferedWriter(new FileWriter(new File("hello3.txt")));
            //3.读取写出数据
            //方式一
//            char[] buffer = new char[10];
//            int len;
//            while((len = br.read(buffer)) != -1){
//                bw.write(buffer,0,len);
//            }
            //方式二
            String data;
            while((data = br.readLine()) != null){
                bw.write(data + "\n");
                //bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关流
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bw != null) {
                    bw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * @auther guawaz
     * @create 2021-06-08-23:13
     * 获取文本文件中某个字符出现的次数，并写入文件
     * 思路：遍历文本文件的每一个字符，将字符出现的次数存在Map中
     */
    @Test
    public void wordCount(){
        FileReader fr = null;
        FileWriter fw = null;
        try {
            File file = new File("hello.txt");
            fr = new FileReader(file);
            fw = new FileWriter(file,true);

            Map<Character,Integer> map = new HashMap<>();
            int c = 0;
            while((c= fr.read()) != -1){

                char ch = (char)c;

                if(map.get(ch) == null){
                    map.put(ch,1);
                }else{
                    map.put(ch, map.get(ch) + 1);
                }
            }
            //遍历map，写入数据
            Set<Map.Entry<Character,Integer>> entrySet = map.entrySet();
            fw.write("\n");
            for(Map.Entry<Character,Integer> entry : entrySet){
                switch(entry.getKey()){
                    case ' ':
                        fw.write("空格=" + entry.getValue());
                        break;
                    case '\t':
                        fw.write("tab键="+entry.getValue());
                        break;
                    case '\r':
                        fw.write("回车=" + entry.getValue());
                        break;
                    case '\n':
                        fw.write("换行=" + entry.getValue());
                        break;
                    default:
                        fw.write(entry.getKey() + "=" + entry.getValue());
                        break;
                }
                fw.write("\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fr != null) {
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

5. 处理流之二：转换流

• 转换流提供了字符流和字节流之间的转换
• JavaAPI提供了两个转换流:InputStreamReader和OutputStreamWriter
• 字节流中的数据都是字符时,转换成字符流操作更高效
• 很多时候我们使用转换流来处理文件乱码的问题，实现编码和解码的功能

package xyz.guawaz.io;

import org.junit.Test;

import java.io.*;

/**
 * @auther guawaz
 * @create 2021-06-09-11:20
 *
 * 处理流之二：转换流的使用
 * 1.转换流：属于字符流
 *
 *      InputStreamReader:将一个字节的输入流转换为字符的输入流
 *      OutputStreamWriter:将一个字符的输出流转换为字节的输出流
 *
 * 2.作用：提供字符流和字节流之间的转换
 *
 * 3.解码：字节、字节数组 --->字符、字符串
 *   编码：字符、字符串---->字节、字节数组
 *
 * 4.字符集
 *
 *
 */
public class InputStreamReaderTest {
    @Test
    public void test1(){
        InputStreamReader isr = null;
        try {
            FileInputStream fis = new FileInputStream("hello.txt");

            isr = new InputStreamReader(fis,"utf-8");

            char[] cbuf = new char[5];
            int len;
            while((len = isr.read(cbuf)) != -1){
                String str = new String(cbuf,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (isr != null) {
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
    /*
    *
    * 综合使用InputStreamReader和OutputStreamWriter
    *
    * */
    @Test
    public void test2(){
        InputStreamReader isr = null;
        OutputStreamWriter osw = null;
        try {
            File srcfile = new File("hello.txt");
            File destfile = new File("hello_gbk.txt");

            FileInputStream fis = new FileInputStream(srcfile);
            FileOutputStream fos = new FileOutputStream(destfile);

            isr = new InputStreamReader(fis,"utf-8");
            osw = new OutputStreamWriter(fos,"gbk");

            char[] cbuf = new char[20];
            int len;
            while((len = isr.read(cbuf)) != -1){
                osw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (isr != null) {
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (osw != null) {
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}    

• 字符集

常见的编码表：
ASCII:美国标准信息交换码，用一个字节的7位来表示字符
ISO8859-1：拉丁码表，欧洲码表，用一个字节的8位来表示字符
GB2312：中文汉字编码表，最多两个字节编码字符
GBK：中文汉字编码表升级，包含更多的汉字，最多两个字节编码字符
Unicode：国际标准编码表，融合了当前人类使用的所有字符。为每个字符分配唯一的字符码，所有文字都用两个字节来表示
UTF-8：边长的编码方式，可以使用1~4个字节来小时一个字符

6. 标准输入输出流以及其他流

处理流之六:对象流
objectInputStream和OjbectOutputSteam
用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可
以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
序列化:用ObjectOutputStream类保存基本类型数据或对象的机制反序列化:用ObjectInputStream类读取基本类型数据或对象的机制ObjectOutputStream和ObjectInputStream不能序列化static和ltransient修饰的成员变量

对象的序列化
●对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象
●序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原
●序列化是 RMI (Remote Method lnvoke -远程方法调用）过程的参数和返回值都必须实现的机制，而RMI是JavaEE的基础。因此序列化机制是JavaEE平台的基础
●如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。杏则，会抛出NotSerializableException异常
> Serializable
> Externalizable

package xyz.guawaz.io;

import org.junit.Test;

import java.io.*;

/**
 * @auther guawaz
 * @create 2021-06-09-17:24
 */
public class ObjectInputOutputStreamTest {
    @Test
    public void testObjectOutputStream(){
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("object.dat"));

            oos.writeObject(new String("我爱北京天安门"));

            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        }

        if (oos != null) {
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    @Test
    public void testObjectIntputStream() {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.dat"));
            Object obj = ois.readObject();
            String str = (String)obj;
            System.out.println(str);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
        }

        if (ois != null) {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

• 自定义类的序列化和对象流
• 自定义类必须实现Serializable接口并且拥有全局常量serialVersionUID

package xyz.guawaz.io;

import java.io.Serializable;
import java.util.Objects;

/**
 * @auther guawaz
 * @create 2021-06-09-18:08
 */
public class Person implements Serializable {
    public static final long serialVersionUID = 45678912254L;

    private String name;
    private int age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

}
//----------------------------------------------------------------------------------
package xyz.guawaz.io;

import org.junit.Test;

import java.io.*;

/**
 * @auther guawaz
 * @create 2021-06-09-17:24
 */
public class ObjectInputOutputStreamTest {
    @Test
    public void testObjectOutputStream(){
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("object.dat"));

            oos.writeObject(new String("我爱北京天安门"));
            oos.flush();
            oos.writeObject(new Person("Guawaz",24));
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        }

        if (oos != null) {
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    @Test
    public void testObjectIntputStream() {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.dat"));
            Object obj = ois.readObject();
            String str = (String)obj;
            System.out.println(str);
            Object obj1 = ois.readObject();
            Person person = (Person)obj1;
            System.out.println(person);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
        }

        if (ois != null) {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

• serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
• 如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID可能发生变化，所以必须显示声明。
• 除了当前类需要实现Serializable接口外，其内部所有属性也必须是可序列化的（默认情况下，基本数据类型是可序列化的）
• static和transient修饰的成员变量不能被序列化
• 序列化是JavaEE平台的基础，通常把要序列化的内容转换成一种特殊格式的字符串：json

7. 随机存取文件流 RandomAccessFile类

-RandomAccessFile类声明在java.io包下，但直接继承与java.lang.Object类，
 并且它实现了DataInput和DataOutput接口，也就以为着这个类既可以读也可以写。
-RandomAccessFile类支持“随机访问”的方式，程序可以直接跳到文件的任意位置来
读写文件
- RandomAccessFile对象包含一个记录指针，用以标示当前读写处的位置。
RandomAccessFile类对象可以自由移动记录指针:
>long getFilePointer():获取文件记录指针的当前位置
>void seek(long pos):将文件记录指针定位到pos位置

package xyz.guawaz.io;

import org.junit.Test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * @auther guawaz
 * @create 2021-06-09-19:44
 *
 * 如果RandomAccessFile作为输出流时，如果写出到的文件不存在，则会自动创建
 * 如果文件存在，则会对原有文件内容进行覆盖（是文件内容不是文件，默认从头开始覆盖）
 *
 * 创建RandomAccessFile类实例的时候需要指定一个mode参数，该参数指定RandomAccessFile的访问模式
 * r:以只读方式打开
 * rw:打开以便读取和写入
 * rwd:打开以便读取和写入;同步文件内容的更新
 * rws:打开以便读取和写入;同步文件内容和元数据的更新
 */
public class RandomAccessFileTest {
    @Test
    public void test1(){
        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;
        try {
            //1
            raf1 = new RandomAccessFile("dream.png", "r");
            raf2 = new RandomAccessFile("dream3.png", "rw");
            //2
            byte[] buffer = new byte[20];
            int len;
            while((len = raf1.read(buffer)) != -1){
                raf2.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3
            if (raf1 != null) {
                try {
                    raf1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (raf2 != null) {
                try {
                    raf2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /*
       如果RandomAccessFile作为输出流时，如果写出到的文件不存在，则会自动创建
       如果文件存在，则会对原有文件内容进行覆盖（是文件内容不是文件，默认从头开始覆盖）
    */
    @Test
    public void test2() throws IOException {
        RandomAccessFile raf1 = new RandomAccessFile("hello.txt", "rw");
        raf1.write("xyz".getBytes());
        raf1.close();
    }


    /*
        使用RandomAccessFile实现数据插入的效果
   */
    @Test
    public void test3() throws FileNotFoundException {
        RandomAccessFile raf1 = null;
        try {
            raf1 = new RandomAccessFile("hello.txt", "rw");

            raf1.seek(3);
            //保存指针3后面所有数据到StringBuilder中
            StringBuilder sb = new StringBuilder((int)new File("hello.txt").length());
            byte[] buffer = new byte[20];
            int len;
            while ((len = raf1.read(buffer)) != -1){
                sb.append(new String(buffer,0,len));
            }
            raf1.seek(3);
            raf1.write("xyz".getBytes());
            raf1.write(sb.toString().getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (raf1 != null) {
                try {
                    raf1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Java NIO

-Java NIO是从jdk1.4开始引入的一套新的IO API，可以替代标准的Java IO API，NIO与原来的IO有相同的作用和目的，但是使用方式完全不同。NIO是面向缓冲区的基于通道的，而IO是面向流的。NIO可以更高效地进行文件读写

• Java API提供了两套NIO，一套是针对标准输入输出IO，另一套是网络编程NIO

|----java.nio.channels.Channel
            |----FileChannel:处理本地文件
            |----SocketChannel：TCP网络编程中客户端的Channel
            |----ServerSocketChannel：TCP网络编程中服务端的Channel
            |----DatagramChannel：UDP网络编程中发送端和接收端的Channel

• 随着JDK7的发布，Java 对NIO进行了极大的扩展，增强了对文件处理和文件系统特性的支持，以至于我们称其为NIO.2 ,NIO已经成为文件处理中越来越重要的部分
• NIO.2中Path、Paths、Files类的使用

- 早期的Java只提供了一个File类来访问文件系统，但File类的功能 比较有限，所
提供的方法性能也不高。而且，大多数方法在出错时仅返回失败，并不会提供异常信息。
- NIO.2为了弥补这种不足，引入了Path接口，代表一个平台无关的平台路径，描述了
目录结构中文件的位置。Path可以看成是File类的升级版本，实际引用的资源也可以不存在。

- 在以前I0操作都是这样写的:
import java.io.File;
File file = new File("index.html");
但在Java7中，我们可以这样写:
import java.nio.file.Path;
import java.nio.file.Paths;
Path path = Paths.get("index.html");

- 同时，NIO.2在java.nio.file包 下还提供了Files、Paths工具类，Files包含
了大量静态的工具方法来操作文件; Paths则包含 了两个返回Path的静态工厂方法。

常用的方法就不展开讲了 用到的时候再说

使用第三方jar包实现数据的读写

• ohhhhhhhhhhhhhhhhhhhhhhhhhhhhh
• 右键 -> New -> Directory ->libs+OK -> Ctrl+V粘进来 -> 右键 -> add as library