Java基础知识 23
IO流的引入
IO：InputStream OutputStream 输入输出流
在Java中IO流用于进行设备之间的一个数据传输，比如：复制文件，上传，下载文件，都是进行数据的传输，就需要使用到IO流来完成操作。我们在上传或下载文件的时候，使用流的途中，可能会遇到一些问题，这些问题就需要我们来解决。
IO流用来进行数据的传输，这些数据在电脑上，它是以文件的形式来体现的。
异常机制
在谈论异常机制之前，我们先画一下异常机制的继承图。
在Java中，对于遇到的问题，有一个类来进行描述：Throwable：问题或者错误的父类。Exception：描述一般性的问题异常。Error：错误，严重性错误。
对于异常也分为两类：一种是编译期异常，发生在编译期间，非RuntimeException及其子类，不解决无法运行，必须解决。另一种是运行期异常，发生在运行期间，RuntimeException及其子类，可以选择解决，也可以选择不解决。
运行期异常
运行期异常，如果选择不处理，Java就默认使用处理方式。
默认处理方式：当遇到异常时，Java虚拟机就会打印出异常的堆栈信息，然后退出Java虚拟机。也就是说，Java默认处理运行期异常的方式不够友好，你可以自己去处理这种运行期异常。
try…catch…
自己处理这个运行期异常信息，遇到异常了，我们可以自己选择提示异常信息，但是不退出系统，让代码继续往下执行。
public class Mytest2 {
public static void main(String[] args) {
int i=10;
int j=0;
try {
//try函数体中放置有可能出现问题的代码
System.out.println(i/j);
}catch (ArithmeticException a){
//(捕获何种类型的异常类名+异常变量名)
//catch函数体中放置一旦出现这种情况，我们给的错误提示
System.out.println("除数不能为0");
}
System.out.println("后面的代码执行了");
}
}
try{
放置可能出现问题的代码;
}catch(捕获何种类型的异常){
放置的是一旦出现这种异常，我们如何处理。
}
如果没有捕获到要出现的这种类型的异常信息，catch里面的代码就不会执行。或者是捕获到的异常和发生的异常不一致，catch里面的代码也不会执行。
public class Mytest3 {
public static void main(String[] args) {
int i=10;
int j=0;
try {
System.out.println(i/j);
}catch (NullPointerException a){
//如果没有捕获到要出现的这种异常类型，catch里面的代码就不会执行
//或者是捕获到的异常类型和发生的异常不一致，catch里面的代码也不会执行
System.out.println("除数不能为0");
}
System.out.println("后面的代码执行了");
}
}
注意事项：
（1）如果不清楚具体属于什么类型的异常，我们可以使用Exception类型来捕捉所有类型的异常，但是需要注意的是：能明确异常的尽量明确，不要用Exception捕捉异常。因为一旦发生异常，你都不知道出现了什么异常。
（2）捕获到的多个异常之间如果有父子继承关系，父类异常放到最后，并列异常的，谁前谁后没有关系。
（3）try里面放的是有可能出现问题的代码，对于没有可能出现问题的代码就不要往里面放了。
public class Mytest4 {
public static void main(String[] args) {
int i=9;
int j=0;
int[] arr={3,4,5};
int[] arr1=null;
//如果说有多种类型的异常需要捕获，我们可以采用多个catch语句来进行异常捕获
try {
System.out.println(arr1[0]);//空指针异常
System.out.println(arr[3]);//角标越界异常
System.out.println(i/j);//算术异常
}catch (ArithmeticException a){
System.out.println("除数为0了");
}catch (IndexOutOfBoundsException b){
System.out.println("没有索引是3的元素");
}catch (NullPointerException c){
System.out.println("arr1[]集合中没有元素");
}catch (Exception d){
//如果不清楚具体发生异常的类型，我们可以选择Exception类型来捕获所有类型的异常
//但是需要注意的是：能明确类型的异常尽量明确，不要用Exception来捕获异常
//因为一旦发生异常，你都不知道发生了什么异常
//捕获的多个异常之间有父子继承关系，父类异常放到最后，并列异常的谁前谁后没有关系
System.out.println("其他不明确的异常");
}
System.out.println("后面的程序执行了");
System.out.println("后面的程序执行了");
System.out.println("后面的程序执行了");
System.out.println("后面的程序执行了");
}
}
关键字finally
finally：最终的，不管try里面的代码有没有遇到异常，那么finally里面的代码都会执行。一般我们会在finally结构体中写一些善后收尾工作的代码，比如进行资源的释放。
import java.util.Scanner;
public class Mytest {
public static void main(String[] args) {
Scanner scanner =null;
try {
scanner = new Scanner(System.in);
System.out.println("请输入第一个整数");
int one = scanner.nextInt();
System.out.println("请输入第一个整数");
int two = scanner.nextInt();
System.out.println(one/two);
}catch (ArithmeticException a){
System.out.println("除数为0了");
}finally {
//释放资源
System.out.println("释放资源");
if (scanner!=null){
scanner.close();
}
}
System.out.println("下面的代码执行了");
}
}
编译期异常
编译期异常：发生在编译期间，非RuntimeException及其子类，编译期间异常必须手动处理，不处理程序无法运行。例如：日期类Date：我们调用parse方法时，会遇到一个编译期异常，必须手动处理：
处理方式：（1）使用throws向上抛出，抛给调用者去处理，谁调用谁处理，俗称甩锅。一般来说，抛到main方法中就不再自己捕获处理了。工具类中异常，就抛给调用者处理吧。
（2）自己使用try…catch…捕获处理
try{
System.out.println(a/b);
}catch(ArithmeticException e){
对于异常的处理，不要做空处理，哪怕只是一句输出错误的提示句都行。
e.printStackTrace();//打印异常的堆栈信息。
}
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Mytest2 {
public static void main(String[] args) {
//编译期异常：发生在编译期间，非RuntimeException及其子类，编译期异常必须手动处理，不处理程序无法运行
String datestr="2020-05-23";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
//调用parse()方法时，会遇到一个编译期异常，编译期异常必须处理，不处理程序无法运行
try {
Date date = simpleDateFormat.parse(datestr);
System.out.println(date);
}catch (ParseException a){
System.out.println("解析失败！");
}
//方式1：使用throws向上抛出，抛给调用者去处理，谁调用谁处理，俗称甩锅
//方式2：使用try catch 捕获处理
System.out.println("下面的代码执行了");
}
}
编译期异常的注意事项：
（1）子类重写父类方法时，子类的方法必须抛出相同的异常或者是父类异常的子类。或者是子类不抛出异常也是可以的。
（2）如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者是它的子集，子类不能抛出父类没有的异常，或者是子类不抛出异常也是可以的。
（3）如果被重写的方法没有异常抛出，那么子类的方法就绝不可以抛出异常，如果子类方法内有异常发生，那么子类只能用try…catch…语句，不能用throws。
Throwable的几个常见方法：
（1）getMessage()------>获取异常信息，返回字符串。
（2）toString()------->获取异常类名和异常信息，返回字符串。
（3）printStackTrace------->获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void。
public class Mytest {
public static void main(String[] args) {
int a=10;
int b=0;
try {
System.out.println(a/b);
}catch (ArithmeticException e){
//System.out.println("除数为0了");
//System.out.println(e.getMessage());//获取异常信息，返回字符串
//System.out.println(e.toString());//获取异常类名和异常信息，并返回字符串
e.printStackTrace();
//获取异常类名和异常信息，以及常出现在程序中的位置，返回void
}
System.out.println("后面的程序！");
System.out.println("后面的程序！");
System.out.println("后面的程序！");
System.out.println("后面的程序！");
}
}
常见的异常类
ArithmeticException：算数异常。
IndexOutOfBoundsException：角标越界异常。
NullPointerException：空指针异常。
public class Mytest4 {
public static void main(String[] args) {
int i=9;
int j=0;
int[] arr={3,4,5};
int[] arr1=null;
//如果说有多种类型的异常需要捕获，我们可以采用多个catch语句来进行异常捕获
try {
System.out.println(arr1[0]);//空指针异常
System.out.println(arr[3]);//角标越界异常
System.out.println(i/j);//算术异常
}catch (ArithmeticException a){
System.out.println("除数为0了");
}catch (IndexOutOfBoundsException b){
System.out.println("没有索引是3的元素");
}catch (NullPointerException c){
System.out.println("arr1[]集合中没有元素");
}catch (Exception d){
System.out.println("其他不明确的异常");
}
System.out.println("后面的程序执行了");
System.out.println("后面的程序执行了");
System.out.println("后面的程序执行了");
System.out.println("后面的程序执行了");
}
}
InputMismatchException类：由Scanner抛出，表明获取的标记与期望类型的模式不匹配，或者该标记超出期望类型的范围。
import java.util.InputMismatchException;
import java.util.Scanner;
public class Mytest2 {
public static void main(String[] args) {
while (true){
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数：");
try {
int num = sc.nextInt();
System.out.println(num);
}catch (InputMismatchException e){
System.out.println("输入类型不匹配，请重新输入");
}
}
}
}
throw和throws的辨析
相同点：都可以进行异常的抛出，throws用在方法声明上，throw用在方法内部抛出异常。
区别：throws：用在方法声明的后面，跟的是异常类名。可以跟多个异常类名，用逗号隔开。表示抛出异常，由该方法的调用者来处理。throws表示出现异常的一种可能性，并不一定会发生这些异常。
throw：用在方法体内，跟的是异常对象名，只能抛出一个异常对象名。这个异常对象可以是运行期异常对象，也可以是编译期异常对象。表示抛出异常，由方法体内的语句处理，throw则是抛出了异常，执行throw则一定抛出了某种异常。
public class Mytest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数：");
int one = sc.nextInt();
System.out.println("请输入第二个数：");
int two = sc.nextInt();
double a=test(one,two);
System.out.println(a);
}
private static double test(int one, int two) {
double i=0;
if (two==0){
throw new ArithmeticException("除数为0了");
}else {
i=one/two;
}
return i;
}
}
final，finally，finalize的辨析
（1）final是一个状态修饰符，可以用来修饰类，变量，成员方法。被修饰的类不能被子类继承，修饰的变量其实是一个常量，不能被再次赋值。修饰的方法不能被重写。
（2）finally：用在try…catch…语句中，作用：释放资源，特点：始终被执行（JVM不能退出）
（3）finallize：Object类中的一个方法，用来回收垃圾。
自定义异常
在开发项目时，会遇到各种各样的异常，那么Java提供的这些异常类，并不能完全的描述我们所遇到的各种异常，对于Java中没有提供的异常，但是业务需求，又要这种异常，我们可以自定义异常。
自定义异常继承RuntimeException类
Exception：非运行时异常，在项目运行之前必须处理，一般由程序员try…catch…处理掉
RuntimeException：运行时异常，在项目运行之后出错，直接终止运行，异常由JVM虚拟机处理。
示例1：判断手机号码是否输入正确？
import java.util.Scanner;
public class Mytest2 {
static String str="[1][3,4,5,7,8,9][0-9]{9}";
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的手机号码：");
String s = sc.nextLine();
chayan(s);
}
private static void chayan(String s) {
if (s.matches(str)){
System.out.println("手机号码输入正确！");
}else {
System.out.println("手机号码输入有误！");
throw new NumberIsWrong("手机号码输入有误");
}
}
}
-------------------------------
public class NumberIsWrong extends RuntimeException {
public NumberIsWrong(String string) {
super(string);
}
}
示例2：判断成绩是否输入错误？
import java.util.Scanner;
public class Mytest3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的成绩：");
int num = sc.nextInt();
CheckNum(num);
}
private static void CheckNum(int num) {
if (num>=0&&num<=100){
System.out.println("成绩输入正确！");
}else {
System.out.println("成绩输入有误！");
throw new ScorsIsWrong("成绩输入有误！");
}
}
}
--------------------------
public class ScorsIsWrong extends RuntimeException {
public ScorsIsWrong(String s) {
super(s);
}
}
File类
IO流的作用，用来进行设备之间的一个数据传输。这些数据在我们电脑上是以文件的形式来体现的，比如文本文件，图片，视频文件。Java为了描述文件或者文件夹这个概念，给我们提供了一个File类来描述文件或文件夹。File文件和目标路径名的抽象表示形式。
构造方法：File（File parent,String child）
根据parent抽象路径名和child路径名字符串创建一个新File实例。
File（String pathname）
通过将给定路径名字符串转换成抽象路径名来创建一个新File实例。
File（String parent,String child）
根据parent路径名字符串和child路径名字符串创建一个新File实例。**
import java.io.File;
public class Mytest2 {
public static void main(String[] args) {
/* File(File parent, String child)
根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。*/
File fuPath = new File("C:\\Users\\YangJian\\Desktop");
File file = new File(fuPath, "yangjian.txt");
System.out.println(file);
System.out.println("-------------------");
/* File(String parent, String child)
根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。*/
//参数1：父路径的Stirng类型 参数2：子文件名
File file1 = new File("C:\\Users\\YangJian\\Desktop", "yangjian.txt");
System.out.println(file1);
System.out.println("-------------------");
File file2 = new File("C:\\Users\\YangJian\\Desktop\\yangjian.txt");
System.out.println(file2);
//以上三种构造方法，是为了我们在编码中，能够灵活的去选用哪种结构
}
}
pathSeparator：与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
pathSeparatorChar：与系统有关的路径分隔符。
Separator：与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
SeparatorChar：与系统有关的默认名称分隔符。
import java.io.File;
public class Mytest {
public static void main(String[] args) {
//通过一个路径字符串，可以封装一个文件或文件夹
File file = new File("C:\\Users\\YangJian\\Desktop\\算法排序.md");
System.out.println(file);
//注意路径分隔符的另一种写法
File file1 = new File("C:/Users/YangJian/Desktop/算法排序.md");
System.out.println(file1);
System.out.println("-------------------");
String pathSeparator = File.pathSeparator;
System.out.println(pathSeparator);
System.out.println("-------------------");
char pathSeparatorChar = File.pathSeparatorChar;
System.out.println(pathSeparatorChar);
System.out.println("-------------------");
String separator = File.separator;
System.out.println(separator);
System.out.println("-------------------");
char separatorChar = File.separatorChar;
System.out.println(separatorChar);
}
}
绝对路径和相对路径：绝对路径：带有盘符的一个详细路径。
相对路径：不带有盘符的路径。
使用绝对路径可以封装文件：
File file = new File("E:\\Java project\\20200523-File类-练习\\aaa.txt");
但是如果这个文件在我们项目的根目录的文件夹下，我们可以使用相对路径来封装：
File file1 = new File("aaa.txt");
import java.io.File;
public class Mytest3 {
public static void main(String[] args) {
File file = new File("E:\\Java project\\20200523-File类-练习\\aaa.txt");
System.out.println(file);
System.out.println("-----------------");
File file2 = new File("E:\\Java project\\20200523-File类-练习\\bbb.txt");
System.out.println(file2);
System.out.println("-----------------");
//如果这个文件在我们项目的文件夹的根目录下，可以使用相对路径来封装
File file1 = new File("aaa.txt");
System.out.println(file1);
System.out.println("-----------------");
File file3 = new File("bbb.txt");
System.out.println(file3);
System.out.println("-----------------");
//./ 当前目录 项目的文件夹的根目录下
File file4 = new File("./");
//public String getAbsolutePath()： 获取绝对路径
System.out.println(file4.getAbsolutePath());
}
}
File类的判断功能
（1）isDirectory()：判断是否为目录。
（2）isFile()：判断是否是文件。
（3）exists()：判断是否存在。
（4）canRead()：判断是否可读。
（5）canWrite()：判断是否可写。
（6）isHidden()：判断是否隐藏。
（7）isAbsolute()：判断是否使用的是绝对路径。
import java.io.File;
public class Mytest {
public static void main(String[] args) {
//判断功能
//判断是不是一个文件
File file = new File("bbb.txt");
boolean b = file.isFile();
System.out.println(b);
System.out.println("-----------------");
//判断这个文件是否存在
boolean b2 = file.exists();
System.out.println(b2);
System.out.println("-----------------");
//判断是否可读
boolean b3 = file.canRead();
System.out.println(b3);
System.out.println("-----------------");
//判断是否可写
boolean b4 = file.canWrite();
System.out.println(b4);
System.out.println("-----------------");
//判断是否隐藏
boolean b5 = file.isHidden();
System.out.println(b5);
System.out.println("-----------------");
//判断是否使用的是绝对路径
boolean b6 = file.isAbsolute();
System.out.println(b6);
}
}
File类的创建功能
（1）CreateNewFile()：创建一个新的文件。
（2）mkdir()：创建一个新的文件夹，只能创建单层目录。
（3）mkdirs()：创建一个新的文件夹，可以创建多层目录。
import java.io.File;
import java.io.IOException;
public class Mytest {
public static void main(String[] args) throws IOException {
//用的相对路径
File file = new File("a.txt");
//创建一个文件。返回值指的是文件是否创建成功，返回true代表创建成功
//文件已经存在，你重复创建就返回false
boolean b = file.createNewFile();
System.out.println(b);
System.out.println("-------------------");
//用绝对路径
File file1 = new File("E:\\Java project\\20200523-File类-练习\\b.txt");
boolean b1 = file1.createNewFile();
System.out.println(b1);
System.out.println("-------------------");
//用的相对路径 ./ 当前路径 指的是项目文件夹的根目录下
File file2 = new File("./c.txt");
boolean b2 = file2.createNewFile();
System.out.println(b2);
System.out.println("-------------------");
//用的相对路径 ../ 表示上一级路径
File file3 = new File("../aaa.txt");
boolean b3 = file3.createNewFile();
System.out.println(b3);
System.out.println("-------------------");
//../../ 当前目录的上两级目录
File file4 = new File("../../bbb.txt");
boolean b4 = file4.createNewFile();
System.out.println(b4);
}
}
-------------------------------
import java.io.File;
public class Mytest {
public static void main(String[] args) {
//在当前项目根目录下创建一个demo文件夹
File file = new File("demo");
//创建文件夹，创建成功返回true ,如果文件夹已经存在，你重复创建，就返回false
boolean b = file.mkdir();
System.out.println(b);
System.out.println("------------------------");
//使用绝对路径，在桌面上创建一个文件夹
File file1 = new File("C:\\Users\\YangJian\\Desktop", "demo");
boolean b1 = file1.mkdir();
System.out.println(b1);
System.out.println("------------------------");
//mkdir() 这个方法的不好之处，就是只能创建单级文件夹
//如果要创建多级文件夹，我们可以使用另外一个方法
File file2 = new File("C:\\Users\\YangJian\\Desktop", "1/2/3");
boolean b2 = file2.mkdirs();
System.out.println(b2);
}
}
File类的获取功能
（1）getAbsolutionPath()：获取绝对路径。
（2）getPath()：获取相对路径。
（3）getParent()：返回此抽象路径名父目录的路径名字符串，如果此路径没有父目录，返回null。
（4）getParentFile()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有父目录，返回null。
import java.io.File;
public class Mytest {
public static void main(String[] args) {
//File文件的获取功能
//获取文件的绝对路径，返回的是字符串类型
File file = new File("eee.txt");
String absolutePath = file.getAbsolutePath();
System.out.println(absolutePath);
System.out.println("---------------------");
//获取文件的相对路径
String path = file.getPath();
System.out.println(path);
System.out.println("---------------------");
//获取文件的绝对路径，返回的是File,这个方法比较灵活
File absoluteFile = file.getAbsoluteFile();
System.out.println(absoluteFile);
System.out.println("---------------------");
//获取文件的父路径，返回的是字符串类型
File file1 = new File("E:\\Java project\\20200524-File类-上午-练习", "eee.txt");
String parent = file1.getParent();
System.out.println(parent);
System.out.println("---------------------");
//获取文件的父路径，返回的是File类型，这个方法比较灵活
File parentFile = file1.getParentFile();
System.out.println(parentFile);
System.out.println("---------------------");
//获取文件的父路径，返回的是字符串类型
File file2 = new File("E:\\Java project\\20200524-File类-上午-练习\\eee.txt");
String parent1 = file2.getParent();
System.out.println(parent1);
//获取文件的父路径，返回的是File类型，这个方法比较灵活
File parentFile1 = file2.getParentFile();
System.out.println(parentFile1);
System.out.println("---------------------");
//在封装文件时，没有指定父路径，返回就是null
File file3 = new File("eee.txt");
String parent2 = file3.getParent();
System.out.println(parent2);
}
}
（5）getTotalSpace()：返回此抽象路径名指定的分区大小，返回总容量，单位为字节。
（6）getFreeSpace()：返回此抽象路径名指定的分区中未分配的字节数，返回剩余容量，单位是字节。
public class Mytest {
public static void main(String[] args) {
//获取磁盘总容量，返回的是字节数
File file = new File("F://");
long totalSpace = file.getTotalSpace();
//1G=1024M 1M=1024K 1K=1024字节
System.out.println((totalSpace / 1024 / 1024 / 1024.0) + "GB");
System.out.println("--------------------");
//获取磁盘的剩余容量
long freeSpace = file.getFreeSpace();
System.out.println((freeSpace / 1024 / 1024 / 1024) + "GB");
}
}
（7）getName()：获取文件的名称。
（8）length()：获取文件的长度，单位为字节数。
public class Mytest2 {
public static void main(String[] args) {
File file = new File("a.txt");
//获取文件名
String name = file.getName();
System.out.println(name);
System.out.println("-------------");
//获取文件的大小
long length = file.length();
System.out.println(length);
}
}
（9）lastModified()：获取最后一次的修改时间，单位为毫秒值。
public class Mytest3 {
public static void main(String[] args) {
//C:\Users\YangJian\Desktop
File file = new File("C:\\Users\\YangJian\\Desktop\\杨健-生活日志.md");
//获取文件的最后一次修改时间，返回的是毫秒值
long time = file.lastModified();
System.out.println(time);
System.out.println("-----------------------");
//把毫秒值转换成字符串，以年月日 时分秒 来展示
Date date = new Date(time);
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String format = simpleDateFormat.format(date);
System.out.println(format);
}
}
（10）list()：获取指定目录下的所有文件或者文件夹的名称数组。
（11）listFiles()：获取指定目录下的所有文件或者文件夹的File数组。
public class Mytest {
public static void main(String[] args) {
//list():获取指定目录下的所有文件或者文件夹的名称数组
File file = new File("F:\\杨健");
String[] list = file.list();
for (String s : list) {
if (s.equals("123.txt")){
System.out.println("程序执行进来了！");
System.out.println(s);
File file1 = new File(file, s);
System.out.println(file1);
file1.delete();
}
}
System.out.println(file);
}
}
------------------------------
public class Mytest2 {
public static void main(String[] args) {
//listFile():获取指定目录下的所有文件或者文件夹的File数组
File file = new File("F:\\杨健");
File[] files = file.listFiles();
for (File f : files) {
System.out.println(f.getName());
if (f.isDirectory()){
f.delete();
}
}
}
}
File文件的删除功能
delete()：删除文件夹，只能删除空的，如果是非空的，则不能删除。
File file = new File("bbb.txt");
当调用delete()方法时，直接删除文件，不管文件是否存在，一经调用立即执行
file.delete();
当调用deleteOnExit()方法时，只是相当于对deleteOnExit()做一个声明
当程序运行结束，JVM终止时才真正调用了deleteOnExit()方法实现删除操作。
即该方法是将删除的命令缓存了一下，到服务停止的时候再进行操作。
file.deleteOnExit();
File文件的重命名功能
renameTo()：源文件和传进来的这个文件对象，都在相同的路径下，它就是重命名。
import java.io.File;
public class Mytest2 {
public static void main(String[] args) {
File file = new File("C:\\Users\\YangJian\\Desktop\\demo");
//delete()删除文件夹的时候，只能删除空文件夹，如果是非空文件夹，则删除失败。
boolean b = file.delete();
System.out.println(b);
}
}
------------------------------
public class Mytest3 {
public static void main(String[] args) {
File file = new File("aaa.txt");
File file1 = new File("bbb.txt");
//重命名：源文件和传进来的这个文件对象，都在相同路径下它就是重命名
boolean b = file.renameTo(file1);
System.out.println(b);
System.out.println("--------------------");
//renameTo(mbFile)方法：源文件和传进来的这个文件，不在同一个路径下，就是剪贴并重命名。
File file2 = new File("eee.txt");
File file3 = new File("C:\\Users\\YangJian\\Desktop\\fff.txt");
boolean b1 = file2.renameTo(file3);
System.out.println(b1);
}
}
1409
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
