日历类、日期格式化工具、File类、lambda表达式

于 2021-05-24 22:44:52 发布
阅读量279 收藏
点赞数
分类专栏： api 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48058125/article/details/117234504
版权 
package date;

import java.util.Date;

/**
 * 日期工具类 Date
 * @author lion
 * @date 2021/5/22 17:36
 */
public class Test1_Date {
    public static void main(String[] args) {
        //1.创建对象
        Date date = new Date();//默认是当前系统时间
        System.out.println(date);
        //2.调用方法
        System.out.println(date.getTime());//获取从1970-1-1零点到现在的毫秒值
        System.out.println(date.getDate());//获取今天是几号
        System.out.println(date.getDay());//今天是星期几
        System.out.println(date.getHours());//现在是几点
        System.out.println(date.getMinutes());//现在是哪一分钟
        System.out.println(date.getSeconds());//现在是多少秒
        System.out.println(date.getMonth()+1);//现在是几月 --底层源码是获取到自然月-1
        System.out.println(date.getYear());//从1900年到现在是多少年
        System.out.println(date.toLocaleString());//2021-5-22 17:56:42
    }
}

日历类 Calendar：

该类将所有可能用到的时间信息封装为静态成员变量，方便获取。

Calendar c = Calendar.getInstance();

 1. int get(int field); 返回给定日历字段的值  

Calendar 与 Date 之间的转换：

 Date getTime(); 返回一个表示此Calendar时间值的Date对象        

Calendar -> Date

void setTime(Date date); 用当前Calendar表示给定的Date所表示的时间        

Date -> Calendar

2. void set(int field,int value); 将给定的日历字段设置为给定值

3. void add(int field,int amount):将给定的日历字段量 增加、减少指定的值，由第二个参数的正负决定

 

package date;

import java.util.Calendar;
import java.util.Date;

/**
 * 日历类：java.util.Calendar，在Date后出现，替换掉了许多Date的方法，
 * 该类将所有可能用到的时间信息封装为静态成员变量，方便获取。
 * @author lion
 * @date 2021/5/24 9:29
 */
public class Test2_Calendar {
    public static void main(String[] args) {
        /*
        Calendar类是抽象类，无法直接创建对象使用，里面有一个静态方法
        叫getInstance(),该方法返回了Calendar类的子类对象。
         */
        Calendar c = Calendar.getInstance();//使用默认时区和语言环境获取一个日历
        System.out.println(c);
        //常用方法
        //1.int get(int field):返回给定日历字段的值
        //2.void set(int field,int value):将给定的日历字段设置为给定值
        c.set(Calendar.YEAR,2020);//设置年份
        int year = c.get(Calendar.YEAR);//获取年份
        System.out.println(year);

        c.set(Calendar.MONTH,4);//设置月份
        int month = c.get(Calendar.MONTH);//获取月份
        System.out.println(month+1);

        c.set(Calendar.DAY_OF_MONTH,20);//设置日
        int day = c.get(Calendar.DAY_OF_MONTH);//获取日
        System.out.println(day);

        c.set(2020,4,20);//设置年月日

        /*
        3.void add(int field,int amount):将给定的日历字段量
        增加/减少指定的值，由第二个参数的正负决定。
         */
        c.add(Calendar.YEAR,2);//增加两年
        System.out.println(c.get(Calendar.YEAR));
        c.add(Calendar.MONTH,-1);//减少一个月
        System.out.println(c.get(Calendar.MONTH)+1);

        //Calendar与Date之间的转换
        //Calendar --> Date
        //Date getTime():返回一个表示此Calendar时间值的Date对象
        Date date = c.getTime();
        System.out.println(date);
        //Date --> Calendar
        //void setTime(Date date):用当前Calendar表示给定的Date所表示的时间
        c.setTime(date);
        System.out.println(c);

    }
}

日期格式化工具类 SimpleDateFormat ：

两种类型的日期数据互转：

把 String 类型的日期转成 Date 类型： parse（）

