JavaSE_day39(接上File：获取，修改，数组形式获取，获取目录下的java文件，删除目录。回顾以及深入完整介绍IO,使用字符、字节复制文本文件)

1 A.java

 *  4  File获取功能
         ①：获取绝对路径
           File getAbsoluteFile()  
 *         String getAbsolutePath() 

 *         ②：获取父目录，文件名（最后的一个的目录或者文件）
 *         String getParent()  
 *         File getParentFile() 
 *         String getName() 

 *         ③：获取参数，最后一次修改文件时间，字节长度
 *         String getPath()  
            long lastModified() 
            long length() 
      
      5 File修改功能：
         boolean renameTo(File dest)

public class A {
	public static void main(String[] args) throws IOException  {
//		method();
//		method2();
//		method3();
		
		method4();
	}

	private static void method4() {
		File f = new File("b/a.txt");  //将b文件夹下的a.txt修改为
		File f2 = new File("bae.txt"); //bae.txt,所以b文件夹下没有了a.txt,同时根目录下新增了bae.txt,文件里面的内容不会变
		
		//boolean renameTo(File dest) : 将当前File对象所指向的路径 修改为 指定File所指向的路径
		//注意：修改的文件路径不能存在，如果存在则修改失败
		System.out.println(f.renameTo(f2));
	}

	private static void method3() {
		File f = new File("a.txt");
		File f2 = new File("F:\\SoftProjects\\eclipse\\HanStudy\\ClassCode\\javaSe\\a\\b.txt");
		File f3 = new File("b");
		
		//String getName() : 获取文件和文件夹的名称
		System.out.println(f.getName());//a.txt
		System.out.println(f2.getName());//b.txt
		System.out.println(f3.getName());//b
		System.out.println("---------");
		
		//String getPath() : 返回创建File对象时给的路径,即参数
		System.out.println(f.getPath());
		System.out.println(f2.getPath());
		System.out.println(f3.getPath());
		System.out.println("---------");
		
		//long lastModified() : 以毫秒值的形式返回最后修改时间
		System.out.println(f.lastModified());
		//2514023311294
		Date d = new Date(1685012167594L);
		System.out.println(d.toLocaleString());
		System.out.println("---------");
		
		//long length() : 返回文件的字节数
		System.out.println(f.length());
		System.out.println(f2.length());
	}

	private static void method2() throws IOException {
	/*	
	    step1：
	 	File f = new File("a.txt");
	 
//		String getName() 
		System.out.println(f.getName());
//		
  		String getParent()  --String对象
		System.out.println(f.getParent());
//			
  		File getParentFile() --File对象
		System.out.println(f.getParentFile());*/
		
		
//		step2:
/*		File f2 = new File("b","d.txt");    //如果目录不存在 ，那么创建失败
		System.out.println(f2.createNewFile());//创建b文件夹下的c.txt
		System.out.println(f2.getName());
		System.out.println(f2.getParent());
		System.out.println(f2.getParentFile());*/
		
//		step3:  一般都是这样用
		File parent = new File("b");   //如果目录不存在，那么会先创建目录
		File f3 = new File(parent,"c.txt");
		if(!parent.exists()) {
			parent.mkdirs();
		}
		System.out.println(f3.createNewFile());
		//String getName()
		System.out.println(f3.getName());
		//String getParent() 
		System.out.println(f3.getParent());
		//File getParentFile() 
		System.out.println(f3.getParentFile());
	}

	private static void method() {
		File f = new File("F:\\SoftProjects\\eclipse\\HanStudy\\ClassCode\\javaSe\\a\\b.txt");
		File f2 = new File("a.txt");
		
		//File getAbsoluteFile()  ：以File对象的形式返回当前File对象所有指向的绝对路径--File
		System.out.println(f.getAbsoluteFile());
		//String getAbsolutePath() : 返回File对象所指向的绝对路径(返回的是一个String类型的字符串，只能调用String类的方法)--Path
		System.out.println(f.getAbsolutePath());
		
		//File getAbsoluteFile()  ：以File对象的形式返回当前File对象所有指向的绝对路径--File
		System.out.println(f2.getAbsoluteFile());
		//String getAbsolutePath() : 返回File对象所指向的绝对路径(返回的是一个String类型的字符串，只能调用String类的方法)--Path
		System.out.println(f2.getAbsolutePath());
	}

}

2. B.java

 * 数组形式的获取File

        String[] list() : 返回当前路径下所有的文件和文件夹名称（String对象数组
        File[] listFiles() ：返回当前路径下所有的文件和文件夹名称（file对象数组
        static File[] listRoots() :返回的是当前计算机的所有盘符

public class B {
	public static void main(String[] args)  {
//		method();
//		method2();
		
		method3();
		}




	private static void method3() {
		//		static File[] listRoots() :  返回的是当前计算机的所有盘符
				File[] files = File.listRoots();
				for (File file : files) {
					System.out.println(file);
	}
	}
		
		
	

	private static void method2() {
		File f = new File("b");
		File f2 = new File("F:\\SoftProjects\\eclipse\\HanStudy\\ClassCode\\javaSe\\a");
		File f3 = new File("a");
		
		//File[] listFiles() :返回的file对象数组
		//注意：只有指向文件夹的File对象才可以调用该方法
		File[] files = f3.listFiles();  
		for (File file : files) {
//			System.out.println(file);//这里的f3创建时参数是相对路径，所以输出也是相对路径，若是f2，则输出绝对路径。一般不这样用，直接使用遍历每个file对象后调用getName方法
			System.out.println(file.getName());
		}
	}

