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中的删除不走回收站。

要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录

1.4 使用方式

/ windows 中 用 \ 表示 , 但是在java中 \ 为转移符,所以要写两个

                   // linux中 用 / 表示

                   // 不过现在系统已经优化比较好了,混用也没关系

                   // File.separator : 主要解决分隔符问题,window系统就是 \\ linux系统就是 /

                   File file = new File("D:" + File.separator + "20期" + File.separator

                                     + "课件");

                   // 获取全路径  D:\20期\课件

                   System.out.println(file.getAbsolutePath());

                   // 文件 / 文件夹名 课件

                   System.out.println(file.getName());

                   // 上级目录 D:\20期

                   System.out.println(file.getParent());

                   // 上级目录对应的文件对象

                   System.out.println(file.getParentFile());

                   // 判断是否是文件  false

                   System.out.println(file.isFile());

                   // 判断是否是目录 true

                   System.out.println(file.isDirectory());

                   // 判断是否存在

                   System.out.println(file.exists());

                  

                    file = new File("D:/a.txt");

                    // 创建文件,不会创建目录,如果已存在 就不创建

                    // 如果创建了 返回true, 否则  返回false

                    System.out.println(file.createNewFile());

                    // 删除文件,删除成功返回true,否则返回false

                    System.out.println(file.delete());

                    

                    file = new File("D:" + File.separator + "20期" + File.separator

                                               + "课件");

                    // 获取所有的子文件对象

                    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();

1.5 递归复制

1 复制

就是输入和输出结合使用

2 获取文件夹下所有子文件

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

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

注意 :

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

 public static void main(String[] args) {

                   String filePath = "D:\\20期\\课件";

                   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);

                            }

                   }



         }

2. 对象流

2.1 概述

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

2.2 注意

 要序列化的类,必须实现Serializable接口

 * 想要被序列化,必须实现Serializable接口,该接口就是一个标识
 * 
 * 说明该类可以被序列化

2.3 序列化

public class IO_04_ObjectOutputStream {
	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();
		}

	}
}

2.4 反序列化

public class IO_05_ObjectInputStream {
	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();
		}
	}
}

2.5 serialVersionUID

 

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

2.6 Transient

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