高级java知识结构图 java高级编程知识点

一、常用的API

1.API中基本数据类型的包装类

public static void main(String[] args) {  //psvm
//        int i =10;

        //System.out.println(i+10); //sout
        //ystem.out.println(i.toString()); //int类型没有继承object
        //基本数据类型是没有面向对象的特征
        //java提供基础数据类型的包装类。
//        Integer i =new Integer(10); //创建包装类的对象,把10包装成Interger的对象交给i
//        Integer ii = 10; //自动打包
//        System.out.println(i+20);  //在使用上int和Integer其实没区别
//        System.out.println(ii+20);
//        int j = ii;  //自动解包
//        System.out.println(j+100);
        String a ="1";
        String b ="1";
        System.out.println(a+b);//11

//        字符串转化成int唯一方案
//        int c = Integer.parseInt(a); //Integer下的pareInt能将里面的东西转成int
//        int d = Integer.parseInt(b);
//        System.out.println(a+b); //2
//
//        String e ="1.25";
//        double f = Double.parseDouble(e); //把字符串转化成一个double
//        System.out.println(f*6);



//        字符串转化成char类型是不现实的，只能取字符串里面的某一个值来转
        String str = "啊哈哈哈哈";
        char c = str.charAt(0); //索引0,拿出的是“啊”
        System.out.println();

    }

总结

• 基本数据类型是没有面向对象的特征，java提供基础数据类型的包装类。
• 在使用上int和Integer其实没区别
• Integer下的pareInt能将里面的东西转成int(同理其他包装类下面的pare也能转化)
• 字符串转化成char类型是不现实的

2.JAVA中的时间

(1)常用的时间

public static void main(String[] args) {

        //Date
        Date d = new Date(); //创造了一个时间的对象，系统时间
        System.out.println(d);

        //现在基本不用了，不利于做时间的加减法
        System.out.println(d.getYear()+1900); //从1900年开始算的年份
        System.out.println(d.getMonth()+1); //月份从0开始的
        System.out.println(d.getDate()); //日期
        System.out.println(d.getHours()); //小时
        System.out.println(d.getMinutes()); //分
        System.out.println(d.getSeconds()); //秒

        //重点
        System.out.println(d.getTime()); // 获取到时间的毫秒，返回的是long
        //结果是：从1970年1月1日0点0分0秒到现在经历的毫秒


        //Calender

        Calendar cal = Calendar.getInstance();
//        System.out.println(cal);
        System.out.println(cal.get(Calendar.YEAR)); //年份
        System.out.println(cal.get(Calendar.MONTH)+1); //月份从0开始
        System.out.println(cal.get(Calendar.DATE));// 日期
        System.out.println(cal.get(Calendar.HOUR_OF_DAY)); //时
        System.out.println(cal.get(Calendar.MINUTE)); //分
        System.out.println(cal.get(Calendar.SECOND)); //秒

        cal.set(Calendar.DATE,cal.get(Calendar.DATE)+30);  //计算时间，在当前时间下，加30天

        System.out.println(cal.getTime()); //拿到的Date对象

        cal.setTime(d); //把Date转化成Calendar，Calendar就指向当前时间
 // Calendar类中的setTime(Date dt)方法用于设置此Calendar的时间值表示的Calendars时间，并以给定或通过的日期为参数。

    }

(2)格式化时间

public static void main(String[] args) throws ParseException {
        Date d =new Date();
        System.out.println(d); //Mon Oct 24 00:51:15 CST 2022

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //设置时间格式

        String s = sdf.format(d); //格式化时间，返回的是字符串
        System.out.println(d);  //2022-10-24 00:51:15

        //让用户输入时间
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个时间(yyyy-MM-dd HH:mm:ss):");
        String s1 =sc.nextLine();
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d1 = sdf1.parse(s1); //把用户输入的字符串转为时间
        System.out.println(d1); //形式为：Mon Oct 24 00:51:15 CST 2022
    }

注意

并不能保证用户输入的一定是这个格式所以在Date d = sdf1.parse(s1); 处会报错，此处的解决方案是在报错处按住ALT+回车，选择第一个Add exception方案

在使用parse()转化时需要选择这个类型：

(3)计算时间差

