Java IO之File

import java.io.File;
import java.io.IOException;
/**
 * Input / Output  :输入/输出机制
何为输入机制：
允许Java程序获取外部设备的数据（磁盘，光盘，网络等）。
何为输出机制：
保留java程序中的数据，输出到外部设备上（磁盘，光盘等）。

File 类
  File类的由来：
  File类的出现弥补了IO流的不足，IO只能够操作数据，但是并不能够对于文件的信息做操作，操作文件必须使用
  File类。

  功能：
  1.可以将文件或者文件夹在程序当中封装成对象。
  2.方便对于文件或者文件夹当中的属性信息进行操作。
  3.File类通常通过构造函数作为参数传递到流的对象当中。

 * File常用的方法介绍：
 * 1.构造函数
 * 
 * 2.创建相关函数
 * createNewFile() : 创建文件，如果创建成功返回true，否则返回false。
 * createTempFile(String prefix, String suffix) ： 在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。
 * mkdir() ：创建文件夹
 * mkdirs()：创建文件夹，如果此文件夹父目录不存在，那么父目录也会被创建。 
 * 
 * 3.删除
 * delete():删除文件或者文件夹（注意只能删除空文件夹）
 * deleteOnExit() ：在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
 * */
public class FileDemo01 {
	public static void main(String[] args) {
		constMethod();
//		createMethod();
	}
	public static void createMethod(){
		File f1 = new File("c:\\readme.txt");
		try {
			boolean createNewFile = f1.createNewFile();
			System.out.println("创建文件成功了么？"+createNewFile);
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		File f2 = new File("c:\\liu\\abc\\tt");
		boolean mkdir = f2.mkdirs();
		System.out.println("创建文件夹成功了么？"+mkdir);
		
		File f3 = new File("c:\\liu");
		boolean delete = f3.delete();
		System.out.println("删除成功了么？"+delete);
	}
	
	public static void constMethod(){
//		通过这个构造方法可以将已经存在的或者不存在的文件封装成file对象。
		File f1 = new File("c:\\abc.txt");
//	把当前路径Day17目录下的文件a.txt封装成对象	
		File f2 = new File("a.txt");
//		将文件夹可以封装成file对象
		File f3 = new File("c:\\Java\\jre7");
		
		File f4 = new File("c:\\Java");
//		好处：可以使得file对于同一个路径的不同文件进行操作。
		File f5 = new File(f4, "jre7");
//		f3和f5两个对象其实代表了同一个文件。
		
		System.out.println(f3);
		System.out.println(f5);
		
		System.out.println(f3.equals(f5));
		File f6 = new File("c:\\Java", "jre7");
		System.out.println(f6);
//		file的toString方法重写了，封装的地址是什么，对象就打印什么。
		
		File f7 = new File("c:/abc.txt");
		System.out.println(f7);
//		"/"和"\\"都是目录分割符号，在其他操作系统当中目录分割符可能发生变化，这个写法不利于跨平台操作。
//		最好使用File当中提供的字段separator进行分割，使用这个分隔符，在不同的操作系统上，会显示不同的分割符。
		
		File f8 = new File("c:"+File.separator+"abc.txt");
//		这种写法可以使f8对象实现跨平台操作
		System.out.println(f8);
	}
}

import java.io.File;
import java.io.IOException;
/**
 * 4.判断：
 * exists() ：判断文件或者文件夹是否存在。
   canExecute() :判断文件是否可执行，和操作系统相关。
   canRead() :判断文件是否可读
 * canWrite() :判断文件是否可写
 * equals(Object obj) :测试此抽象路径名与给定对象是否相等。
 * isAbsolute() :测试此抽象路径名是否为绝对路径名。
 * isDirectory() :判断file对象是否表示文件夹。
 * isFile() :判断file对象是否表示文件
   isHidden() :判断file对象是否是隐藏文件
   5.获取file对象属性信息的方法：
  getAbsoluteFile() ：返回此抽象路径名的绝对路径名形式。 
  getAbsolutePath() ：返回此抽象路径名的绝对路径名字符串。 
  getCanonicalFile() ： 返回此抽象路径名的规范形式。 
  getCanonicalPath() ：返回此抽象路径名的规范路径名字符串。 
  getPath() ： 将此抽象路径名转换为一个路径名字符串。
  getName() : 返回由此抽象路径名表示的文件或目录的名称。
  getParent() :返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。 
  getParentFile() :返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。 
  getTotalSpace() :返回指定路径的全部空间的字节数
  getFreeSpace() :返回此抽象路径名指定的分区中未分配的字节数。
  getUsableSpace() : 返回此抽象路径名指定的分区上可用于此虚拟机的字节数。
  renameTo(File dest) :重新命名此抽象路径名表示的文件。剪切
 **/
public class FileDemo02 {

