黑马程序员——IO（1）

最新推荐文章于 2024-05-24 15:38:56 发布

u010154008

最新推荐文章于 2024-05-24 15:38:56 发布

阅读量208

点赞数

分类专栏：学习日记

本文链接：https://blog.csdn.net/u010154008/article/details/48978087

版权

学习日记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

------- android培训、java培训、期待与您交流！ ----------

（一）File类

(1)因为硬盘上对数据的存储基本上都是以文件存在。为了方便对文件或者文件夹进行操作。
java就提供了一个类File供我们使用。本质上是对路径的封装。
(2)File类构造方法：
A:File file = new File("d:\\a.txt");通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。即根据路径创建文件对象
B:File file = new File("d:\\","a.txt");
C:File file = new File("d:");
File file2 = new File(file,"a.txt");根据父文件夹路径以及本文件/文件夹名称创建对象
以上三种格式等价。
(3)File类的功能:
A:创建功能
创建文件：public boolean createNewFile() throws IOException 通过File对象创建文件返回是否创建成功
创建文件夹：public boolean mkdir() 通过File对象创建文件夹返回是否创建成功

public boolean mkdirs() 创建文件夹创建此抽象路径名指定的文件夹，包括所有必需但不存在的父文件夹
注意：仅仅根据后缀名并不能判断是文件还是文件夹。
public class Demo02_File {

	public static void main(String[] args) throws IOException {
		
		//在代码中 创建了一个 代表 a.txt文件的  文件对象
		File file = new File("a.txt");
		
		//通过调用方法，创建文件
		boolean createNewFile = file.createNewFile();
		System.out.println(createNewFile);
		
		//定义父文件夹
		String sDIR = "a";
		//创建父文件夹对象
		File DIR = new File(sDIR);
		System.out.println(DIR.mkdir());
		
		//创建该父文件夹下的文件对象
		File file2 = new File(sDIR,"b.txt");
		//通过对象创建文件
		System.out.println(file2.createNewFile());
	}

}
B:删除功能
删除文件或者文件夹：
public boolean delete()删除文件夹
注意：
A:删除一个带内容的目录，必须先删除内容，在删除目录。
B:java中的删除不走回收站。
public class Demo03_File {

	public static void main(String[] args) throws IOException {
		
		File dir = new File("b/c/d/e");
		System.out.println(dir.mkdir());
		System.out.println(dir.mkdirs());
		
		File file = new File("b/c/d/e/a.txt");
		System.out.println(file.createNewFile());
		
		
		System.out.println(file.delete());
		System.out.println(dir.delete());
		System.out.println("======================");
		
		System.out.println(dir.exists());
		System.out.println(file.exists());
		
		System.out.println("======================");
		System.out.println(dir.isDirectory());
		System.out.println(dir.isFile());
		System.out.println(file.isDirectory());
		System.out.println(file.isFile());
		System.out.println("======================");
		
		
	}

}
C:判断功能
public String getAbsolutePath() 获取绝对路径
public String getPath() 获取路径
public String getParent() 获取该文件或文件夹坐在的文件夹(String)
public File getParentFile() 获取该文件或文件夹坐在的文件夹(File)
public String getName() 获取文件或文件夹的名称
public class Demo04_File {

	public static void main(String[] args) throws IOException {
		
		File file = new File("c/c.txt");
		File file2 = new File("D:\\Lesson\\JAVA\\北京\\150831\\day19\\code\\day19\\d.txt");
		
		file.createNewFile();
		file2.createNewFile();
		
		System.out.println(file.getAbsolutePath());
		System.out.println(file2.getAbsolutePath());
		System.out.println("========================");
		System.out.println(file.getPath());
		System.out.println(file2.getPath());
		System.out.println("========================");
		System.out.println(file.getParent());
		System.out.println(file2.getParent());
		System.out.println("========================");
		System.out.println(file.getParentFile().getClass());
		System.out.println(file2.getParentFile().getClass());
		System.out.println("========================");
		System.out.println(file.getName());
		System.out.println(file2.getName());	
		
	}

}
D:重名名功能
把旧名称改变为新名称：renameTo()
注意：路径问题。
重命名涉及两个File对象。
将File1重命名成File2
在同一目录下：
file2文件已经存在，重命名失败
file2文件不存在，重命名成功
在不同目录下：
file2文件已经存在，重命名失败
file2文件不存在，剪切成功
public class Demo01_File {

	public static void main(String[] args) throws IOException {
		
		File file = new File("b.txt");
		File destFile = new File("a/b/a.txt");
		
		System.out.println(file.renameTo(destFile));
	}

}
E:获取功能
基本获取
获取绝对路径：getAbsolutePath()
获取定义的路径：getPath()
获取名称：getName()
获取大小：length()
获取最后修改时间：lastModified()
高级获取
获取指定目录下所有文件或者文件夹的名称数组：list()
获取指定目录下所有文件或者文件夹的File数组：listFiles()
返回所有盘符：listRoots()
文件过滤器：
接口 FilenameFilter 重写accept()方法 dir:文件所在的目录 name：文件名称
方式1，定义类实现FilenameFilter，list(这个类的实例对象)
方式2，匿名内部类

public class Demo02_File {

	public static void main(String[] args) {

		File[] listRoots = File.listRoots();
		System.out.println(Arrays.toString(listRoots));
		System.out.println("=================================");
		
		File dir = new File("a");
		
		String[] list = dir.list();
		System.out.println(Arrays.toString(list));
		System.out.println("=================================");
		
		File[] listFiles = dir.listFiles();
		System.out.println(Arrays.toString(listFiles));
		
	}

}