public static void main(String[] args) throws Exception {
        String s1 = "2018-01-01 12:00:00"; //开始时间
        String s2 = "2018-01-01 13:45:00"; //结束时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //设置时间格式的工具
        //把字符串转化成时间
        Date d1 = sdf.parse(s1);
        Date d2 = sdf.parse(s2);

        //转化成long类型的时间
        long long1 = d1.getTime();
        long long2 = d2.getTime();

        //计算毫秒级别的时间差，求绝对值
        long diff =Math.abs(long1 - long2);

        //秒级别的时间差
        long diffSec = diff/1000;
        //分钟级别的时间差
        long diffMin = diffSec/60;
        System.out.println(diffMin); //105分钟

        //显示成xx小时xx分钟
        long diffHourDisplay = diffMin /60 ; //xx小时
        long diffMinDisplay = diffMin %60 ; //xx分钟

        System.out.println("您一共玩了"+diffHourDisplay+"小时"+diffMinDisplay+"分钟");
    }

总结

• JAVA中的时间有Date 日期 和Calendar 日历
• SimpleDateFormat：帮助我们格式化时间
• format(Date)把时间转化成字符串
• parse(Sting)把字符串转化成时间
• 时间差计算就是将两个时间.getTime()获得毫秒级时间再相减

3.字符串

常用的十三种方法

public static void main(String[] args) {
        String s = "你好呀，我叫xxx";
        //1.charAt()获取字符串
        System.out.println(s.charAt(0)); //你， 获取到第0个位置的字符串

        //2.contact()拼接字符串
        s.concat("哈哈哈"); //在字符串s上进行拼接“哈哈哈”
        System.out.println(s); //你好呀，我叫xxx

        //注意：字符串是不可变的数据类型，
        //几乎所有的字符串操作都需要返回一个新字符串
        String s1 = s.concat("哈哈哈");
        System.out.println(s1); //你好呀，我叫xxx哈哈哈

        //3.contains()判断字符串里面是否包含，返回是true或者false
        String s2 ="苍老师特别喜欢小明";
        System.out.println(s2.contains("波多老师")); //false

        //4.endsWith()判断是否为这个结尾
        System.out.println(s2.endsWith("小明")); //true

        //5.startsWith()判断是否以这个开头
        System.out.println(s2.startsWith("苍老师")); //true

        //6.equalsIgnoreCase() 忽略大小写判断两个是否相同
        String verify_code = "Kmgn";
        Scanner sc =new Scanner(System.in);
        System.out.println("请输入验证码("+verify_code+"):");
        String userInput = sc.nextLine();
        if(verify_code.equalsIgnoreCase(userInput)){ //判断左右两端内容忽略大小写是否相等
            System.out.println("OK");
        }
        else {
            System.out.println("NO");
        }

        //7.indexOf():计算给出的字符串第一次出现的位置
        //  lastIndexOf:最后一次出现的位置
        String s3="你好呀好";
        System.out.println(s3.indexOf("好")); //1

        //8.length():计算出字符串的长度
        System.out.println(s3.length()); //4

        //9.replace():替换
        String s4 = "周润发特别喜欢小明";
        String s5 = s4.replace("周润发","苍老师");
        System.out.println(s5); //苍老师特别喜欢小明

        //10.split():切割，分离
        String s6 = "哈哈_啊啊_呵呵_哦no";
        String[] ss = s6.split("_"); //切割出来是个字符串的数组
        System.out.println(ss[0]); //哈哈
        System.out.println(ss[2]); //呵呵

        //11.substring():截取，前闭后开
        String s7 = "今天天气还不错";
        System.out.println(s7.substring(2,4)); //天气

        //12.trim():去掉左右两边的空格,中间管不了
        String s8 = "    哈   哈     ";
        System.out.println(s8.trim()); //哈   哈

        //13.valueOf():能把基本数据类型转化成字符串
        int i = 10;
        System.out.println(String.valueOf(i)); //输出的字符串10
        //野路子
        System.out.println(i+""); //int与字符串拼接,变成了新字符串
    }

4.DecimalFormat类型

DecimalFormat就是用来转化格式的工具 . 表示小数点儿，0和# 表示数字