把 Date 类型 转成 String 类型： format（）

将当前日期以字符串的格式输出

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

System.out.println(sdf.format(new Date())); // 2021-05-24

System.currentTimeMillis(); // 当前的毫秒值

package date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/**
 * 日期格式化工具类
 * @author lion
 * @date 2021/5/24 10:40
 */
public class Test3_SimpleDateFormat {
    public static void main(String[] args) throws ParseException {
//        method();
        method2();
    }
    //接收用户输入的出生日期，计算距离现在多少天？
    public static void method2() throws ParseException {
        //接收用户输入的出生日期
        String birthday = new Scanner(System.in).next();
        //1.创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf.parse(birthday);
        long birth = date.getTime();//出生时的毫秒值
        long now = System.currentTimeMillis();//当前的毫秒值
        System.out.println( (now-birth)/1000/60/60/24 );//ms->天
    }
    //两种类型的日期数据互转
    public static void method() throws ParseException {
        String date = "2020-5-20";
        //1.创建SimpleDateFormat对象 --参数是日期格式
        //y表示年，M表示月，d表示日，h表示小时，m表示分钟，s表示秒，-是分隔符
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //2.把String类型的日期转成Date类型
        Date d = sdf.parse(date);
        System.out.println(d);
        //3.把Date类型转成String类型
        String str = sdf.format(d);
        System.out.println(str);
        //将当前日期以字符串的形式输出
        System.out.println( sdf.format(new Date()) );
    }
}

 

File类：

使用File 可以：

1.访问该文件或目录的属性信息（名字，大小，修改时间等）

2.创建或删除文件和目录

3.访问一个目录中的所有子项 File创建时需要指定其表示的文件或目录的路径信息，

路径有两种写法：        

1.相对路径：            

例如 ./text.txt        

2.绝对路径：            

例如  D:\api        

绝对路径的优点：清晰明了，但是位置是固定的，不利于跨平台        

相对路径的优点：适应性好，利于跨平台，但是不清晰，需要视当前程序的运行环境而定        

在 idea 等开发工具中，当前目录的位置是当前程序所在的目录，这里相当于是api这个目录。

 

 

File file = new File("./test.txt");

file.getName(); // 获取文件名

file.length(); // 获取文件的大小

file.canRead(); // 是否可读

file.canWrite(); // 是否可写

file.isHidden(); // 是否是隐藏的

package file;

import java.io.File;

/**
 * java.io.File
 * File的每一个实例用于表示硬盘上的一个文件或目录。
 * 使用File可以：
 * 1.访问该文件或目录的属性信息(名字，大小，修改时间等)
 * 2.创建或删除文件和目录
 * 3.访问一个目录中的所有子项
 * 使用File不能读写文件中的数据，由其他的API可以做到
 * @author lion
 * @date 2021/5/24 11:49
 */
public class Test1_FileDemo {
    public static void main(String[] args) {
        /*
        File创建时需要指定其表示的文件或目录的路径信息，路径有两种写法：
        1.绝对路径:  例如 C:\Users\Think\IdeaProjects\api\test.txt
        2.相对路径:  例如 ./test.txt

        绝对路径的优点：清晰明了，但是位置是固定的，不利于跨平台。
        相对路径的优点：适应性好，利于跨平台，但是不清晰，需要视当前程序的
        运行环境而定。
        在idea等开发工具中，当前目录的位置是当前程序所在的目录，这里相当于
        是api这个目录。
         */
        File file = new File("./test.txt");

        String name = file.getName();//获取文件名
        System.out.println(name);

        long length = file.length();//获取文件大小
        System.out.println(length+"字节");

        boolean b1 = file.canRead();//是否可读
        boolean b2 = file.canWrite();//是否可写
        System.out.println("可读："+b1);
        System.out.println("可写："+b2);

        boolean b3 = file.isHidden();//是否是隐藏的
        System.out.println(b3);

    }
}

使用 File 创建一个新文件：

File file = new File("./demo.txt");  

