常用API、Lambda

西部猎人
140 阅读5分钟

常用API、Lambda

1. 日期与时间

Date

  • Date构造器

    public Date()

    创建一个Date对象，代表的是系统当前此刻日期时间。

  • 常用方法

    public long getTime()

    获取时间对象的毫秒值

SimpleDateFormat

  • 可以对Date对象或时间毫秒值格式化成我们喜欢的时间形式
  • 也可以把字符串的时间形式解析成日期对象。
    在这里插入图片描述
    在这里插入图片描述
public static void main(String[] args) {
        // 1、日期对象
        Date d = new Date();
        System.out.println(d);

        // 2、格式化这个日期对象 (指定最终格式化的形式)
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
        // 3、开始格式化日期对象成为喜欢的字符串形式
        String rs = sdf.format(d);
        System.out.println(rs);

        System.out.println("----------------------------");

        // 4、格式化时间毫秒值
        // 需求：请问121秒后的时间是多少
        long time1 = System.currentTimeMillis() + 121 * 1000;
        String rs2 = sdf.format(time1);
        System.out.println(rs2);

        System.out.println("------------解析字符串时间，下个代码---------------");
    }

public static void main(String[] args) throws ParseException {
        // 目标: 学会使用SimpleDateFormat解析字符串时间成为日期对象。
        // 有一个时间 2021年08月06日 11:11:11 往后 2天 14小时 49分 06秒后的时间是多少。
        // 1、把字符串时间拿到程序中来
        String dateStr = "2021年08月06日 11:11:11";

        // 2、把字符串时间解析成日期对象（本节的重点）:形式必须与被解析时间的形式完全一样，否则运行时解析报错！
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date d = sdf.parse(dateStr);

        // 3、往后走2天 14小时 49分 06秒
        long time = d.getTime() + (2L*24*60*60 + 14*60*60 + 49*60 + 6) * 1000;

        // 4、格式化这个时间毫秒值就是结果
        System.out.println(sdf.format(time));
    }

JDK8新增日期类

  • LocalDate：日期

  • LocalTime：时间。

  • LocalDateTime：包含了日期及时间。
    构建对象的方式如下在这里插入图片描述
    LocalDate、LocalTime、LocalDateTime获取信息的API.
    在这里插入图片描述
    转换相关的API
    在这里插入图片描述
    修改相关的API
    在这里插入图片描述

  • Instant：时间戳。

  • DateTimeFormatter 用于做时间的格式化和解析的

    • 正反都能调用format方法。

      LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);//2021-03-01T15:09:17.444190900

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String ldtStr = ldt.format(dtf);
System.out.println(ldtStr);//2021-03-01 15:09:17

String ldtStr1 = dtf.format(ldt);
System.out.println(ldtStr1);//2021-03-01 15:09:17

  • Duration:用于计算两个“时间”间隔

    • 用于 LocalDateTime 之间的比较。也可用于 Instant 之间的比较

      LocalDateTime today = LocalDateTime.now();
System.out.println(today);
LocalDateTime birthDate = LocalDateTime.of(1990,10,1,10,50,30);
System.out.println(birthDate);
Duration duration = Duration.between(birthDate, today);//第二个参数减第一个参数
System.out.println(duration.toDays());//两个时间差的天数
System.out.println(duration.toHours());//两个时间差的小时数
System.out.println(duration.toMinutes());//两个时间差的分钟数
System.out.println(duration.toMillis());//两个时间差的毫秒数
System.out.println(duration.toNanos());//两个时间差的纳秒数

  • Period:用于计算两个“日期”间隔

    • 用于 LocalDate 之间的比较。

      LocalDate today = LocalDate.now();
System.out.println(today);     // 2021-03-01
LocalDate birthDate = LocalDate.of(1995, 1, 11);
System.out.println(birthDate); // 1995-01-11
Period period = Period.between(birthDate, today);
System.out.printf("年龄 : %d 年 %d 月 %d 日", period.getYears(), period.getMonths(), 
period.getDays());