public static void main(String[] args) {
        double d = 10/3.0;
        System.out.println(d); //3.3333333333

        //. 表示小数点儿
        //0和# 表示数字

        //保留两位小数
        DecimalFormat df = new DecimalFormat(".00"); //相当于转化格式的工具
        String s = df.format(d); //转化后变成了字符串格式
        System.out.println(s); //3.33
    }

5.API的练习

打印出每个学生的平均分

/打印出每个学生的平均分
        String[] stus = {"小绿_数学_12_语文_33_英语_42","钢管男_数学_25_语文_56_英语_27",
                "泰斯波尔_数学_99_语文_88_英语_120"};  //数据
        for(int i = 0;i<stus.length;i++){  //对数组的循环，注意这里的length没有括号
            String s = stus[i];
            String[] ss = s.split("_");
            String name = ss[0];
            String shuxue = ss[2];
            String yuwen = ss[4];
            String yingyu = ss[6];
            double avg =(Integer.parseInt(shuxue)+Integer.parseInt(yuwen)+
                    Integer.parseInt(yingyu))/3.0;  //为了显示为小数所以除3.0，除3就是整除了
            System.out.println(name+"的平均分是"+avg);
        }

让用户输入一个加法表达式，完成对表达式的计算

//让用户输入一个加法数学表达式,如:3+6+9,编程完成数学表达式的计算
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数学表达式:");
        String s =sc.nextLine();
        //获取到用户输入到的每一个数字
        //先去掉空格
        s = s.replace(" ","");
        int sum=0;
        String[] ss = s.split("\\+");  //加号为特殊符号，需要用\\进行转化
        for (int i=0;i< ss.length;i++){
            int a = Integer.parseInt(ss[i]);
            sum += a;
        }
        System.out.println("最终的结果是:"+sum);

计算手速小游戏

//计算手速
        System.out.println("准备测试，请狂按enter");
        Scanner sc = new Scanner(System.in);
        sc.nextLine(); //让程序等下来

        // 游戏开始
        //准备一个游戏结束的时间
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.SECOND,cal.get(Calendar.SECOND)+10);
        Date end =cal.getTime();  //拿到的是一个Date对象，获得的是加了10秒的结束时间
        long endLong = end.getTime(); //获取到时间的毫秒，返回的是long

        int count=0;
        while (endLong - new Date().getTime() >=0){
            sc.nextLine(); //让程序停下来，等待用户输入enter,输一次才记录一次
            System.out.println("你按了");
            count++;
        }
        //计算一共按了多少次
        System.out.println("您在10秒之内按了"+count+"次");

        double pin = count/10.0; //计算频率
        //把频率进行格式化
        DecimalFormat df = new DecimalFormat(".00"); //只显示两位小数
        System.out.println("您的手数是:"+df.format(pin)+"次/秒");

二、常用的容器

1.List

public static void main(String[] args) {
        List list=new ArrayList(); //一般都用ArrayList()
        //1.add()用来向list里面添加元素
        list.add("福满多");
        list.add("小当家");
        list.add("康师傅");
        list.add("康帅傅");
        System.out.println(list);//[福满多, 小当家, 康师傅, 康师傅]

        //2.remove():删除,找到的第一个
        list.remove("小当家");
        System.out.println(list);//[福满多, 康师傅, 康帅傅]

        //3.size():列表的大小(列表中装了多少个元素)
        System.out.println(list.size());//3

        //4.get()从列表中获取到某个元素
        //任何东西放到列表里面，都会被转成Object类型，所以这里用Object来接
        Object obj = list.get(1);//列表下标是从0开始
        String s = (String) obj; //将obj强制转化成String类型
        System.out.println(s);//康师傅

        //5.contains():判断列表中是否包含xx东西
        System.out.println(list.contains("康帅傅"));//true

        //6.遍历列表
        for(int i=0; i<list.size(); i++){
            String s1 = (String) list.get(i); //向下转型，需要强转
            System.out.println(s1);
        }
    }

2.Set