	public static void main(String[] args) {
//		judgeMethod();
		try {
			getFileInfo();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public static void judgeMethod(){
		File file = new File("c:\\readme.txt");
		System.out.println("文件存在么？"+file.exists());
		System.out.println("文件可执行么？"+file.canExecute());
		System.out.println("文件可读么？"+file.canRead());
		System.out.println("文件可写么："+file.canWrite());
		System.out.println("路径名是绝对路径名："+file.isAbsolute());
		System.out.println("当前对象是文件夹么："+file.isDirectory());
		System.out.println("当前对象是文件么："+file.isFile());
		System.out.println("文件是隐藏的么："+file.isHidden());
	}
	
	public static void getFileInfo() throws IOException{
		File file = new File("c:\\readme.txt");
		System.out.println("路径名："+file.getPath());
		System.out.println("绝对路径名："+file.getAbsolutePath());
		System.out.println("规范路径名："+file.getCanonicalPath());
		System.out.println("文件名称："+file.getName());
		System.out.println("父目录："+file.getParent());
		
		System.out.println("========================");
		File f1 = new File("..\\src");
		System.out.println(f1.getPath());  //封装什么就打印什么
		System.out.println(f1.getAbsolutePath());
		System.out.println(f1.getCanonicalPath());
		
		File f2 = new File("c:\\");
		System.out.println("全部空间："+f2.getTotalSpace());
		System.out.println("空闲空间："+f2.getFreeSpace());
		System.out.println("可用空间："+f2.getUsableSpace());
		
		File destFile = new File("d:\\read.txt");
		
		boolean to = file.renameTo(destFile);
		System.out.println("移动成功了么？"+to);
	}
}

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
 * 6.设置文件信息的方法：
 * setExecutable(boolean executable) :设置文件可执行的方法
 * setLastModified(long time) :设置此抽象路径名指定的文件或目录的最后一次修改时间。
 * setReadable(boolean readable) :设置文件是否可读
   setReadOnly() :设置文件是否只读
   setWritable(boolean writable) :设置文件是否可写
   7.获取文件的常规信息的方法：
   lastModified() ：获取文件最后一次被修改的时间
   length() : 返回由此抽象路径名表示的文件的长度。
 **/
public class FileDemo03{
	public static void main(String[] args) {
//		setFileInfo();
		getBasicFileInfo();
	}
	public static void setFileInfo(){
		File f = new File("d:/read.txt");
		f.setExecutable(true);
		boolean modified = f.setLastModified(99999999999L);
		System.out.println("设置成功了么："+modified);
		f.setReadable(true);
//		f.setReadOnly();
		f.setWritable(true);
	}
	
	public static void getBasicFileInfo(){
		File file = new File("D:\\read.txt");
		long modified = file.lastModified();
		Date date = new Date(modified);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
		
		System.out.println(sdf.format(date));
		
		long length = file.length();
		System.out.println("此文件的字节数为："+length);
	}
}

import java.io.File;
import java.io.FilenameFilter;

/**8.操作文件夹的相关方法
 * list(): 把文件夹当中包含的目录和文件都存放到字符串数组当中。
 * listFiles():列举文件夹当中包含的目录和文件，存放到File数组当中。
 * listRoots()：列出可用的文件系统根。
 * 
 * 9.文件过滤器：
 **/
public class FileDemo04 {

	public static void main(String[] args) {
//		operateDicMethod();
		filterMethod();
	}
	
	public static void operateDicMethod(){
		File file = new File("C:\\Java\\jdk1.7.0_17");
		String[] list = file.list();
		for (String msg : list) {
			System.out.println(msg);
		}
		System.out.println("===================");
		File[] listFiles = file.listFiles();
		for (File f : listFiles) {
			System.out.println(f.getPath());
		}
		System.out.println("------------------");
		File[] roots = File.listRoots();
		for (File r : roots) {
			System.out.println(r);
		}
	}
	
	public static void filterMethod(){
//		获取文件夹当中的以.png和.java结尾的文件
		File file = new File("D:\\CS-JAVAEE1701\\2017-07-26");
		
		String[] list = file.list(new MyFileNameFileter());
		
		for (String name : list) {
			System.out.println(name);
		}
	}
}

class MyFileNameFileter implements FilenameFilter{
    //dir:表示文件所在的父目录
//	name:表示文件的名称
	@Override
	public boolean accept(File dir, String name) {
		if (name.endsWith(".png")|name.endsWith(".java")) {
			return true;
		}
		
//		如果只要文件夹
//		File child = new File(dir, name);
//		if (child.isDirectory()) {
//			return true;
//		}
		return false;
	}
	
}

import java.io.File;
import java.util.LinkedList;
//文件常见操作：
// 遍历一个文件夹下的所有文件（包括子文件夹当中的文件） 
public class FileDemo05 {
	static int fileCount = 0,folderCount = 0;
	public static void main(String[] args) {
		File f = new File("C:\\Java\\jdk1.7.0_17");
//		showFile(f);
//		System.out.println("此文件夹当中包含了"+fileCount+"个文件和"+folderCount+"个文件夹！！");
		showFolder(f);
	}
	/**
	 * 思路：
	 * 1.判断file对象是文件还是目录，如果是目录可以遍历，如果是文件就不能遍历。
	 * 2.获取文件夹当中所有文件和目录组成的容器。
	 * 3.遍历文件数组的内容
	 * 4.判断文件的信息
	 *     如果file对象代表文件，直接打印文件。
	 *     如果file对象代表目录，打印文件夹信息，重复刚才的过程。
	 * 递归
	 * */
	public static void showFile(File file){
		if (file.isDirectory()) {
			File[] childFiles = file.listFiles();
//			3.遍历文件数组的内容
			for (File childFile : childFiles) {
//				 4.判断文件的信息
				if (childFile.isFile()) {
//					 如果file对象代表文件，直接打印文件。
					System.out.println("文件："+childFile.getAbsolutePath());
					fileCount++;
				}else{
//					 如果file对象代表目录，打印文件夹信息，重复刚才的过程。
					System.out.println("文件夹："+childFile.getAbsolutePath());
					folderCount++;
					showFile(childFile);
				}
			}
		}else{
			System.out.println("文件不能够遍历！！");
		}
	}
	
	/**
	 *第二种写法：不用递归，使用循环
	 *1.判断file对象是否是文件夹。 
	 *2.可以获取文件夹当中的目录和文件，如果是文件就直接打印了，如果是目录，就先把目录存储到容器当中。
	 *因为容器的大小在定义时不能够确定，所以使用集合，因为List集合是有序的，先存放的可以先解决，
	 *所以List集合。因为要从集合当中添加元素并且还要取出元素进行遍历，所以使用LinkedList实现类比较好，
	 *效率比较高。
	 *3.遍历集合当中的目录，取出每一个目录，然后在获取目录当中的内容
	 *4.当集合当中没有内容时，就停止循环。
	 **/
	public static void showFolder(File dirFile){
		int fileCount=0,folderCount=0;
		
		if (dirFile.isDirectory()) {
//			存放文件夹的容器
			LinkedList<File>fileList = new LinkedList<>();
			fileList.add(dirFile);
			
			while (!fileList.isEmpty()) {
//				获取并移除容器当中的第一个文件
				File firstFile = fileList.pollFirst();
				File[] childFiles = firstFile.listFiles();
				for (File child : childFiles) {
					if (child.isFile()) {
						System.out.println("文件："+child.getAbsolutePath());
						fileCount++;
					}else{
						System.out.println("文件夹："+child.getAbsolutePath());
						folderCount++;
						fileList.add(child);
					}
				}
			}
		}else{
			System.out.println("此文件对象不能够遍历！！");
		}
		
		System.out.println("文件夹："+folderCount+"个，文件："+fileCount+"个");
	}
}

import java.io.File;

//  文件常见操作二：
//如果文件夹当中包括多层级的文件和文件夹，定义一个方法，将这个文件夹删除。
public class FileDemo06 {

	public static void main(String[] args) {
		File file = new File("c:\\abc");
		
		deleteFile(file);
	}
	/**
	 * 思路：
	 * 1.获取File对象是文件还是文件夹，如果是文件夹就获取子目录和文件组成的数组，
	 * 如果是文件就直接删除。
	 * 2.遍历文件夹包含的内容组成的数组：
	 * 3.判断file对象信息
	 *    如果是文件，直接调用delete方法删除。
	 *    如果是文件夹，重复刚才的过程
	 **/
	
	public static void deleteFile(File file){
		if (file.isDirectory()) {
			File[] childFiles = file.listFiles();
			if (childFiles.length==0) {  //判断目录中是否有内容，没有内容，直接删除
				file.delete();
			}
//			遍历数组
			for (File child : childFiles) {
//				3.判断file对象信息
				if (child.isFile()) {
					child.delete();
				}else{
					deleteFile(child);
//					已经把文件夹当中包含的内容都删除了，所以最后删除这个文件夹
					child.delete();
				}
			}
//			已经把内部的内容都删除了，最后删除空文件夹。
			file.delete();
		}else{
			file.delete();
		}
	}
}