file.createNewFile(); // 创建新文件

// boolean exists() : 判断File表示的文件或目录是否已经存在

创建一个目录：

 File dir = new File("demo");

dir.mkdir();

创建多级目录：

 File dir = new File("a/b/c/d/e/f/g");

dir.mkdirs();

 

package file;

import java.io.File;
import java.io.IOException;

/**
 * 使用File创建一个新文件
 * @author lion
 * @date 2021/5/24 14:15
 */
public class Test2_CreateNewFile {
    public static void main(String[] args) throws IOException {
        //在当前目录下创建一个文件：demo.txt
        File file = new File("./demo.txt");
        //boolean exists()：判断File表示的文件或目录是否已经存在
        if (file.exists()){
            System.out.println("文件已存在！");
        }else{
            file.createNewFile();//创建新文件
            System.out.println("文件已创建！");
        }

    }
}

package file;

import java.io.File;

/**
 * 创建目录
 * @author lion
 * @date 2021/5/24 14:28
 */
public class Test3_MkDir {
    public static void main(String[] args) {
        //在当前目录下新建一个目录demo
//        File dir = new File("demo");
        //在当前目录下创建多级目录 a/b/c/d/e/f/g
        File dir = new File("a/b/c/d/e/f/g");
        if (dir.exists()){
            System.out.println("目录已存在！");
        }else{
//            dir.mkdir();//创建的目录所在的目录必须存在，否则创建不成功
            dir.mkdirs();//会将不存在的父目录一同创建出来
            System.out.println("目录已创建！");
        }
    }
}

 

使用 File 删除一个文件：  

File file = new File("demo.txt");

file.delete();

删除一个目录： File dir = new File("demo");

dir.delete(); // 删除目录时要求目录是空的

 

package file;

import java.io.File;

/**
 * 使用File删除一个文件
 * @author lion
 * @date 2021/5/24 14:38
 */
public class Test4_DeleteFile {
    public static void main(String[] args) {
        /*
        在相对路径中，"./"是可以忽略不写的，默认就是从当前目录开始。
        因此 "./test.txt" 和 "test.txt" 是一样的。
         */
        //删除当前项目下的test.txt文件
        File file = new File("test.txt");
        if (file.exists()){
            file.delete();
            System.out.println("文件已删除！");
        }else{
            System.out.println("文件不存在！");
        }
    }
}

package file;

import java.io.File;

/**
 * 删除一个目录
 * @author lion
 * @date 2021/5/24 14:46
 */
public class Test5_DeleteDir {
    public static void main(String[] args) {
        //删除当前目录下的demo目录
        File dir = new File("a");
        if (dir.exists()){
            dir.delete();//删除目录时要求目录是空的
            System.out.println("目录已删除！");
        }else{
            System.out.println("目录不存在！");
        }
    }
}

获取一个目录中的所有子项：

File file = new File(".");

boolean isFile():判断是否是一个文件

boolean isDirectory():判断是否为一个目录

File[] listFiles():获取当前File对象所表示的目录中的所有子项

File[] files = file.listFiles();

listFiles 方法有一个重载，允许我们传入一个文件过滤器，

然后将该目录中符合过滤器要求的子项返回 ：

File dir = new File(".");

File[] subs = dir.listFiles(new FileFilter() {

                @Override                

                public boolean accept(File file) {                    

                             String name = file.getName(); //                  

                             int index = name.indexOf("a"); //                  

                             return index!=-1;                    

                            return name.contains("a");

                }

 });

package file;

import java.io.File;

/**
 * 获取一个目录中的所有子项
 * @author lion
 * @date 2021/5/24 15:15
 */
public class Test6_ListFiles {
    public static void main(String[] args) {
        //获取当前目录中的所有子项
        File file = new File(".");
        //boolean isFile():判断是否是一个文件
        //boolean isDirectory():判断是否为一个目录
        if (file.isDirectory()){
            //File[] listFiles:获取当前File对象所表示的目录中的所有子项
            //每一个对象都是一个File对象的形式，最终返回一个数组。
            File[] files = file.listFiles();
            System.out.println("子项个数："+files.length);
            for (int i = 0; i < files.length; i++){
                System.out.println(files[i].getName());
            }
        }else{
            System.out.println("不是一个目录！");
        }
    }


}

