package com.caq.java;
import org.junit.Test;
import java.io.*;
/**
    转换流
 2.作用:提供字节流与字符流之间的转换
 3.解码:字节、字节数组--->字符数组、 字符串
   编码:字符数组、字符串--->字节、字节数组
 4.字符集
 * @Date 2021/12/1 15:37
 * @Version 1.0
 */
public class InputStreamReaderTest {
    /*
        此时处理异常的话，仍然应该使用try-catch-finally
        InputStreamReader的使用，实现字节的输入流到字符的输入流的转换
     */
    @Test
    public void test1() throws IOException {
        FileInputStream fis = new FileInputStream("dbcp.txt");
        //使用系统默认的字符集
//        InputStreamReader isr = new InputStreamReader(fis);
        InputStreamReader isr = new InputStreamReader(fis,"gbk");
        char[] cbuf = new char[20];
        int len;
        while ((len = isr.read(cbuf)) != -1){
            String str = new String(cbuf, 0, len);
            System.out.println(str);
        }
        isr.close();
    }
    @Test
    public void  test2() throws IOException {
        //指定文件，指定流，用转换流把指定流抱起来
        InputStreamReader isr = new InputStreamReader(new FileInputStream("dbcp.txt"),"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("dhcp_gbk.txt"),"gbk");
        char[] cbuf = new char[20];
        int len;
        while ((len = isr.read(cbuf)) != -1){
            osw.write(cbuf,0,len);
        }
        isr.close();
        osw.close();
    }
}

Person类
package com.caq.java;
import java.io.Serializable;
/**
 Person类需要满足如下要求方可序列化
 1.需要实现Seriallizable接口
 2.提供一个全局常量static final long serialVersionUID = 42L;
 3.除了当前Person类需要实现Serializable接口之外，还必须保证其他所有属性
 是可序列化的！
 默认情况下，基本数据类型是可序列化的
 4.对象序列化机制允许把内存中的Java对象转换成平台
 无关的二进制流，从 而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传 输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原 来的Java对象
 * @Date 2021/12/2 18:14
 * @Version 1.0
 */
public class Person implements Serializable {
    public static final long serialVersionUID = 56354763763L;
    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 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 +
                '}';
    }
}

package com.caq.java;
import org.junit.Test;
import java.io.*;
/**
 * ObjectInputStream和ObjectOutputStream
 * 作用：用于存储和读取基本数据或对象的处理流，
 * 它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来
 *
 * @Date 2021/12/2 17:18
 * @Version 1.0
 */
public class ObjectInputOutputStreamTest {
    /**
     * 将内存中的Java对象保存到磁盘中或通过网络传输出去
     * 使用ObjectOutputStream实现
     */
    //序列化单元测试
    @Test
    public void testObjectOutputStream() {
        ObjectOutputStream oos = null;
        try {
            //1.创建序列化流
            oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
            //2.
            oos.writeObject(new String("我爱你！"));
            oos.flush();//刷新操作
            oos.writeObject(new Person("朱茵",12));
            oos.flush();//刷新操作
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //反序列化测试
    @Test
    public void testObjectOutputStream2() {
        ObjectInputStream ois = null;
        try {
            //反序列化流
            ois = new ObjectInputStream(new FileInputStream("object.dat"));
            Object obj = ois.readObject();
            String str = (String) obj;
            Person p = (Person)ois.readObject();
            System.out.println(p);
            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();
                }
            }
        }
    }
}

package com.caq.java;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
 * RandomAccessFile 声明在java.io包下，但直接继承于java.lang.Object类。并
 * 且它实现了DataInput、DataOutput这两个接口，也就意味着这个类既可以读也
 * 可以写。
 *
 * @Date 2021/12/2 20:27
 * @Version 1.0
 */
public class RandomFile {
    @Test
    public void test1() {
        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;
        try {
            raf1 = new RandomAccessFile(new File("img/cxk.jpg"), "r");
            raf2 = new RandomAccessFile(new File("cxk1.jpg"), "rw");
            byte[] buffer = new byte[1024];
            int len;
            while ((len = raf1.read(buffer)) != -1) {
                raf2.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            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.seek(3);
        raf1.write("xyz".getBytes());
        raf1.close();
    }
    //用RandomAccessFile实现数据的插入效果
    @Test
    public void test3() throws IOException {
        RandomAccessFile raf1 = new RandomAccessFile("hello.txt", "rw");
        raf1.seek(3);//指针遇到角标为3的位置
        byte[] buffer = new byte[20];
        int len;
        while ((len = raf1.read(buffer)) != -1){
        }
    }
}