Day-20 File操作，递归复制，序列化

1 File

1.1概述：

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

File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。

如果需要访问文件内容本身，则需要使用输入/输出流。

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

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

1.2 构造方法

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对象

1.3常用方法

获取功能：

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 static void main(String[] args) throws IOException{
			//windows 中用\表示 但是在java中用\为转义符。所以写俩个
			//linux 中用/表示，现在系统已经优化比较好了，混用也没关系
			//File.separator: 主要解决分隔符问题，window 系统\\ linxu系统就是/
			File file = new  File("E:"+File.separator +"字节");
			//获取全路径	D:\software\eclipse\workspace\Day-19\E：\字节
			System.out.println(file.getAbsolutePath());
			// 文件/文件夹名  课件
			System.out.println(file.getName());
			// 上级目录   E
			System.out.println(file.getParent());
			//上级目录对应的文件对象    E
			System.out.println(file.getParentFile());
			//判断是否是文件	false
			System.out.println(file.isFile());
			//判断是否是目录	true
			System.out.println(file.isDirectory());
			//判断是否存在	true
			System.out.println(file.exists());
			
			file = new File("E:/w.txt");
			//创建文件。不会创建目录，如果已经存在就不再创建
			// 如果创建了 返回true 否则返回 false
			System.out.println(file.createNewFile());
			//删除文件，删除成功 返回truea ,否则返回false
		//	System.out.println(file.delete());
			file = new File("E:" +File.separator + "字节");
			//获取所有的子文件对象
			File [] subFiles = file.listFiles();
			for( File file2 :subFiles){
				System.out.println(file2.getName());
				
			}
			file = new File("E:/字节/字节1/q.txt");
			//创建目录，如果上级目录不存在 则不创建
			//创建q.txt    如果字节不存在 不创建
			file.mkdir();
			// 创建目录，如果上级目录不存在，九八上级目录也创建好
			file.mkdirs();
			//删除目录的时候，只会删除 q.txt 不会删除 字节1. 因为file 是q.tat文件对象
			file.delete();
		}

2递归复制

2.1 复制  ： 就是输入和输出结合使用

2.2   获取文件夹下所有文件

        如果子文件是文件，则复制

        如果子文件是目录，则再次获取该目录的所有子文件，做相同操作

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

	public static void main(String[] args){
		String filePath = "E:\\字节";
		copyMenu(new File(filePath));
		System.out.println("复制完成");
	}
	public static void  copyMenu(File file){
		//1 判断是否是文件
		if(file.isFile()){
			//是文件  则复制
			//2 获取文件的全路径，并创建对应的输出流
			String filePath = file.getAbsolutePath();
			//3 得到写出的文件全路径，并创建对应的输出流
			// 写出目录顶死，即从哪复制到哪里
			String newFilePath = "F"+ 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);
			}
		}
	}

3对象流

创建对象流的方式： 1 new的最多  2 反射机制   可以通过一个字符串来创建对应的对象       3clone  Object中的方法 已经废弃被序列化替代      4序列化

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

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

优点： 可以长期保存       更利于数据传输

应用场景： 序列化是将数据转换为二进制流进行长期保存，如果不进行序列化，是不能进行长期                 储存和网络床送的

网络传输流程：

        数据对象-->序列化-->二进制流-->加密处理-->网络传输-->精密处理-->二进制流-->反序列化-->数据对象

注意!!!!!!!!!!!!!:: 要序列化的类，必须实现Serializable接口

想要被序列化，必须实现Serializable接口，该接口就是一个标识

3.1序列化

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

3.2反序列化

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

User类

public class User implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	/**
	 * 每次更改类之后，都会重新声明一个版本，此时如果序列化的对象和类中的版本不对应，就会报错
	 * InvalidClassExceotion
	 * 假如，我们现在只是新增了一个属性，希望向下兼容，这时候我们需要手动控制版本号
	 * 否则 每次类更改之后     都需要重新序列化和反序列化
	 * 值可以随意定义，因为只是定义了类和对象之间的一个版本桥梁
	 * private static final long serialVersionUID =1L;
	 * transient 修饰符，修饰的属性不能被序列化
	 * 可以把不必要的数据用transient 修饰，这样可以提高序列化和反序列化 的效率
	 * 
	 */
	private  transient String username;
	private String password;
	private int age;
	private String sex;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public User(String username, String password) {
		super();
		this.username = username;
		this.password = password;
	}
	@Override
	public String toString() {
		return "User [username=" + username + ", password=" + password + "]";
	}
	public User() {
		super();
	}
	public void m1(){
		System.out.println("m1方法");
		System.out.println("m2方法");
	}

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

3.3 serialVersionUID

每次更改类之后 ，都会重新声明一个版本，此时    如果序列化的对象和类中的版本不对应就会报错