public static void main(String[] args) {
        Set s = new HashSet();//无序，不重复;一般用HashSet

        //1.add():添加元素
        s.add(123);
        s.add(147);
        s.add(3);
        s.add(3); //重复的数据添加不进去
        System.out.println(s); //[147, 3, 123]

        Set s1 = new TreeSet(); //默认进行升序排序，不重复
        s1.add(123);
        s1.add(147);
        s1.add(3);
        System.out.println(s1); //[3, 123, 147]

        //2.remove:删除元素
        s.remove(147);
        System.out.println(s); //[3, 123]

        //3.contains:判断是否包含
        System.out.println(s.contains("3"));//false,这里是字符串，Set里面的3是数字

    }

3.Map

public static void main(String[] args) {
        Map map = new HashMap();

        //1.put():存储数据
        map.put("jay","周杰伦");
        map.put("wf","汪峰");
        map.put("tz","陶喆");
        map.put("zbc","周笔畅");
        System.out.println(map);//{jay=周杰伦, tz=陶喆, zbc=周笔畅, wf=汪峰}

        Map map1 = new TreeMap(); //会根据key来排序
        map1.put(11,"周杰伦");
        map1.put(33,"蔡徐坤");
        map1.put(66,"六小儿童");
        map1.put(22,"汪峰");
        System.out.println(map1);//{11=周杰伦, 22=汪峰, 33=蔡徐坤, 66=六小儿童}

        //2.remove():根据key删除数据
        map1.remove(33);
        System.out.println(map1);//{11=周杰伦, 22=汪峰, 66=六小儿童}

        //3.size():计算存储了多少个键值对
        System.out.println(map1.size());//3

        //4.containsKey():判断是否包含xxkey
        System.out.println(map1.containsKey(33));//false,前面已经把33删除了
        //containsValue:判断是否包含xx值
        System.out.println(map1.containsValue("周杰伦"));//true

        //5.如果出现了相同的key，原来的value值会被顶掉
        map1.put(22,"只因你太美");
        System.out.println(map1);//{11=周杰伦, 22=只因你太美, 66=六小儿童}

        //6.keySet():将map中所有的key打包成集合返回
        System.out.println(map1.keySet());//[11, 22, 66]

        //7.get(key):通过key查询具体的value
        System.out.println(map1.get(22));//只因你太美
    }

4.迭代器Iterator

迭代器就是用来遍历和迭代拿到容器中的元素的工具
迭代器从元素中取出一个元素，容器里就少一个元素

public class _05Iterator {
    //迭代器就是用来遍历和迭代拿到容器中的元素的工具
    //迭代器从元素中取出一个元素，容器里就少一个元素
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("蔡徐坤");
        list.add("吴亦凡");
        list.add("李易峰");
        list.add("鹿晗");

        //列表的遍历
//        System.out.println(list);
//        for(int i=0; i<list.size(); i++){
//            String s = (String) list.get(i);
//            System.out.println(s);
//        }

        //创建迭代器，创建一个医生
        Iterator it = list.iterator();

        //1.next():拿一个出来
//        String s0 =(String) it.next();  //第一个
//        System.out.println(s0);  //蔡徐坤
//        String s1 =(String) it.next();  //下一个
//        System.out.println(s1);  //吴亦凡
//        String s2 =(String) it.next();  //下一个
//        System.out.println(s2);  //李易峰
//        String s3 =(String) it.next();  //下一个
//        System.out.println(s3);  //鹿晗
//        String s4 =(String) it.next();  //没有元素了，再叫下一个，没人了，报错
//        System.out.println(s4);  //报错

        //2.hasNext():判断有没有元素
        //set集合和list一样的操作
        while (it.hasNext()){  //判断有没有下一个元素
            String s = (String) it.next(); //拿下一个元素
            System.out.println(s);
        }

        // 3.用迭代器从map中获取元素
        //3.1 方案一
        Map map = new HashMap();
        map.put("小峰峰","李易峰");
        map.put("小六六","六小龄童");
        map.put("小凡凡","吴亦凡");
        map.put("小坤坤","蔡徐坤");

        //keySet():将map中所有的key打包成集合返回
        System.out.println(map.keySet()); //[小峰峰, 小坤坤, 小六六, 小凡凡]

        Set set = map.keySet();  //用一个集合拿到所有的key
        Iterator it1 = set.iterator();