包装类

  • 概述：其实就是8种基本数据类型对应的引用类型。
    在这里插入图片描述

  • 为什么要提供包装类

    • Java为了实现一切皆对象
    • 集合和泛型其实也只能支持包装类型，不支持基本数据类型

正则表达式

  • 概述：用一些规定的字符来制定规则，并用来校验数据格式的合法性。

  • 匹配规则：
    字符类（默认匹配一个字符）：

    匹配规则说明
    [abc]只能是a, b, 或c
    [^abc]除了a, b, c之外的任何字符
    [a-zA-Z]a到z A到Z，包括（范围
    [a-d[m-p]]a到d，或m通过p：（[a-dm-p]联合
    [a-z&&[def]]d, e, 或f(交集)
    [a-z&&[^bc]]a到z，除了b和c：（[ad-z]减法）

    预定义的字符类(默认匹配一个字符)

    匹配规则说明
    .任何字符
    \d一个数字： [0-9]
    \D非数字： [^0-9]
    \s一个空白字符： [ \t\n\x0B\f\r]
    \S非空白字符： [^\s]
    \w[a-zA-Z_0-9] 英文、数字、下划线
    \W[^\w] 一个非单词字符

    贪婪的量词（配合匹配多个字符）

    匹配规则说明
    X?X , 一次或根本不
    X*X，零次或多次
    X+X , 一次或多次
    X{n}X，正好n次
    X{n, }X,至少n次
    X{n,m}X,至少n但不超过m次

    public boolean matches​(String regex): 判断是否匹配正则表达式，匹配返回true，不匹配返回

    System.out.println("a".matches("[abc]")); // true
System.out.println("z".matches("[abc]")); // false
System.out.println("ab".matches("[abc]")); // false
System.out.println("ab".matches("[abc]+")); //true

Arrays类

  • 概述：数组操作工具类，专门用于操作数组元素的。

  • Arrays类的常用API

    方法说明
    public static String toString​(类型[] a)对数组进行排序
    public static void sort​(类型[] a)对数组进行默认升序排序
    public static void sort​(类型[] a, Comparator<? super T> c)使用比较器对象自定义排序
    public static int binarySearch​(int[] a, int key)二分搜索数组中的数据，存在返回索引，不存在返回-1

    方法实现代码：

    public static void main(String[] args) {
        // 目标：学会使用Arrays类的常用API ,并理解其原理
        int[] arr = {10, 2, 55, 23, 24, 100};
        System.out.println(arr);

        // 1、返回数组内容的 toString(数组)
//        String rs = Arrays.toString(arr);
//        System.out.println(rs);

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

        // 2、排序的API(默认自动对数组元素进行升序排序)
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        // 3、二分搜索技术（前提数组必须排好序才支持，否则出bug）
        int index = Arrays.binarySearch(arr, 55);
        System.out.println(index);

        // 返回不存在元素的规律： - （应该插入的位置索引 + 1）
        int index2 = Arrays.binarySearch(arr, 22);
        System.out.println(index2);


        // 注意：数组如果么有排好序，可能会找不到存在的元素，从而出现bug!!
        int[] arr2 = {12, 36, 34, 25 , 13,  24,  234, 100};
        System.out.println(Arrays.binarySearch(arr2 , 36));
    }

    自定义比较规则

    Arrays.sort(ages1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 指定比较规则。
//                if(o1 > o2){
//                    return 1;
//                }else if(o1 < o2){
//                    return -1;
//                }
//                return 0;
                // return o1 - o2; // 默认升序
                return o2 - o1; //  降序
            }
        });

Lambda

  • 作用：简化匿名内部类的代码写法。

  • 格式：

    (匿名内部类被重写方法的形参列表) -> {
	   被重写方法的方法体代码。
	   }
注：-> 是语法形式，无实际含义
	-> 首先必须是接口、其次接口中有且仅有一个抽象方法的形式
avatar
文章
阅读
粉丝