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

    1. public class A {
    2. 	public static void main(String[] args) throws IOException  {
    3. //		method();
    4. //		method2();
    5. //		method3();
    6. 		
    7. 		method4();
    8. 	}
    9.  
    10. 	private static void method4() {
    11. 		File f = new File("b/a.txt");  //将b文件夹下的a.txt修改为
    12. 		File f2 = new File("bae.txt"); //bae.txt,所以b文件夹下没有了a.txt,同时根目录下新增了bae.txt,文件里面的内容不会变
    13. 		
    14. 		//boolean renameTo(File dest) : 将当前File对象所指向的路径 修改为 指定File所指向的路径
    15. 		//注意：修改的文件路径不能存在，如果存在则修改失败
    16. 		System.out.println(f.renameTo(f2));
    17. 	}
    18.  
    19. 	private static void method3() {
    20. 		File f = new File("a.txt");
    21. 		File f2 = new File("F:\\SoftProjects\\eclipse\\HanStudy\\ClassCode\\javaSe\\a\\b.txt");
    22. 		File f3 = new File("b");
    23. 		
    24. 		//String getName() : 获取文件和文件夹的名称
    25. 		System.out.println(f.getName());//a.txt
    26. 		System.out.println(f2.getName());//b.txt
    27. 		System.out.println(f3.getName());//b
    28. 		System.out.println("---------");
    29. 		
    30. 		//String getPath() : 返回创建File对象时给的路径,即参数
    31. 		System.out.println(f.getPath());
    32. 		System.out.println(f2.getPath());
    33. 		System.out.println(f3.getPath());
    34. 		System.out.println("---------");
    35. 		
    36. 		//long lastModified() : 以毫秒值的形式返回最后修改时间
    37. 		System.out.println(f.lastModified());
    38. 		//2514023311294
    39. 		Date d = new Date(1685012167594L);
    40. 		System.out.println(d.toLocaleString());
    41. 		System.out.println("---------");
    42. 		
    43. 		//long length() : 返回文件的字节数
    44. 		System.out.println(f.length());
    45. 		System.out.println(f2.length());
    46. 	}
    47.  
    48. 	private static void method2() throws IOException {
    49. 	/*	
    50. 	    step1：
    51. 	 	File f = new File("a.txt");
    52. 	 
    53. //		String getName() 
    54. 		System.out.println(f.getName());
    55. //		
    56.   		String getParent()  --String对象
    57. 		System.out.println(f.getParent());
    58. //			
    59.   		File getParentFile() --File对象
    60. 		System.out.println(f.getParentFile());*/
    61. 		
    62. 		
    63. //		step2:
    64. /*		File f2 = new File("b","d.txt");    //如果目录不存在 ，那么创建失败
    65. 		System.out.println(f2.createNewFile());//创建b文件夹下的c.txt
    66. 		System.out.println(f2.getName());
    67. 		System.out.println(f2.getParent());
    68. 		System.out.println(f2.getParentFile());*/
    69. 		
    70. //		step3:  一般都是这样用
    71. 		File parent = new File("b");   //如果目录不存在，那么会先创建目录
    72. 		File f3 = new File(parent,"c.txt");
    73. 		if(!parent.exists()) {
    74. 			parent.mkdirs();
    75. 		}
    76. 		System.out.println(f3.createNewFile());
    77. 		//String getName()
    78. 		System.out.println(f3.getName());
    79. 		//String getParent() 
    80. 		System.out.println(f3.getParent());
    81. 		//File getParentFile() 
    82. 		System.out.println(f3.getParentFile());
    83. 	}
    84.  
    85. 	private static void method() {
    86. 		File f = new File("F:\\SoftProjects\\eclipse\\HanStudy\\ClassCode\\javaSe\\a\\b.txt");
    87. 		File f2 = new File("a.txt");
    88. 		
    89. 		//File getAbsoluteFile()  ：以File对象的形式返回当前File对象所有指向的绝对路径--File
    90. 		System.out.println(f.getAbsoluteFile());
    91. 		//String getAbsolutePath() : 返回File对象所指向的绝对路径(返回的是一个String类型的字符串，只能调用String类的方法)--Path
    92. 		System.out.println(f.getAbsolutePath());
    93. 		
    94. 		//File getAbsoluteFile()  ：以File对象的形式返回当前File对象所有指向的绝对路径--File
    95. 		System.out.println(f2.getAbsoluteFile());
    96. 		//String getAbsolutePath() : 返回File对象所指向的绝对路径(返回的是一个String类型的字符串，只能调用String类的方法)--Path
    97. 		System.out.println(f2.getAbsolutePath());
    98. 	}
    99.  
    100. }

    2. B.java

     * 数组形式的获取File

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

    1.  
    2. public class B {
    3. 	public static void main(String[] args)  {
    4. //		method();
    5. //		method2();
    6. 		
    7. 		method3();
    8. 		}
    9.  
    10.  
    11.  
    12.  
    13. 	private static void method3() {
    14. 		//		static File[] listRoots() :  返回的是当前计算机的所有盘符
    15. 				File[] files = File.listRoots();
    16. 				for (File file : files) {
    17. 					System.out.println(file);
    18. 	}
    19. 	}
    20. 		
    21. 		
    22. 	
    23.  
    24. 	private static void method2() {
    25. 		File f = new File("b");
    26. 		File f2 = new File("F:\\SoftProjects\\eclipse\\HanStudy\\ClassCode\\javaSe\\a");
    27. 		File f3 = new File("a");
    28. 		
    29. 		//File[] listFiles() :返回的file对象数组
    30. 		//注意：只有指向文件夹的File对象才可以调用该方法
    31. 		File[] files = f3.listFiles();  
    32. 		for (File file : files) {
    33. //			System.out.println(file);//这里的f3创建时参数是相对路径，所以输出也是相对路径，若是f2，则输出绝对路径。一般不这样用，直接使用遍历每个file对象后调用getName方法
    34. 			System.out.println(file.getName());
    35. 		}
    36. 	}
    37.  
    38. 	private static void method() {
    39. 		File f = new File("b");
    40. 		File f2 = new File("F:\\SoftProjects\\eclipse\\HanStudy\\ClassCode\\javaSe\\a\\b.txt");
    41. 		File f3 = new File("a");
    42. 		
    43. 		//String[] list() : 返回当前路径下所有的文件和文件夹名称
    44. 		//注意：只有指向文件夹的File对象才可以调用该方法
    45. 		String[] files = f3.list();
    46. 		for (int i = 0; i < files.length; i++) {
    47. 			System.out.println(files[i]);
    48. 		}
    49. 	}
    50. }

    3. C.java

     * 需求：

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

    1. public class C {
    2. 	public static void main(String[] args) {
    3. 		File file = new File("src/day39");
    4. //		File file = new File("src");   //试method2
    5. 		
    6. 		//File f = new File("src\\com\\itjinling_01\\RecurrenceDemo.java");
    7. //		method(file);
    8. 		method2(file);
    9. 	}
    10. 	
    11. 	public static void method(File file) {
    12. 		if(file.isDirectory()) {  //src/day39是一个目录
    13. 			File[] files = file.listFiles();  //获取src/day39目录下的所有文件以及文件夹
    14. 			for (File f : files) {  //遍历文件数组
    15. 				//判断是否是文件对象
    16. 				if(f.isFile()) {     //数组元素是否是文件
    17. 					if(f.getName().endsWith(".java")) {  //文件是否是java结尾
    18. 						System.out.println(f.getName());  //是就返回java文件
    19. 					}
    20. 				}
    21. 				else if(f.isDirectory()){     
    22. 					//是一个目录对象
    23. 					method(f);   //递归算法
    24. 				}
    25. 			}
    26. 		}
    27. 	}
    28. 	
    29. 	
    30. 	//输出指定目录下的所有java文件名（不包含子目录）--意思就是该目录下只能输出java文件，若是该目录下还有一个目录下是有java文件，那么java文件输出不了
    31. 	public static void method2(File file) {
    32. 		if(file.isDirectory()) {
    33. 			File[] files = file.listFiles();
    34. 			for (File f : files) {
    35. 				//判断是否是文件对象
    36. 				if(f.isFile()) {
    37. 					if(f.getName().endsWith(".java")) {
    38. 						System.out.println(f.getName());
    39. 					}
    40. 				}
    41. 			}
    42. 		}
    43. 	}
    44. 	
    45.  
    46. }

    4.D.java

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

    1. public class D {
    2. 	public static void main(String[] args) {
    3. 		File f = new File("b");
    4. 		method(f);
    5. 	}
    6. 	
    7. 	//删除指定目录下所有文件和目录
    8. 	public static void method(File file) {
    9. 		if(file.isDirectory()) {
    10. 			//干掉自己所有的子文件和子目录
    11. 			//获取所有的子文件和子目录
    12. 			File[] files = file.listFiles();
    13. 			for (File f : files) {
    14. 				if(f.isFile()) {
    15. 					//直接干掉文件
    16. 					System.out.println(f.getName()+"文件被删掉！");
    17. 					f.delete();
    18. 				}
    19. 				else if(f.isDirectory()) {
    20. 					//继续查看是否还有文件和子目录
    21. 					method(f);
    22. 				}
    23. 			}
    24. 			
    25. 			//文件夹-干掉自己
    26. 			System.out.println(file.getName()+"文件夹被删除");
    27. 			file.delete();
    28. 		}
    29. 	}
    30. }
    31.

    5.E.java

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

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

    1. public class E {
    2. 	public static void main(String[] args) throws IOException  {
    3. 		//创建字符输入流对象
    4. 		FileReader fr = new FileReader("src/day39/A.java");
    5. 		//创建字符输出流对象
    6. 		FileWriter fw = new FileWriter("B.java");
    7. 		
    8. 		//一次读写一个字符
    9. 		
    10. 		/*int ch;
    11. 		while((ch = fr.read()) != -1) {
    12. 			fw.write(ch);
    13. 			fw.flush();
    14. 		}*/
    15. 		
    16. 		//一次读写一个字符数组，读完了就结束，没读完就继续循环
    17. 		int len;//用于存储读到的字符个数
    18. 		char[] chs = new char[2048];  //一次读取多少个长度到字符数组
    19. 		while((len = fr.read(chs)) != -1) {  
    20. 			fw.write(chs,0,len);
    21. 			fw.flush();
    22. 		}
    23. 		
    24. 		//释放资源
    25. 		fw.close();
    26. 		fr.close();
    27. 	}
    28.  
    29. 	
    30. }

    6.F.java

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

    1. public class F {
    2. 	public static void main(String[] args) throws IOException  {
    3. 		//创建字节输入流对象
    4. 		FileInputStream fis = new FileInputStream("1.png"); //当然这里用简单的文本文件也行，我就是想试试图片
    5. 		//创建字节输出流对象
    6. 		FileOutputStream fos = new FileOutputStream("file/11.png");
    7. 		
    8. 		//一次读写一个字节
    9. 		/*int by;
    10. 		while((by = fis.read()) != -1) {
    11. 			fos.write(by);
    12. 		}*/
    13. 		//一次读写一个字节数组
    14. 		int len;//存储读到的字节个数
    15. 		byte[] bys = new byte[2048];
    16. 		while((len = fis.read(bys)) != -1) {
    17. 			fos.write(bys,0,len);
    18. 		}
    19. 		
    20. 		
    21. 		//释放资源
    22. 		fos.close();
    23. 		fis.close();
    24. 	}
    25. }

  • 相关阅读:
    Android修行手册-Gson中不用实体类生成JsonObject或JsonArray
    简单工厂模式
    基于tornado BELLE 搭建本地的web 服务
    Web大学生网页作业成品：基于html制作中国科技发展网站设计题材【航天之路7页】HTML+CSS+JavaScript
    类与对象(一)----什么是类和对象
    [userfaultfd] 2019-BalsnCTF_KrazyNote
    JAVAEE初阶相关内容第八弹--多线程（初阶）
    springboot基于微信小程序的校园体育运动场地及器材租凭系统设计与实现毕业设计源码131052
    用Python编写自己的微型Redis
    大数据技术之 HBase简介
  • 原文地址：https://blog.csdn.net/weixin_52479647/article/details/130910434