</pre><pre name="code" class="java"><pre name="code" class="java">public class Test_01 {  

    public static void main(String[] args) {  

        File file = new File("a");  

        //使用匿名内部类方式创建文件过滤器  

        File[] list = file.listFiles(new FilenameFilter(){  
            @Override  
//重写accept方法，如果该方法返回true，则说明满足条件，返回到数组中，如果返回false，则不满足条件，不返回  

            public boolean accept(File dir, String name) {  

                File thisFile = new File(dir,name);  

                if(thisFile.isFile()&&thisFile.getName().endsWith(".java")){  

                    return true;  

                }  

                return false;  

            }  
        });  

//正则表达式方式         

//      for (File list1 : list) {  

//          if(list1.toString().matches(".+\\.java")&&list1.isFile()){  

//              System.out.println(list1.getName());  

//          }  

//      }  

        System.out.println(Arrays.toString(list));  

    }  

}

（二）递归调用

递归：在函数内调用函数本身。即本身方法体内用到了本身的功能必须在函数内调用该函数本身。递归算法所在函数内，必须有函数出口。递归次数不能过多，否则会导致内存溢出。

public class Demo03 {

	public static void main(String[] args) {
		
		System.out.println(getSum(10));
	}
	//使用递归求1-10的和
	/*
	 * 1-N
	 * 
	 * N + (1-(N-1))的和
	 * 
	 * 10 + 1-9的和
	 * 		9  +  1-8的和
	 * 			  8  +  1-7的和
	 * 					7  +  1-6的和
	 * 						....
	 * 							3 + 1-2的和
	 * 								2  +  1-1的和
	 * 									   1
	 */
	
	//方法需求：给我一个N，我还给你一个从1-N的和
	public static int getSum(int n) {
		System.out.println(n);
		//定义递归出口：如果等于1，就直接返回1，不再调用自己了！
		if(n==1) {
			return 1;
		}
		
		//N + (1-(N-1))的和
		return n +  getSum(n-1);
	}
}

（三）异常

(1)就是程序的非正常情况。

(2)异常的继承体系结构：

Throwable:
|--Error 严重的问题,不需要处理的。
|--Exception 非RuntimeException必须进行处理。两种方案，点击鼠标即可。
|--RuntimeException 运行时期异常,需要修正代码。

(3)jvm的默认处理方式：

默认情况下，jvm会采用默认处理方案：
把异常的全路径名称，原因，及位置等信息显示出来。
注意：
如果是jvm的默认处理方式，那么，它会在出问题的地方结束。

(4)我们自己的处理方案：

A:try...catch...finally
基本格式：

-格式一： try{

需要检测的代码；

}catch(异常类变量){

异常处理代码；

}

-格式二： try{

需要检测的代码；

}catch(异常类变量){

异常处理代码；

}finally{

必须被执行代码

}

-格式三： try{

需要检测的代码；

}finally{

必须被执行代码；

}

l多异常捕获处理：

•分别捕获分别处理，每个try对应一个catch

•分别捕获分别处理，一个try对应所有catch

-注意：大的异常不能在前边，即捕获有子父关系，父异常一定要放在最后，如果是平级关系，它们存在的位置没有顺序关系。

•一次捕获共同处理

-注意：不能同时捕获大的异常与小的异常

执行顺序：
在try里面的代码会按照从上往下执行，一旦发生问题，
就会产生一个异常对象，去和catch里面进行匹配。
有对应的匹配，就走对应的处理方案。
没有，就找父匹配，有就走对应的处理方案。
如果找不到，那么就由jvm采用默认处理方案。

JDK7的新特性：在处理多个平级的异常的时候
catch(ExceptionA | ExceptionB | ExceptionC ... e) {

}

B:声明抛出异常
throws：声明异常抛出，定义在函数声明上
throw：抛出异常是写在方法体内的

（5）l自定义异常

•如果涉及其他需求，JDK没有提供相应的异常对象，则可以自己定义异常。

•定义格式：继承Exception或者RuntimeException。同时需要带参的构造方法，用于接收异常信息。

class MyException{

public MyException(String message){

super(message);

}

}
(6) A:Exception和RuntimeException的区别?
Exception:分为编译期异常和运行期异常。编译期异常是必须处理的。否则，代码不能编译通过。
RuntimeException:运行期异常,不需要编写异常处理代码,但是可能需要修正程序参数或者逻辑代码。
B:throws和throw的区别?
throws:在方法声明上,后面跟的是异常类名。
throws声明后面如果是一个运行时期异常，调用者不需要处理。这种方式没有意义。
throws声明后面跟的是一个编译期异常，调用者是必须处理的。
throw:在方法体中,后面跟的是异常对象名。
throw后面如果抛出的是运行时期异常对象，那么方法上是不需要进行声明的。
throw后面如果抛出的是编译时期异常对象，那么，一般在方法声明上都是要用throws声明该方法有异常。
C:finally的面试题
a:final,finally,finalize的特点及区别?
b:如果catch里面有return，请问finally里面的代码还执行吗?
如果执行，是在return前，还是后呢?
c:写一个程序，测试finally里面的操作对结果没有影响。
finally一般只用于释放资源。

(7)怎么选择呢?
A:能够自己处理的时候，尽量自己处理。
B:在main方法里面尽量不要抛。
C:将来在实际开发中，我们会把不同的异常给出不同的界面进行显示给用户。
(8)子父关系中的异常处理?
class Fu {
public void show() throws Exception{

}
}

class Zi extends Fu {
public void show() throws RuntimeException{

}
}

class Demo {
public static void main(String[] args) {

}
}

总结：子的重写方法中不能抛出比父更大的异常。