        while (it1.hasNext()){
            String key = (String) it1.next();  //拿到的是key
            //通过key获取到value
            System.out.println(map.get(key)); // 李易峰\n蔡徐坤\n六小龄童\n吴亦凡
        }

        //3.2方案二
        Set set1 = map.entrySet(); //set1里面装的是entry,就是既有key也有value
        Iterator it2 = set1.iterator();
        while (it2.hasNext()){
            Map.Entry entry = (Map.Entry) it.next();
            System.out.println(entry.getKey()); //小峰峰\n小坤坤\n小六六\n小凡凡
            System.out.println(entry.getValue());//李易峰\n蔡徐坤\n六小龄童\n吴亦凡
        }
    }

5.泛型

泛型就是给容器贴一个标签，规范容器里的数据类型

public static void main(String[] args) {
        //泛型就是给容器贴一个标签，规范容器里的数据类型

        //1.列表用泛型
        //定义的一个只装字符串的列表
        List<String> strList = new ArrayList<String>();

        strList.add("蔡徐坤");
        //strList.add(123); 不能装除了字符串类型的其他东西，会报错
        strList.add("吴亦凡");
        strList.add("李易峰");
        //因为这是一个专门装字符串的列表，所以赋值给字符串不需要强转了
        String s = strList.get(1);
        System.out.println(s); //吴亦凡

        //2.给自己写的类用泛型
        //自己写的类也可以用泛型，列表里也能加自己造的对象
        List<Singer> list = new ArrayList<Singer>();
        list.add(new Singer(1,"蔡徐坤",1.25,"只因你太美"));
        list.add(new Singer(2,"吴亦凡",1.25,"大碗宽面"));
        list.add(new Singer(3,"鹿晗",1.25,"不知道"));
        list.add(new Singer(4,"李易峰",1.25,"不知道"));

        Iterator<Singer> it = list.iterator();

        while (it.hasNext()){
            Singer s1 = it.next();
            //打印出每个歌手的名字和歌曲
            System.out.println(s1.getName());
            System.out.println(s1.getSong());
        }

        //3.给map用泛型
        Map<String,String> map = new HashMap<String,String>(); //key和value都要指定类型
        map.put("老坛酸菜","我的最爱");
        map.put("红烧牛肉","吃吐了");
        map.put("西红柿打撸","难吃");
        map.put("海鲜","还行");

        String s2 =map.get("老坛酸菜");
        System.out.println(s2); //我的最爱

    }

public class Singer {
    private int id;
    private String name;
    private double salary;
    private String song;

    //构造函数
    public Singer(int id, String name, double salary, String song) {
        this.id = id;
        this.name = name;
        this.salary = salary;
        this.song = song;
    }

    //get和set
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String getSong() {
        return song;
    }

    public void setSong(String song) {
        this.song = song;
    }
}

6.增强for

增强for一般用来循环遍历集合和数组，优点是代码简单，缺点是看不到索引

public static void main(String[] args) {
        //增强for一般用来循环遍历集合和数组，优点是代码简单，缺点是看不到索引
        String[] arr = {"hello","你好","沙瓦蒂卡","欧豪已有"};

        //for的一般用法
        for(int i=0;i< arr.length;i++){
            System.out.println(arr[i]);
        }

        //增强for：for(类型 变量: arr){ 循环体 }
        for(String s :arr){
            System.out.println(s);
        }

        //基本数据类型不属于面向对象范畴，所以不能用List<int>
        List<Integer> list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add(789);
        //未给列表加泛型的，就只能使用Object来装
        for(Integer obj:list){
            System.out.println(obj);
        }

    }

7.collections工具类

Collections:是集合的工具类，主要用来排序和打乱，多用于列表