	private static void method() {
		File f = new File("b");
		File f2 = new File("F:\\SoftProjects\\eclipse\\HanStudy\\ClassCode\\javaSe\\a\\b.txt");
		File f3 = new File("a");
		
		//String[] list() : 返回当前路径下所有的文件和文件夹名称
		//注意：只有指向文件夹的File对象才可以调用该方法
		String[] files = f3.list();
		for (int i = 0; i < files.length; i++) {
			System.out.println(files[i]);
		}
	}
}

3. C.java

 * 需求：

输出指定目录下所有的java文件名（包含与不包含子目录下的java文件）,非常实用，结合了递归，判断File到底是目录还是单纯的文件
 * 
 * File[] listFiles() ：返回当前路径下所有的文件和文件夹名称（file对象数组

public class C {
	public static void main(String[] args) {
		File file = new File("src/day39");
//		File file = new File("src");   //试method2
		
		//File f = new File("src\\com\\itjinling_01\\RecurrenceDemo.java");
//		method(file);
		method2(file);
	}
	
	public static void method(File file) {
		if(file.isDirectory()) {  //src/day39是一个目录
			File[] files = file.listFiles();  //获取src/day39目录下的所有文件以及文件夹
			for (File f : files) {  //遍历文件数组
				//判断是否是文件对象
				if(f.isFile()) {     //数组元素是否是文件
					if(f.getName().endsWith(".java")) {  //文件是否是java结尾
						System.out.println(f.getName());  //是就返回java文件
					}
				}
				else if(f.isDirectory()){     
					//是一个目录对象
					method(f);   //递归算法
				}
			}
		}
	}
	
	
	//输出指定目录下的所有java文件名（不包含子目录）--意思就是该目录下只能输出java文件，若是该目录下还有一个目录下是有java文件，那么java文件输出不了
	public static void method2(File file) {
		if(file.isDirectory()) {
			File[] files = file.listFiles();
			for (File f : files) {
				//判断是否是文件对象
				if(f.isFile()) {
					if(f.getName().endsWith(".java")) {
						System.out.println(f.getName());
					}
				}
			}
		}
	}
	

}

4.D.java

 * 需求：删除指定的目录（包含子目录）
 * 
 * 注意：如果要删除一个目录，则需要先删除这个目录下的所有子文件和子目录

public class D {
	public static void main(String[] args) {
		File f = new File("b");
		method(f);
	}
	
	//删除指定目录下所有文件和目录
	public static void method(File file) {
		if(file.isDirectory()) {
			//干掉自己所有的子文件和子目录
			//获取所有的子文件和子目录
			File[] files = file.listFiles();
			for (File f : files) {
				if(f.isFile()) {
					//直接干掉文件
					System.out.println(f.getName()+"文件被删掉！");
					f.delete();
				}
				else if(f.isDirectory()) {
					//继续查看是否还有文件和子目录
					method(f);
				}
			}
			
			//文件夹-干掉自己
			System.out.println(file.getName()+"文件夹被删除");
			file.delete();
		}
	}
}

5.E.java

* 1.回顾IO以及深入：
 * 
 
 IO流分类：
        
     根据流向（之前通过流向简单了解了一下输入输出）
          
          输入流    读取数据    FileReader   （ Reader）
           
           输出流    写出数据    FileWriter   （ Writer）
    
     
     根据数据类型
              
            字节流    （打开文件乱码的，如图片，视频音频等就用字节，因为底层都是二进制）
                   字节输入流   读取数据    InputStream
                   字节输出流   写出数据    OutputStream
            字符流     （打开文件不是乱码，可以看懂，跟字符相关采用）
                   字符输入流  读取数据    Reader（FileReader ）
                   字符输出流  写出数据    Writer（ FileWriter ）

 * 
 * 
 *2. 使用字符流复制文本文件（旧知识）
      
     数据源        IODemo.java
     目的地        d:\\IODemo.java
 

public class E {
	public static void main(String[] args) throws IOException  {
		//创建字符输入流对象
		FileReader fr = new FileReader("src/day39/A.java");
		//创建字符输出流对象
		FileWriter fw = new FileWriter("B.java");
		
		//一次读写一个字符
		
		/*int ch;
		while((ch = fr.read()) != -1) {
			fw.write(ch);
			fw.flush();
		}*/
		
		//一次读写一个字符数组，读完了就结束，没读完就继续循环
		int len;//用于存储读到的字符个数
		char[] chs = new char[2048];  //一次读取多少个长度到字符数组
		while((len = fr.read(chs)) != -1) {  
			fw.write(chs,0,len);
			fw.flush();
		}
		
		//释放资源
		fw.close();
		fr.close();
	}

	
}

6.F.java

 * 1.使用字节流复制文本文件 ,同时他还可以传照片等非字符的文件
 * 
      数据源        IODemo.java
      目的地        d:\\a\\IODemo.java

public class F {
	public static void main(String[] args) throws IOException  {
		//创建字节输入流对象
		FileInputStream fis = new FileInputStream("1.png"); //当然这里用简单的文本文件也行，我就是想试试图片
		//创建字节输出流对象
		FileOutputStream fos = new FileOutputStream("file/11.png");
		
		//一次读写一个字节
		/*int by;
		while((by = fis.read()) != -1) {
			fos.write(by);
		}*/
		//一次读写一个字节数组
		int len;//存储读到的字节个数
		byte[] bys = new byte[2048];
		while((len = fis.read(bys)) != -1) {
			fos.write(bys,0,len);
		}
		
		
		//释放资源
		fos.close();
		fis.close();
	}
}