java学习-第20天

package _01_File;

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

/**
 * File 的基本操作
 * 
 * @author SEC90
 * @Date 2022年1月23日下午9:24:46
 */
public class File_01 {
    public static void main(String[] args) throws IOException {
        //windows 中 用\表示,但是在java中\为转义符,所以要写两个"\\"
        //Linux 中 ,用/ 表示
        //不过现在系统已经优化,混用也可
        //File.separator : 主要解决分隔符问题,Windows系统就是\\,linux系统就是/
        File file = new File("D:\\a\\b\\c");
        //获取全路径 
        System.out.println(file.getAbsolutePath());
        //文件/文件夹名
        System.out.println(file.getName());
        //上级目录
        System.out.println(file.getParent());
        //上级目录对应的文件对象
        System.out.println(file.getParentFile());
        //是否是文件
        System.out.println(file.isFile());
        //是否是目录
        System.out.println(file.isDirectory());
        //是否存在
        System.out.println(file.exists());
        
        file = new File("D:/b.txt");
        System.out.println(file.createNewFile());
        System.out.println(file.delete());
        
         file = new File("D:" + File.separator + "a" + File.separator
                    + "b");
         // 获取所有的子文件对象
         File[] subFiles = file.listFiles();
         for (File file2 : subFiles) {
            System.out.println(file2.getName());
        }
         
         file = new File("D:/com/zrz");
         // 创建目录,如果上级目录不存在,则不创建
         // 创建zrz,但是如果没有com,则不创建
        //  file.mkdir();
         // 创建目录,如果上级目录不存在,就把上级目录也创建好
         file.mkdirs();
         // 删除目录的时候,只会删除zrz并不会删除com,因为file是zrz文件对象
         file.delete();
    }
    }

package _01_File;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * 复制的时候,源目录和目标目录不能一致
 * @author SEC90
 * @Date 2022年1月23日下午9:44:21
 */
public class FileCopy_01 {

    public static void main(String[] args) {
        // 因为创建输出流的时候,如果是覆盖写入,则会在创建对象的时候把对应的文件内容清空,导致读取数据的时候读取不到
        // 如果设置为追加写入,则导致永远读不完
        // 但是使用缓冲流就可以解决这个问题
        try (FileInputStream fis = new FileInputStream("D:/a.txt");
                BufferedInputStream bis = new BufferedInputStream(fis);
                FileOutputStream fos = new FileOutputStream("D:/a.txt",true);
                 ) {
            int temp = 0;
            byte[] bytes = new byte[10];
            while ((temp = bis.read(bytes)) != -1) {
                // System.out.print(new String(bytes, 0, temp));
                fos.write(bytes, 0, temp);
            }
            fos.flush();
            System.out.println("完成");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package _01_File;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/***
 * 递归复制
 * @author SEC90
 * @Date 2022年1月23日下午9:45:44
 */
public class FileCopy_02 {

    public static void main(String[] args) {
        String filePath = "D:\\a\\b";
        copyMenu(new File(filePath));
        System.out.println("复制完成");
    }

    public static void copyMenu(File file) {
        // 1 判断 是否是文件
        if (file.isFile()) {
            // 是文件,则复制
            // 2 获取文件的全路径 , 并创建对应的输入流
            String filePath = file.getAbsolutePath();
            // 3 得到写出的文件全路径,并创建对应的输出流
            // 写出目录定死,就在D盘的数据复制到E盘当中
            String newFilePath = "E"+filePath.substring(1);
            // 判断目标目录是否存在,不存在就创建
            File supFile = new File(newFilePath).getParentFile();
            if (!supFile.exists()) {
                supFile.mkdirs();
            }
            // 4 复制
            try(
                    FileInputStream fis = new FileInputStream(filePath);
                    FileOutputStream fos = new FileOutputStream(newFilePath);
                    BufferedInputStream bis = new BufferedInputStream(fis);
                    BufferedOutputStream bos = new BufferedOutputStream(fos);
                    ) {
                byte[] bytes = new byte[fis.available()+10];
                int temp = 0;
                while ((temp = bis.read(bytes)) != -1) {
                    bos.write(bytes, 0, temp);
                }
                bos.flush();
                System.out.println(file.getName()+" 复制成功");
            } catch (Exception e) {
                e.printStackTrace();
            }
            
        } else {
            // 是目录 则获取目录下所有文件,在进行判断(把子文件对象再次递归传入当前方法中进行操作)
            File[] subFiles = file.listFiles();
            for (File file2 : subFiles) {
                copyMenu(file2);
            }
        }

    }
}

package _01_File;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 创建对象的方式
 *         1 new 用的最多
 *         2 反射机制 可以通过一个字符串来创建对应的对象
 *         3 clone Object中的方法,已经废弃,被序列化代替
 *         4 序列化
 * 
 * 序列化 : 
 *         把堆内存的java对象,持久化保存在本地硬盘当中
 * 反序列化 :
 *         把硬盘当中的序列化文件,反序列化为堆内存对象
 * 
 * 优点 : 
 *         可以长期保存
 *         更利于数据传输
 * 
 * 应用场景
 *         序列化是将数据转换为二进制流进行长期保存,如果不进行序列化 是不能进行长期存储和网络传递的
 *         
 *     网络传输流程 : 
 *         数据对象 --> 序列化 --> 二进制流 --> 加密处理 --> 网络传输 --> 解密处理 --> 二进制流 --> 反序列化 --> 数据对象
 * @author SEC90
 * @Date 2022年1月23日下午9:47:42
 */
public class ObjectOutputStream_01 {

    public static void main(String[] args) {
        User user = new User("admin", "root");
        // System.out.println(user);
        try (FileOutputStream fos = new FileOutputStream("./src/user");
                ObjectOutputStream oos = new ObjectOutputStream(fos);) {
            // 写出
            oos.writeObject(user);
            oos.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

package _01_File;

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

public class ObjectOutputStream_02 {

    public static void main(String[] args) {
        try (
                FileInputStream fis = new FileInputStream("./src/user");
                ObjectInputStream ois = new ObjectInputStream(fis);
                ){
            // 读取数据
            Object object = ois.readObject();
            System.out.println(object);
            // 向下转型
            User user = (User) object;
            System.out.println(user.getPassword());
            user.m1();
            user.m2();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package _01_File;

import java.io.Serializable;

/**
 * 想要被序列化,必须实现Serializable接口,该接口就是一个标识
 * 
 * 说明该类可以被序列化
 * @author SEC90
 * @Date 2022年1月23日下午9:48:53
 */
public class User implements Serializable {
    /**
     * 每次更改类之后,都会重新声明一个版本,此时 如果序列化的对象和类中的版本不对应,就会报错
     * 
     * InvalidClassExceotion
     * 
     * 假如 我们现在只是新增了一个属性,希望向下兼容,这时候我们需要手动控制版本号
     * 
     * 否则 每次类更改之后,都需要重新序列化和反序列化
     * 
     * 值可以随意定义.因为只是定义了类和对象之间的一个版本桥梁
     */
    private static final long serialVersionUID = 1L;
    
    /**
     * transient修饰符,修饰的属性不能被序列化
     * 
     * 可以把不必要的数据,用transient修饰,这样可以提高序列化和反序列化的效率
     */
    private transient String username;
    private String password;
    private int age;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    @Override
    public String toString() {
        return "User [username=" + username + ", password=" + password + "]";
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public User(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }

    public User() {
        super();
    }

    public void m1() {
        System.out.println("我是m1方法");
    }
    public void m2() {
        System.out.println("我是m2方法");
    }
}