public static void main(String[] args) {
        //Collections:是集合的工具类，主要用来排序和打乱，多用于列表
        List<Integer> list = new ArrayList<>();
        list.add(123);
        list.add(132);
        list.add(999);
        list.add(777);

        //1.min:计算列表中的最小值
        Integer min = Collections.min(list);
        System.out.println(min);  //123

        //2.max:计算列表中的最大值
        Integer max = Collections.max(list);
        System.out.println(max);  //999

        //3.sort:对列表进行排序
        Collections.sort(list);
        System.out.println(list);  //[123, 132, 777, 999]

        //4.shuffle:随机打乱列表
        Collections.shuffle(list);
        System.out.println(list);  //[123, 777, 132, 999]

        //5.addAll:能一次加多个元素进入列表
        Collections.addAll(list,888,111,222,333);
        System.out.println(list); //[123, 777, 132, 999, 888, 111, 222, 333]

        //6.java支持不定参数的方法
        chi("黄瓜","木瓜","甜瓜");
    }
    public static void chi(String... args){ //不定参数的方法
       //String... args,表示args能接收很多个字符串的参数，接收的东西方在一个数组里面
        for(String s:args){
            System.out.println(s);
        }
    }

8.容器的练习

1.敏感词

public static void main(String[] args) {
        //敏感词
        List li = new ArrayList();
     ;

        //让用户输入评论内容
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入评论内容:");
        String s = sc.nextLine();

        for (int i=0 ;i<li.size();i++){
            String s1 = (String) li.get(i);  //拿到敏感词
            if(s.contains(s1)){
                //拼接*
                String x ="";
                for(int j=0;j<s1.length();j++){
                   x += "*";
                }
                s = s.replace(s1,x);
            }
        }
        System.out.println(s);
    }

2.字符串处理成map

public static void main(String[] args) {

        String str = "k:1,k1:2,k2:3,k3:4";
        String[] strs = str.split(",");
        Map<String,Integer> map = new HashMap<>();
        //对数组循环，拿到每一个切割完成的字符串
        for(String s:strs){
            String[] ss =s.split(":");
            map.put(ss[0],Integer.parseInt(ss[1]));
        }
        System.out.println(map);
    }

3.元素分类

public static void main(String[] args) {

        int[] li = {11,22,33,44,55,66,77,88,99,90};
        Map<String,List<Integer>> map = new HashMap<>();

        for(int n:li){
            if(n >=66){
                //判断是否存在key1,如果不存在,创建一个新的进去
                if(!map.containsKey("k1")){
                    map.put("k1",new ArrayList<Integer>());
                }
                //确定map容器里面里有List
                map.get("k1").add(n);//把数据添加到列表
            } else {
                if(!map.containsKey("k2")){
                    map.put("k2", new ArrayList<>());
                }
                map.get("k2").add(n);
            }
        }
        System.out.println(map);
    }

三、IO流

因为本章与操作系统对接，所以会有大量的异常处理

1.文件操作File类

public static void main(String[] args) {
        try{
            File file = new File("abc/def/students.txt");
            //1.创建一个文件，不包含文件夹
            file.createNewFile();

            //2.getParent():拿到上一层文件夹的对象,
            // getParentFile():拿到上一级文件的名字，是字符串
            System.out.println(file.getParentFile()); //abc\def
            System.out.println(file.getParent()); //abc\def

            //3.mkdir() 创建文件夹，不能创建多级目录(不能嵌套)
            //mkdirs() 创建文件夹一定选这个，可以创建多级目录
            file.mkdirs();

            //4.renameTo():重命名，括号里面需要给一个文件
            //file.renameTo(new File("abc/def/哈哈哈.txt"));

            //5.delete():删除一个文件
            //file.delete(); //根据原来创建file那个路径来的，重命名后的就删不了

            //查看相关的操作
            //6.exists():判断文件是否存在
            System.out.println(file.exists()); //true

            //7.isAbsolute():判断是否是绝对路径
            System.out.println(file.isAbsolute()); //false

            //8.isDirectory():查看文件是否是文件夹
            System.out.println(file.isDirectory()); //false

            //9.isFile():判断文件是否是文件
            System.out.println(file.isFile());  //true

            //10.lenth():查看文件大小，返回的是字节数
            System.out.println(file.length()); //0

            //11.getName():查看文件的名字
            System.out.println(file.getName()); //students.txt

            //12.创建文件的完整路径
            File file1 = new File("abc/def/吃饭.txt");
            //1.先判断上层文件夹是否存在
            File parentFile = file1.getParentFile();
            if(!parentFile.exists()){
                parentFile.mkdirs(); //创建上层文件夹
            }
            //2.创建文件
            file1.createNewFile();

        }catch (Exception e){
            e.printStackTrace();
        }
    }