Day16 学习java（File操作、递归复制、序列化）

File

概述

java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关

File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对 象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。

File对象可以作为参数传递给流的构造器

构造方法

public File(String pathname)以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
绝对路径：是一个固定的路径,从盘符开始
相对路径：是相对于某个位置开始
public File(String parent,String child)以parent为父路径，child为子路径创建File对象。
public File(File parent,String child)根据一个父File对象和子文件路径创建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数组
重命名功能：
public boolean renameTo(File dest):把文件重命名为指定的文件路径
判断功能：
 public boolean isDirectory()：判断是否是文件目录
public boolean isFile() ：判断是否是文件
public boolean exists() ：判断是否存在
public boolean canRead() ：判断是否可读
public boolean canWrite() ：判断是否可写
public boolean isHidden() ：判断是否隐藏
创建删除功能：
 public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。 如果此文件目录的上层目录不存在，也不创建。
public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建
注意事项：如果你创建文件或者文件目录没有写盘符路径，那么，默认在项目 路径下。
public boolean delete()：删除文件或者文件夹
删除注意事项：
Java中的删除不走回收站。
要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录

使用方式

public class IO_01_File {

	public static void main(String[] args) throws IOException {
		// windows中用 \ 表示，但是在java中\为转译符，所以要写两个
		// linux中用/表示
		// 不过现在系统优化已经很好了,混用也没关系
		// File.separator ：主要解决分隔符问题，window系统就是 \ linux就是/
		File file = new File("D:" + File.separator + "cym" + File.separator
				+ "a.txt");
		// 获取全路径
		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:/cym/a.txt");
		// 创建文件，不会创建目录，如果已存在，就不创建
		// 如果创建了返回true ，否则返回false
		System.out.println(file.createNewFile());
		// 删除文件，删除成功返回true，否则返回false
		System.out.println(file.delete());
		file = new File("D:/cym");
		// 获取所有的子文件对象
		File[] subFiles = file.listFiles();
		for (File file1 : subFiles) {
			System.out.println(file1.getName());
		}
		file = new File("D:/cym/cym1");
		// 创建目录，如果上级目录不存在，则不创建
		// 创建cym1，但是如果没有cym，则不创建
		file.mkdir();
		// 创建目录，如果上级目录不存在，就把上级目录也创建好
		// file.mkdirs();
		// 删除目录的时候，只会删除cym1并不会删除cym，因为file是cym1文件对象
		file.delete();
	}

}

复制的时候，源目录和目标目录不能一致

public class IO_02_FileCopy {

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

递归复制

public class IO_03_FileCopy {

	public static void main(String[] args) {
copyMenu(new File("D:/abcd"));
	}

	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();
			}
			// 复制
			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 f : subFiles) {
				copyMenu(f);
			}
		}
	}

}

对象流

概述

创建对象的方式

•  1.new：用的最多
  

•  2.反射机制：可以通过一个字符串来创建对应的对象
  

•  3.clone Object中的方法，已经废弃，被序列化代替
  

•  4.序列化
  

序列化：把堆内存的java对象，持久化保存在本地硬盘中

反序列化：把硬盘当中的序列化文件，反序列化为堆内存对象

优点：

• 可以长期保存
  

•  	更利于数据传输
  

应用场景

•  	序列化是将数据转换为二进制流进行长期保存，如果不进行序列化，是不能进行长期存储和网络传递的
  

网络传输流程：

•  	数据对象→序列化→二进制流→加密处理→网络传输→解密处理→二进制流→反序列化→数据对象
  

注意

想要被序列化，必须必须实现Serializable接口，该接口没有方法，就是一个标识，用来说明该类可以序列化

要如下声明

序列化

public class IO_04_ObjectOutputStream {

	public static void main(String[] args) {
		Student s = new Student(18, "张三");
		System.out.println(s);
		try (FileOutputStream fos = new FileOutputStream("./src/_1_22/s");
				ObjectOutputStream oos = new ObjectOutputStream(fos);) {
			// 写出
			oos.writeObject(s);
			oos.flush();

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

反序列化

public class IO_05_ObjectInputStream {

	public static void main(String[] args) {
		try (FileInputStream fis = new FileInputStream("./src/_1_22/s");
				ObjectInputStream ois = new ObjectInputStream(fis);) {
			// 读取数据
			Object o = ois.readObject();
			System.out.println(o);
			//向下转型
			Student s = (Student)o;
			System.out.println(s.age);
			s.m1();
			s.m2();
		}

		catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}

serialVersionUID

每次更新类之后都会重新声明一个版本，此时，如果序列化的对象和类中过的版本不对应就会报错
假如只新增了一个属性，希望向下兼容，这时我们需要手动控制版本号 否则每次更新之后都要重新序列化和反序列化
值可以随意定义，因为只是一个类和对象之间的一个版本桥梁

Transient

transient修饰符，修饰的属性不能被序列化，可以把不必要的教程，用transient修饰，这样可以提高序列化和反序列化的效率