package file;

import java.io.File;
import java.io.FileFilter;

/**
 * listFiles方法有一个重载，允许我们传入一个文件过滤器，然后将
 * 该目录中符合过滤器要求的子项返回。
 * @author lion
 * @date 2021/5/24 15:31
 */
public class Test7_ListFiles2 {
    public static void main(String[] args) {
        //获取当前目录中名字包含"a"的子项
        File dir = new File(".");
        if (dir.isDirectory()){
            File[] subs = dir.listFiles(new FileFilter() {
                @Override
                public boolean accept(File file) {
                    String name = file.getName();
//                    int index = name.indexOf("a");
//                    return index != -1;
                    return name.contains("a");
                }
            });
            System.out.println("个数："+subs.length);
        }
    }
}

递归：在方法内部调用方法本身，节省代码量，但是效率不高

JDK8之后推出了一个新的特性：lambda表达式

lambda 表达式可以用更简短的语法创建匿名内部类。

语法： (参数列表)->{ 方法体 }

需要注意的是，使用lambda表达式创建时实现的 接口 中只能有一个 抽象方法 ！

当方法中只有一句代码，那么方法体的"{}"可以忽略不写，

         并且如果该方法要求返回值，则return关键字也要一同忽略

 

package file;

import java.io.File;

/**
 * 递归：在方法内部调用方法本身，节省代码量，但是效率不高
 * @author lion
 * @date 2021/5/24 15:47
 */
public class Test8_Recursion {
    public static void main(String[] args) {
        del(new File("./a"));
        System.out.println("文件夹已删除！");
    }
    //递归删除文件夹
    public static void del(File dir){
        //1.把文件夹中的所有资源都获取到
        File[] files = dir.listFiles();
        //2.遍历数组，获取到每一个资源
        for (int i = 0; i < files.length; i++){
            //3.判断 资源是文件吗？
            if (files[i].isFile()){//如果是，直接删
                files[i].delete();
            }else if (files[i].isDirectory()){
                //4.判断 资源是文件夹吗？
                //如果是，继续遍历资源，判断，是文件就删除，是文件夹继续遍历...
                //递归，重复之前做的1，2，3，4步...
                del(files[i]);
            }
        }
        dir.delete();//删除空文件夹
    }
}

package lambda;

import java.io.File;
import java.io.FileFilter;

/**
 * JDK8之后推出了一个新的特性：lambda表达式
 * lambda表达式可以用更简短的语法创建匿名内部类。
 * 语法：
 * (参数列表)->{
 *     方法体
 * }
 * 需要注意的是，使用lambda表达式创建时实现的接口中只能有一个抽象方法！
 * @author lion
 * @date 2021/5/24 16:29
 */
public class LambdaDemo {
    public static void main(String[] args) {
        //使用匿名内部类方法创建的文件过滤器
        FileFilter filter = new FileFilter() {
            public boolean accept(File file) {
                return file.getName().contains("a");
            }
        };
        //lambda表达式写法
        /*
        编译器会结合程序语义分析出实现的是哪个结构，由于要求接口只能
        有一个抽象方法，所以也能知道重写的方法是什么，最终将它还原为
        匿名内部类。
         */
        FileFilter filter1 = (File file)->{
            return file.getName().contains("a");
        };
        //参数类型可以忽略不写
        FileFilter filter2 = (file)->{
            return file.getName().contains("a");
        };
        /*
        当方法中只有一句代码时，方法体的"{}"可以忽略不写，
        并且如果该方法要求返回值，则return关键字也要一同忽略。
         */
        FileFilter filter3 = (file)->
                file.getName().contains("a");

    }
}

 

梦里°
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值