快盘下载:好资源、好软件、快快下载吧!

快盘排行|快盘最新

当前位置:首页软件教程电脑软件教程 → 常见API、正则表达式、Lanbda、算法

常见API、正则表达式、Lanbda、算法

时间:2022-09-25 07:06:00人气:作者:快盘下载我要评论

1、常见API - Date

Date 类 代表 当前所在 系统 的 日期时间 信息 。

Date的构造器

Date d = new Date();

名称

说明

public Date()

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

Date的常用方法

long time = d.getTime();

名称

说明

public long getTime()

返回从1970年1月1日    00:00:00走到此刻的总的毫秒数

时间毫秒值 -> 日期对象

Date d2 = new Date(time2);
d3.setTime(time2);

构造器

说明

public Date(long time)

把时间毫秒值转换成Date日期对象。

Date方法

说明

public void setTime(long time)

设置日期对象的时间为当前时间毫秒值对应的时间

import java.time.Instant;
import java.time.ZoneId;
import java.util.Date;

/**
    目标;学会使用Date类处理时间;获取时间的信息
 */
public class DateDemo1 {
    public static void main(String[] args) {
        // 1、创建一个Date类的对象;代表系统此刻日期时间对象
        Date d = new Date();
        System.out.println(d);

        // 2、获取时间毫秒值
        long time = d.getTime();
        System.out.println(time);
//        long time1 = System.currentTimeMillis();
//        System.out.println(time1);

        System.out.println(;----------------------------;);
        // 1、得到当前时间
        Date d1 = new Date();
        System.out.println(d1);

        // 2、当前时间往后走 1小时  121s
        long time2 = System.currentTimeMillis();
        time2 ;= (60 * 60 ; 121) * 1000;

        // 3、把时间毫秒值转换成对应的日期对象。
        // Date d2 = new Date(time2);
        // System.out.println(d2);

        Date d3 = new Date();
        d3.setTime(time2);
        System.out.println(d3);

    }
}

2、常见API - SimpleDateFormat

可以去完成日期时间的格式化操作

常见API、正则表达式、Lanbda、算法

构造器

构造器

说明

public SimpleDateFormat​(String pattern)

构造一个SimpleDateFormat;使用指定的格式

格式化方法

格式化方法

说明

public final String format(Date date)

将日期格式化成日期/时间字符串

public final String format(Object time)

将时间毫秒值式化成日期/时间字符串

 

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

/**
    目标;SimpleDateFormat简单日期格式化类的使用
    格式化时间
    解析时间

 */
public class SimpleDateFormatDemo01 {
    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(;------------解析字符串时间;下个代码---------------;);
    }
}

SimpleDateFormat解析字符串时间成为日期对象

解析字符串时间成为日期对象;

  2011-11-11 11:11:22    ->    Date日期对象

案例

请计算出 2021 年 08 月 06 日 11 点 11 分 11 秒;往后走 2 天 14 小时 49 分 06 秒后的时间是多少。

解析方法

说明

 public Date parse​(String source)

  从给定字符串的开始解析文本以生成日期

import javax.xml.crypto.Data;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatDemo2 {
    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));
    }
}

案例;秒杀活动

需求

某购物网站举办秒杀活动;开始时间和结束时间如左图所示;当前活动结束后;系统记录到 2 位用户的付款时间分别如下; Ø 小贾下单并付款的时间为; 2020 年 11 月 11 日 0:03:47 Ø 小皮下单并付款的时间为; 2020 年 11 月 11 日 0:10:11 规则;顾客的付款时间必须在秒杀时间之内;请判断出两位顾客是否秒杀成功。

分析

把 4 个字符串形式的时间解析成日期对象。 判断小贾和小皮的时间是否在秒杀时间范围之内;并给出相应的提示。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatTest3 {
    public static void main(String[] args) throws ParseException {
        // 1、开始 和 结束时间
        String startTime = ;2021-11-11 00:00:00;;
        String endTime = ;2021-11-11 00:10:00;;

        // 2、小贾 小皮
        String xiaoJia =  ;2021-11-11 00:03:47;;
        String xiaoPi =  ;2021-11-11 00:10:11;;

        // 3、解析他们的时间
        SimpleDateFormat sdf = new SimpleDateFormat(;yyyy-MM-dd HH:mm:ss;);
        Date d1 = sdf.parse(startTime);
        Date d2 = sdf.parse(endTime);
        Date d3 = sdf.parse(xiaoJia);
        Date d4 = sdf.parse(xiaoPi);

        if(d3.after(d1) && d3.before(d2)){
            System.out.println(;小贾秒杀成功;可以发货了;;);
        }else {
            System.out.println(;小贾秒杀失败;;);
        }

        if(d4.after(d1) && d4.before(d2)){
            System.out.println(;小皮秒杀成功;可以发货了;;);
        }else {
            System.out.println(;小皮秒杀失败;;);
        }
    }
}

2、常见API - Calendar

Calendar代表了系统此刻日期对应的日历对象。

Calendar是一个抽象类;不能直接创建对象。

Calendar日历类创建日历对象的方法;

Calendar cal = Calendar.getInstance();

方法名

说明

public static Calendar getInstance()

获取当前日历对象

Calendar常用方法

方法名

说明

public int get(int field)

取日期中的某个字段信息。

public void set(int field,int value)

修改日历的某个字段信息。

public void add(int field,int amount)

为某个字段增加/减少指定的值

public final Date getTime()

拿到此刻日期对象。

public long getTimeInMillis()

拿到此刻时间毫秒值

注意;calendar是可变日期对象;一旦修改后其对象本身表示的时间将产生变化。

import javax.xml.crypto.Data;
import java.util.Calendar;
import java.util.Date;

/**
    目标;日历类Calendar的使用,可以得到更加丰富的信息。

    Calendar代表了系统此刻日期对应的日历对象。
    Calendar是一个抽象类;不能直接创建对象。
    Calendar日历类创建日历对象的语法;
        Calendar rightNow = Calendar.getInstance();
    Calendar的方法;
        1.public static Calendar getInstance(): 返回一个日历类的对象。
        2.public int get(int field);取日期中的某个字段信息。
        3.public void set(int field,int value);修改日历的某个字段信息。
        4.public void add(int field,int amount);为某个字段增加/减少指定的值
        5.public final Date getTime(): 拿到此刻日期对象。
        6.public long getTimeInMillis(): 拿到此刻时间毫秒值
    小结;
        记住。
 */
public class CalendarDemo{
    public static void main(String[] args) {
        // 1、拿到系统此刻日历对象
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);

        // 2、获取日历的信息:public int get(int field);取日期中的某个字段信息。
        int year = cal.get(Calendar.YEAR);
        System.out.println(year);

        int mm = cal.get(Calendar.MONTH) ; 1;
        System.out.println(mm);

        int days = cal.get(Calendar.DAY_OF_YEAR) ;
        System.out.println(days);

        // 3、public void set(int field,int value);修改日历的某个字段信息。
        // cal.set(Calendar.HOUR , 12);
        // System.out.println(cal);

        // 4.public void add(int field,int amount);为某个字段增加/减少指定的值
        // 请问64天后是什么时间
        cal.add(Calendar.DAY_OF_YEAR , 64);
        cal.add(Calendar.MINUTE , 59);

        //  5.public final Date getTime(): 拿到此刻日期对象。
        Date d = cal.getTime();
        System.out.println(d);

        //  6.public long getTimeInMillis(): 拿到此刻时间毫秒值
        long time = cal.getTimeInMillis();
        System.out.println(time);

    }
}

3、JDK8新增 - 日期类 - LocalDate、LocalTime、LocalDateTime

从Java 8开始;java.time包提供了新的日期和时间API;主要涉及的类型有;

LocalDate;不包含具体时间的日期。

LocalTime;不含日期的时间。

LocalDateTime;包含了日期及时间。

Instant;代表的是时间戳。

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

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

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

新增的 API 严格区分了时刻、本地日期、本地时间;并且;对日期和时间进行运算更加方便。 其次;新 API 的类型几乎全部是不变类型;和 String 的使用类似;;可以放心使用不必担心被修改。

 LocalDate、LocalTime、LocalDateTime

他们 分别表示日期;时间;日期时间对象;他们的类的实例是不可变的对象。 他们三者构建对象和 API 都是通用的

构建对象的方式如下;

方法名

说明

      public static Xxxx now();

静态方法;根据当前时间创建对象

LocaDate localDate = LocalDate.now();
LocalTime llocalTime = LocalTime.now();
LocalDateTime localDateTime = LocalDateTime.now();

public static Xxxx of(…);

静态方法;指定日期/时间创建对象

LocalDate localDate1 = LocalDate.of(2099 , 11,11);
LocalTime localTime1 = LocalTime.of(11, 11, 11);
LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43);

import java.time.LocalDate;
import java.time.Month;

public class Demo01LocalDate {
    public static void main(String[] args) {
        // 1、获取本地日期对象。
        LocalDate nowDate = LocalDate.now();
        System.out.println(;今天的日期;; ; nowDate);//今天的日期;

        int year = nowDate.getYear();
        System.out.println(;year;; ; year);


        int month = nowDate.getMonthValue();
        System.out.println(;month;; ; month);

        int day = nowDate.getDayOfMonth();
        System.out.println(;day;; ; day);

        //当年的第几天
        int dayOfYear = nowDate.getDayOfYear();
        System.out.println(;dayOfYear;; ; dayOfYear);

        //星期
        System.out.println(nowDate.getDayOfWeek());
        System.out.println(nowDate.getDayOfWeek().getValue());

        //月份
        System.out.println(nowDate.getMonth());//AUGUST
        System.out.println(nowDate.getMonth().getValue());//8

        System.out.println(;------------------------;);
        LocalDate bt = LocalDate.of(1991, 11, 11);
        System.out.println(bt);//直接传入对应的年月日
        System.out.println(LocalDate.of(1991, Month.NOVEMBER, 11));//相对上面只是把月换成了枚举
    }
}
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;

public class Demo02LocalTime {
    public static void main(String[] args) {
        // 1、获取本地时间对象。
        LocalTime nowTime = LocalTime.now();
        System.out.println(;今天的时间;; ; nowTime);//今天的时间;

        int hour = nowTime.getHour();//时
        System.out.println(;hour;; ; hour);//hour;

        int minute = nowTime.getMinute();//分
        System.out.println(;minute;; ; minute);//minute;

        int second = nowTime.getSecond();//秒
        System.out.println(;second;; ; second);//second;

        int nano = nowTime.getNano();//纳秒
        System.out.println(;nano;; ; nano);//nano;

        System.out.println(;-----;);
        System.out.println(LocalTime.of(8, 20));//时分
        System.out.println(LocalTime.of(8, 20, 30));//时分秒
        System.out.println(LocalTime.of(8, 20, 30, 150));//时分秒纳秒
        LocalTime mTime = LocalTime.of(8, 20, 30, 150);

        System.out.println(;---------------;);
        System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20));
        System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20));
        System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30));
        System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30));
        System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30, 150));
        System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30, 150));
    }
}
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Demo03LocalDateTime {
    public static void main(String[] args) {
        // 日期 时间
        LocalDateTime nowDateTime = LocalDateTime.now();
        System.out.println(;今天是;; ; nowDateTime);//今天是;
        System.out.println(nowDateTime.getYear());//年
        System.out.println(nowDateTime.getMonthValue());//月
        System.out.println(nowDateTime.getDayOfMonth());//日
        System.out.println(nowDateTime.getHour());//时
        System.out.println(nowDateTime.getMinute());//分
        System.out.println(nowDateTime.getSecond());//秒
        System.out.println(nowDateTime.getNano());//纳秒
        //日;当年的第几天
        System.out.println(;dayOfYear;; ; nowDateTime.getDayOfYear());//dayOfYear;249
        //星期
        System.out.println(nowDateTime.getDayOfWeek());//THURSDAY
        System.out.println(nowDateTime.getDayOfWeek().getValue());//4
        //月份
        System.out.println(nowDateTime.getMonth());//SEPTEMBER
        System.out.println(nowDateTime.getMonth().getValue());//9


        LocalDate ld = nowDateTime.toLocalDate();
        System.out.println(ld);

        LocalTime lt = nowDateTime.toLocalTime();
        System.out.println(lt.getHour());
        System.out.println(lt.getMinute());
        System.out.println(lt.getSecond());
    }
}

LocalDate、LocalTime、LocalDateTime获取信息的API

方法名

说明

public int geYear()

获取年

public int getMonthValue()

获取月份;1-12;

Public int getDayOfMonth()

获取月中第几天乘法

Public int getDayOfYear()

获取年中第几天

Public DayOfWeek getDayOfWeek()

获取星期

修改相关的API

LocalDateTime 综合了  LocalDate 和  LocalTime 里面的方法;所以下面只用  LocalDate 和  LocalTime 来举例。 这些方法返回的是一个新的实例引用;因为 LocalDateTime 、 LocalDate 、 LocalTime 都是不可变的。

方法名

说明

plusDays, plusWeeks, plusMonths, plusYears

向当前 LocalDate 对象添加几天、 几周、几个月、几年

minusDays, minusWeeks, minusMonths, minusYears

从当前 LocalDate 对象减去几天、 几周、几个月、几年

withDayOfMonth, withDayOfYear, withMonth, withYear

将月份天数、年份天数、月份、年 份 修 改 为 指 定 的 值 并 返 回 新 的 LocalDate 对象

isBefore, isAfter

比较两个 LocalDate

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.MonthDay;

public class Demo04UpdateTime {
    public static void main(String[] args) {
        LocalTime nowTime = LocalTime.now();
        System.out.println(nowTime);//当前时间
        System.out.println(nowTime.minusHours(1));//一小时前
        System.out.println(nowTime.minusMinutes(1));//一分钟前
        System.out.println(nowTime.minusSeconds(1));//一秒前
        System.out.println(nowTime.minusNanos(1));//一纳秒前

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

        System.out.println(nowTime.plusHours(1));//一小时后
        System.out.println(nowTime.plusMinutes(1));//一分钟后
        System.out.println(nowTime.plusSeconds(1));//一秒后
        System.out.println(nowTime.plusNanos(1));//一纳秒后

        System.out.println(;------------------;);
        // 不可变对象;每次修改产生新对象;
        System.out.println(nowTime);

        System.out.println(;---------------;);
        LocalDate myDate = LocalDate.of(2018, 9, 5);
        LocalDate nowDate = LocalDate.now();

        System.out.println(;今天是2018-09-06吗? ; ; nowDate.equals(myDate));//今天是2018-09-06吗? false
        System.out.println(myDate ; ;是否在; ; nowDate ; ;之前? ; ; myDate.isBefore(nowDate));//2018-09-05是否在2018-09-06之前? true
        System.out.println(myDate ; ;是否在; ; nowDate ; ;之后? ; ; myDate.isAfter(nowDate));//2018-09-05是否在2018-09-06之后? false

        System.out.println(;---------------------------;);
        // 判断今天是否是你的生日
        LocalDate birDate = LocalDate.of(1996, 8, 5);
        LocalDate nowDate1 = LocalDate.now();

        MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
        MonthDay nowMd = MonthDay.from(nowDate1);

        System.out.println(;今天是你的生日吗? ; ; birMd.equals(nowMd));//今天是你的生日吗? false
    }
}

3、JDK8新增 - 日期类 -  Instant

JDK8获取时间戳特别简单;且功能更丰富。Instant类由一个静态的工厂方法now()可以返回当前时间戳。

Instant instant = Instant.now();
System.out.println(;当前时间戳是;; ; instant);

Date date = Date.from(instant);
System.out.println(;当前时间戳是;; ; date);

instant = date.toInstant();
System.out.println(instant);

时间戳是包含日期和时间的;与 java.util.Date 很类似;事实上 Instant 就是 类似 JDK8 以前的 Date 。 Instant 和 Date 这两个类 可以 进行转换。
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.util.Date;

public class Demo05Instant {
    public static void main(String[] args) {
        // 1、得到一个Instant时间戳对象
        Instant instant = Instant.now();
        System.out.println(instant);

        // 2、系统此刻的时间戳怎么办?
        Instant instant1 = Instant.now();
        System.out.println(instant1.atZone(ZoneId.systemDefault()));

        // 3、如何去返回Date对象
        Date date = Date.from(instant);
        System.out.println(date);

        Instant i2 = date.toInstant();
        System.out.println(i2);
    }
}

4、JDK8新增 - 日期类 -  DateTimeFormatter

在JDK8中;引入了一个全新的日期与时间格式器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

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class Demo06DateTimeFormat {
    public static void main(String[] args) {
        // 本地此刻  日期时间 对象
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);

        // 解析/格式化器
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern(;yyyy-MM-dd HH:mm:ss EEE a;);
        // 正向格式化
        System.out.println(dtf.format(ldt));
        // 逆向格式化
        System.out.println(ldt.format(dtf));

        // 解析字符串时间
        DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern(;yyyy-MM-dd HH:mm:ss;);
        // 解析当前字符串时间成为本地日期时间对象
        LocalDateTime ldt1 = LocalDateTime.parse(;2019-11-11 11:11:11; ,  dtf1);
        System.out.println(ldt1);
        System.out.println(ldt1.getDayOfYear());
    }
}

5、JDK8新增 - 日期类 -  Duration/Period

1、 Duration:  用于计算两个“时间”间隔。

2、 Period:      用于计算两个“日期”间隔。

在 Java8 中;我们可以使用以下类来计算 日期间隔 差异; java.time.Period 主要是 Period 类方法 getYears () ; getMonths () 和 getDays () 来计算 , 只能精确到年月日。 用于 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());

import java.time.LocalDate;
import java.time.Period;

public class Demo07Period {
    public static void main(String[] args) {
        // 当前本地 年月日
        LocalDate today = LocalDate.now();
        System.out.println(today);//

        // 生日的 年月日
        LocalDate birthDate = LocalDate.of(1998, 10, 13);
        System.out.println(birthDate);

        Period period = Period.between(birthDate, today);//第二个参数减第一个参数

        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());
    }
}
在 Java8 中;我们可以使用以下类来计算 时间间隔 差异; java.time.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());//两个时间差的纳秒数

import java.time.Duration;
import java.time.LocalDateTime;

public class Demo08Duration {
    public static void main(String[] args) {
        // 本地日期时间对象。
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);

        // 出生的日期时间对象
        LocalDateTime birthDate = LocalDateTime.of(2021,8
                ,06,01,00,00);

        System.out.println(birthDate);

        Duration duration = Duration.between(  today , birthDate);//第二个参数减第一个参数

        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());//两个时间差的纳秒数
    }
}

6、JDK8新增 - 日期类 -  ChronoUnit

ChronoUnit类可用于在单个时间单位内测量一段时间;这个工具类是最全的了;可以用于比较所有的时间单位

LocalDateTime today = LocalDateTime.now();
System.out.println(today);
LocalDateTime birthDate = LocalDateTime.of(1990,10,1,10,50,30);
System.out.println(birthDate);

System.out.println(;相差的年数;; ; ChronoUnit.YEARS.between(birthDate, today));
System.out.println(;相差的月数;; ; ChronoUnit.MONTHS.between(birthDate, today));
System.out.println(;相差的周数;; ; ChronoUnit.WEEKS.between(birthDate, today));
System.out.println(;相差的天数;; ; ChronoUnit.DAYS.between(birthDate, today));
System.out.println(;相差的时数;; ; ChronoUnit.HOURS.between(birthDate, today));
System.out.println(;相差的分数;; ; ChronoUnit.MINUTES.between(birthDate, today));
System.out.println(;相差的秒数;; ; ChronoUnit.SECONDS.between(birthDate, today));
System.out.println(;相差的毫秒数;; ; ChronoUnit.MILLIS.between(birthDate, today));
System.out.println(;相差的微秒数;; ; ChronoUnit.MICROS.between(birthDate, today));
System.out.println(;相差的纳秒数;; ; ChronoUnit.NANOS.between(birthDate, today));

System.out.println(;相差的半天数;; ; ChronoUnit.HALF_DAYS.between(birthDate, today));
System.out.println(;相差的十年数;; ; ChronoUnit.DECADES.between(birthDate, today));
System.out.println(;相差的世纪;百年;数;; ; ChronoUnit.CENTURIES.between(birthDate, today));
System.out.println(;相差的千年数;; ; ChronoUnit.MILLENNIA.between(birthDate, today));
System.out.println(;相差的纪元数;; ; ChronoUnit.ERAS.between(birthDate, today));

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class Demo09ChronoUnit {
    public static void main(String[] args) {
        // 本地日期时间对象;此刻的
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);

        // 生日时间
        LocalDateTime birthDate = LocalDateTime.of(1990,10,1,
                10,50,59);
        System.out.println(birthDate);

        System.out.println(;相差的年数;; ; ChronoUnit.YEARS.between(birthDate, today));
        System.out.println(;相差的月数;; ; ChronoUnit.MONTHS.between(birthDate, today));
        System.out.println(;相差的周数;; ; ChronoUnit.WEEKS.between(birthDate, today));
        System.out.println(;相差的天数;; ; ChronoUnit.DAYS.between(birthDate, today));
        System.out.println(;相差的时数;; ; ChronoUnit.HOURS.between(birthDate, today));
        System.out.println(;相差的分数;; ; ChronoUnit.MINUTES.between(birthDate, today));
        System.out.println(;相差的秒数;; ; ChronoUnit.SECONDS.between(birthDate, today));
        System.out.println(;相差的毫秒数;; ; ChronoUnit.MILLIS.between(birthDate, today));
        System.out.println(;相差的微秒数;; ; ChronoUnit.MICROS.between(birthDate, today));
        System.out.println(;相差的纳秒数;; ; ChronoUnit.NANOS.between(birthDate, today));
        System.out.println(;相差的半天数;; ; ChronoUnit.HALF_DAYS.between(birthDate, today));
        System.out.println(;相差的十年数;; ; ChronoUnit.DECADES.between(birthDate, today));
        System.out.println(;相差的世纪;百年;数;; ; ChronoUnit.CENTURIES.between(birthDate, today));
        System.out.println(;相差的千年数;; ; ChronoUnit.MILLENNIA.between(birthDate, today));
        System.out.println(;相差的纪元数;; ; ChronoUnit.ERAS.between(birthDate, today));
    }
}

7、 包装类

其实就是 8 种基本数据类型对应的引用类型。

基本数据类型

引用数据类型

byte

Byte

short

Short

int

Integer

long

Long

char

Character

float

Float

double

Double

boolean

Boolean

Java 为了实现一切皆对象;为 8 种基本类型提供了对应的引用类型。 后面的集合和泛型其实也只能支持包装类型;不支持基本数据类型。

自动装箱;基本类型的数据和变量可以直接赋值给包装类型的变量。

自动拆箱;包装类型的变量可以直接赋值给基本数据类型的变量。

包装类的特有功能;

可以把字符串类型的数值转换成真实的数据类型; 真的很有用 ; ① Integer.parseInt (“ 字符串类型的整数 ”) ② Double.parseDouble (“ 字符串类型的小数 ”) 。 包装类的变量的默认值可以是 null ;容错率更高。 可以把 基本类型的数据转换成字符串类型 ( 用处不大 ) ① 调用 toString () 方法得到字符串结果。 ② 调用 Integer.toString ( 基本类型的数据 ) 。
/**
    目标;明白包装类的概念;并使用。
 */
public class Test {
    public static void main(String[] args) {
        int a = 10;
        Integer a1 = 11;
        Integer a2 = a; // 自动装箱
        System.out.println(a);
        System.out.println(a1);

        Integer it = 100;
        int it1 = it; // 自动拆箱
        System.out.println(it1);

        double db = 99.5;
        Double db2 = db; // 自动装箱了
        double db3 = db2; // 自动拆箱
        System.out.println(db3);

        // int age = null; // 报错了;
        Integer age1 = null;
        Integer age2 = 0;

        System.out.println(;-----------------;);
        // 1、包装类可以把基本类型的数据转换成字符串形式。;没啥用;
        Integer i3 = 23;
        String rs = i3.toString();
        System.out.println(rs ; 1);

        String rs1 = Integer.toString(i3);
        System.out.println(rs1 ; 1);

        // 可以直接;字符串得到字符串类型
        String rs2 = i3 ; ;;;
        System.out.println(rs2 ; 1);

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

        String number = ;23;;
        //转换成整数
        // int age = Integer.parseInt(number);
        int age = Integer.valueOf(number);
        System.out.println(age ; 1);

        String number1 = ;99.9;;
        //转换成小数
//        double score = Double.parseDouble(number1);
        double score = Double.valueOf(number1);
        System.out.println(score ; 0.1);
    }
}

8、正则表达式

正则表达式可以用一些规定的字符来 制定 规则;并用来校验数据格式的合法性。
需求;假如现在要求校验一个 QQ 号码是否正确; 6 位及 20 位之内;必须全部是数字 。 先使用目前所学知识完成校验需求;然后体验一下正则表达式检验。

 

public class RegexDemo1 {
    public static void main(String[] args) {
        // 需求;校验qq号码;必须全部数字 6 - 20位
        System.out.println(checkQQ(;251425998;));
        System.out.println(checkQQ(;2514259a98;));
        System.out.println(checkQQ(null));
        System.out.println(checkQQ(;2344;));

        System.out.println(;-------------------------;);
        // 正则表达式的初体验;
        System.out.println(checkQQ2(;251425998;));
        System.out.println(checkQQ2(;2514259a98;));
        System.out.println(checkQQ2(null));
        System.out.println(checkQQ2(;2344;));

    }

    public static boolean checkQQ2(String qq){
        return qq != null && qq.matches(;d{6,20};);
    }


    public static boolean checkQQ(String qq){
        // 1、判断qq号码的长度是否满足要求
        if(qq == null || qq.length() < 6 || qq.length() > 20 ) {
            return false;
        }

        // 2、判断qq中是否全部是数字;不是返回false
        //  251425a87
        for (int i = 0; i < qq.length(); i;;) {
            // 获取每位字符
            char ch = qq.charAt(i);
            // 判断这个字符是否不是数字;不是数字直接返回false
            if(ch < ;0; || ch > ;9;) {
                return false;
            }
        }

        return true; // 肯定合法了;
    }
}

匹配规则;

字符串对象提供了匹配正则表达式的方法

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

字符类(默认匹配一个字符)

[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]减法;

[a-z&&[^m-p]]     a到z;除了m到p;;[a-lq-z]减法;

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

.          任何字符

d          一个数字; [0-9]

D          非数字; [^0-9]

s          一个空白字符; [ x0Bf ]

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次

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

/**
    目标;全面、深入学习正则表达式的规则
 */
public class RegexDemo02 {
    public static void main(String[] args) {
        //public boolean matches(String regex):判断是否与正则表达式匹配;匹配返回true
        // 只能是 a  b  c
        System.out.println(;a;.matches(;[abc];)); // true
        System.out.println(;z;.matches(;[abc];)); // false

        // 不能出现a  b  c
        System.out.println(;a;.matches(;[^abc];)); // false
        System.out.println(;z;.matches(;[^abc];)); // true

        System.out.println(;a;.matches(;d;)); // false
        System.out.println(;3;.matches(;d;)); // true
        System.out.println(;333;.matches(;d;)); // false
        System.out.println(;z;.matches(;w;)); // true
        System.out.println(;2;.matches(;w;)); // true
        System.out.println(;21;.matches(;w;)); // false
        System.out.println(;你;.matches(;w;)); //false
        System.out.println(;你;.matches(;W;)); // true
        System.out.println(;---------------------------------;);
        //  以上正则匹配只能校验单个字符。

        // 校验密码
        // 必须是数字 字母 下划线 至少 6位
        System.out.println(;2442fsfsf;.matches(;w{6,};));
        System.out.println(;244f;.matches(;w{6,};));

        // 验证码 必须是数字和字符  必须是4位
        System.out.println(;23dF;.matches(;[a-zA-Z0-9]{4};));
        System.out.println(;23_F;.matches(;[a-zA-Z0-9]{4};));
        System.out.println(;23dF;.matches(;[w&&[^_]]{4};));
        System.out.println(;23_F;.matches(;[w&&[^_]]{4};));

    }
}

案例;

需求

① 请编写程序模拟用户输入手机号码、验证格式正确;并给出提示;直到格式输入正确为止。 ② 请编写程序模拟用户输入邮箱号码、验证格式正确;并给出提示;直到格式输入正确为止。 ③ 请编写程序模拟用户输入电话号码、验证格式正确;并给出提示;直到格式输入正确为止。

分析

定义方法;接收用户输入的数据;使用正则表达式完成检验;并给出提示。
import java.util.Arrays;
import java.util.Scanner;

public class RegexTest3 {
    public static void main(String[] args) {
        // 目标;校验 手机号码 邮箱  电话号码
        // checkPhone();
        // checkEmail();
        // checkTel();

        // 同学可以完成校验金额是否格式金额; 99  0.5  99.5  019   | 0.3.3

        int[] arr = {10, 4, 5,3, 4,6,  2};
        System.out.println(Arrays.binarySearch(arr, 2));

    }

    public static void checkTel(){
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println(;请您输入您的电话号码;;);
            String tel = sc.next();
            // 判断邮箱格式是否正确   027-3572457  0273572457
            if(tel.matches(;0d{2,6}-?d{5,20};)){
                System.out.println(;格式正确;注册完成;;);
                break;
            }else {
                System.out.println(;格式有误;;);
            }
        }
    }

    public static void checkEmail(){
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println(;请您输入您的注册邮箱;;);
            String email = sc.next();
            // 判断邮箱格式是否正确   3268847878;qq.com
            // 判断邮箱格式是否正确   3268847dsda878;163.com
            // 判断邮箱格式是否正确   3268847dsda878;pci.com.cn
            if(email.matches(;w{1,30};[a-zA-Z0-9]{2,20}(.[a-zA-Z0-9]{2,20}){1,2};)){
                System.out.println(;邮箱格式正确;注册完成;;);
                break;
            }else {
                System.out.println(;格式有误;;);
            }
        }
    }

    public static void checkPhone(){
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println(;请您输入您的注册手机号码;;);
            String phone = sc.next();
            // 判断手机号码的格式是否正确
            if(phone.matches(;1[3-9]d{9};)){
                System.out.println(;手机号码格式正确;注册完成;;);
                break;
            }else {
                System.out.println(;格式有误;;);
            }
        }
    }
}

方法应用;

正则表达式在字符串方法中的使用

方法名

说明

 public String replaceAll(String regex,String newStr)

按照正则表达式匹配的内容进行替换

public String[] split(String regex);

按照正则表达式匹配的内容进行分割字符串;反回一个字符串数组。

/**
    目标;正则表达式在方法中的应用。
        public String[] split(String regex);
            -- 按照正则表达式匹配的内容进行分割字符串;反回一个字符串数组。
        public String replaceAll(String regex,String newStr)
            -- 按照正则表达式匹配的内容进行替换
 */
public class RegexDemo04 {
    public static void main(String[] args) {
        String names = ;小路dhdfhdf342蓉儿43fdffdfbjdfaf小何;;

        String[] arrs = names.split(;w;;);
        for (int i = 0; i < arrs.length; i;;) {
            System.out.println(arrs[i]);
        }

        String names2 = names.replaceAll(;w;;, ;  ;);
        System.out.println(names2);
    }
}

爬取内容;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
    拓展;正则表达式爬取信息中的内容。(了解)
 */
public class RegexDemo05 {
    public static void main(String[] args) {
        String rs = ;来黑马程序学习Java,电话020-43422424;或者联系邮箱; ;
                ;itcast;itcast.cn,电话18762832633;0203232323; ;
                ;邮箱bozai;itcast.cn;400-100-3233 ;4001003232;;

        // 需求;从上面的内容中爬取出 电话号码和邮箱。
        // 1、定义爬取规则;字符串形式
        String regex = ;(w{1,30};[a-zA-Z0-9]{2,20}(.[a-zA-Z0-9]{2,20}){1,2})|(1[3-9]d{9}); ;
                ;|(0d{2,6}-?d{5,20})|(400-?d{3,9}-?d{3,9});;

        // 2、把这个爬取规则编译成匹配对象。
        Pattern pattern = Pattern.compile(regex);

        // 3、得到一个内容匹配器对象
        Matcher matcher = pattern.matcher(rs);

        // 4、开始找了
        while (matcher.find()) {
            String rs1 = matcher.group();
            System.out.println(rs1);
        }

    }
}

9、Arrays类

数组操作工具类;专门用于操作数组元素的。

Arrays类的常用API

方法名

说明

public static String toString​(类型[] a)

返回数组的内容;字符串形式;

public static void sort​(类型[] a)

对数组进行默认升序排序

public static <T> void sort​(类型[] a, Comparator<? super T> c)

使用比较器对象自定义排序

public static int binarySearch​(int[] a, int key)

二分搜索数组中的数据;存在返回索引;不存在返回-1

import java.util.Arrays;

public class ArraysDemo1 {
    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类的排序方法

方法名

说明

public static void sort​(类型[] a)

对数组进行默认升序排序

public static <T> void sort​(类型[] a, Comparator<? super T> c)

使用比较器对象自定义排序

自定义排序规则

设置 Comparator 接口对应的比较器对象;来定制比较规则。

如果认为左边数据 大于 右边数据 返回正整数

如果认为左边数据 小于 右边数据  返回负整数

如果认为左边数据  等于 右边数据  返回0

public class Student {
    private String name;
    private int age;
    private double height;

    public Student() {
    }

    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    ;Override
    public String toString() {
        return ;Student{; ;
                ;name=;; ; name ; ;;; ;
                ;, age=; ; age ;
                ;, height=; ; height ;
                ;};;
    }
}
import java.util.Arrays;
import java.util.Comparator;

public class ArraysDemo2 {
    public static void main(String[] args) {
        // 目标;自定义数组的排序规则;Comparator比较器对象。
        // 1、Arrays的sort方法对于有值特性的数组是默认升序排序
        int[] ages = {34, 12, 42, 23};
        Arrays.sort(ages);
        System.out.println(Arrays.toString(ages));

        // 2、需求;降序排序;(自定义比较器对象;只能支持引用类型的排序;;)
        Integer[] ages1 = {34, 12, 42, 23};
        /**
           参数一;被排序的数组 必须是引用类型的元素
           参数二;匿名内部类对象;代表了一个比较器对象。
         */
        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; //  降序
            }
        });
        System.out.println(Arrays.toString(ages1));

        System.out.println(;-------------------------;);
        Student[] students = new Student[3];
        students[0] = new Student(;吴磊;,23 , 175.5);
        students[1] = new Student(;谢鑫;,18 , 185.5);
        students[2] = new Student(;王亮;,20 , 195.5);
        System.out.println(Arrays.toString(students));

        // Arrays.sort(students);  // 直接运行奔溃
        Arrays.sort(students, new Comparator<Student>() {
            ;Override
            public int compare(Student o1, Student o2) {
                // 自己指定比较规则
                // return o1.getAge() - o2.getAge(); // 按照年龄升序排序;
                // return o2.getAge() - o1.getAge(); // 按照年龄降序排序;;
                // return Double.compare(o1.getHeight(), o2.getHeight()); // 比较浮点型可以这样写 升序
                return Double.compare(o2.getHeight(), o1.getHeight()); // 比较浮点型可以这样写  降序
            }
        });
        System.out.println(Arrays.toString(students));


    }
}

10、常见算法 - 选择排序

选择排序的思想

每轮选择当前位置;开始找出后面的较小值与该位置交换

选择排序的关键

确定总共需要 选择几轮 ; 数组的长度-1. 控制每轮从以前位置为基准;与后面元素选择几次。
import java.util.Arrays;

/**
    目标;学会使用选择排序的方法对数组进行排序。
 */
public class Test1 {
    public static void main(String[] args) {
        // 1、定义数组
        int[] arr = {5, 1, 3, 2};
        //           0  1  2  3

        // 2、定义一个循环控制选择几轮; arr.length - 1
        for (int i = 0; i < arr.length - 1; i;;) {
            // i = 0   j =  1  2  3
            // i = 1   j =  2  3
            // i = 2   j =  3
            // 3、定义内部循环;控制选择几次
            for (int j = i ; 1; j < arr.length; j;;) {
                // 当前位;arr[i]
                // 如果有比当前位数据更小的;则交换
                if(arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

11、常见算法 - 二分查找

实现步骤;

定义变量记录左边和右边位置。 使用 while 循环控制查询;条件是左边位置 <= 右边位置; 循环内部获取中间元素索引 判断当前要找的元素如果大于中间元素;左边位置 = 中间索引 ;1 判断当前要找的元素如果小于中间元素;右边位置 = 中间索引 -1 判断当前要找的元素如果等于中间元素;返回当前中间元素索引。
/**
    目标;理解二分搜索的原理并实现。
 */
public class Test2 {
    public static void main(String[] args) {
        // 1、定义数组
        int[] arr = {10, 14, 16, 25, 28, 30, 35, 88, 100};
        //                                            r
        //                                                l
        //
        System.out.println(binarySearch(arr , 35));
        System.out.println(binarySearch(arr , 350));
    }
    /**
     * 二分查找算法的实现
     * ;param arr  排序的数组
     * ;param data 要找的数据
     * ;return  索引;如果元素不存在;直接返回-1
     */
    public static int binarySearch(int[] arr, int data){
        // 1、定义左边位置  和 右边位置
        int left = 0;
        int right = arr.length - 1;

        // 2、开始循环;折半查询。
        while (left <= right){
            // 取中间索引
            int middleIndex = (left ; right) / 2;
            // 3、判断当前中间位置的元素和要找的元素的大小情况
            if(data > arr[middleIndex]) {
                // 往右边找;左位置更新为 = 中间索引;1
                left = middleIndex ; 1;
            }else if(data < arr[middleIndex]) {
                // 往左边找;右边位置 = 中间索引 - 1
                right = middleIndex - 1;
            }else {
                return middleIndex;
            }
        }
        return -1; // 查无此元素
    }

}

12、Lambda表达式

Lambda 表达式是 JDK 8 开始后的一种新语法形式。

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

Lambda表达式的简化格式;

(匿名内部类被重写方法的形参列表) -> {
   被重写方法的方法体代码。
}

注;-> 是语法形式;无实际含义

public class LambdaDemo1 {
    public static void main(String[] args) {
        // 目标;学会使用Lambda的标准格式简化匿名内部类的代码形式
        Animal a = new Animal() {
            ;Override
            public void run() {
                System.out.println(;乌龟跑的很慢~~~~~;);
            }
        };
        a.run();

        // 注意;lambda并不是可以简化所有匿名匿名内部类形式;;
//        Animal a1 = () -> {
//            System.out.println(;乌龟跑的很慢~~~~~;);
//        };
//        a1.run();
    }
}



abstract class Animal{
    public abstract void run();
}

注意;Lambda表达式只能简化函数式接口的匿名内部类的写法形式

函数式接口:

首先必须是接口、其次接口中有且仅有一个抽象方法的形式
public class LambdaDemo2 {
    public static void main(String[] args) {
        // 目标;学会使用Lambda的标准格式简化匿名内部类的代码形式
        // 注意;Lambda只能简化接口中只有一个抽象方法的匿名内部类形式;函数式接口;
//        Swimming s1 = new Swimming() {
//            ;Override
//            public void swim() {
//                System.out.println(;老师游泳贼溜~~~~~;);
//            }
//        };

//        Swimming s1 = () -> {
//            System.out.println(;老师游泳贼溜~~~~~;);
//        };

        Swimming s1 = () -> System.out.println(;老师游泳贼溜~~~~~;);
        go(s1);

        System.out.println(;---------------------;);
//        go(new Swimming() {
//            ;Override
//            public void swim() {
//                System.out.println(;学生游泳很开心~~~;);
//            }
//        });

//        go(() ->{
//                System.out.println(;学生游泳很开心~~~;);
//        });

        go(() -> System.out.println(;学生游泳很开心~~~;));


    }

    public static void go(Swimming s){
        System.out.println(;开始。。。;);
        s.swim();
        System.out.println(;结束。。。;);
    }
}

;FunctionalInterface // 一旦加上这个注解必须是函数式接口;里面只能有一个抽象方法
interface Swimming{
    void swim();
}

Lambda表达式简化Comparator接口的匿名形式:

 

public static void main(String[] args) {
    Integer[] ages = {66, 33, 22, 55, 88};

    Arrays.sort(ages, new Comparator<Integer>(){
        ;Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    });

    System.out.println(;内容:; ; Arrays.toString(ages));
}

注意;通常我们见到的函数式接口上都有一个;FunctionalInterface注解;标记该接口必须是满足函数式接口。

Arrays.sort(ages, (Integer o1, Integer o2) -> {
        return o2 - o1;
});

Lambda表达式简化按钮监听器ActionListener的匿名内部类形式:

  JButton btn = new JButton(;登录;);


  // 给登录按钮绑定点击事件监听器
  btn.addActionListener(new ActionListener() {
        ;Override
        public void actionPerformed(ActionEvent e) {
            System.out.println(;登录一下~~~;);
        }
   });

btn.addActionListener( (ActionEvent e) -> {
        System.out.println(;登录一下~~~;);
});

Lambda表达式的省略写法;进一步在Lambda表达式的基础上继续简化;

①参数类型可以省略不写。 ②如果只有一个参数;参数类型可以省略;同时()也可以省略。 ③如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号;

       ④如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时;如果这行代码是return语句;必须省略return不写;同时也必须省略;;;不写

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Comparator;

public class LambdaDemo3 {
    public static void main(String[] args) {
        Integer[] ages1 = {34, 12, 42, 23};
        /**
         参数一;被排序的数组 必须是引用类型的元素
         参数二;匿名内部类对象;代表了一个比较器对象。
         */
//        Arrays.sort(ages1, new Comparator<Integer>() {
//            ;Override
//            public int compare(Integer o1, Integer o2) {
//                return o2 - o1; //  降序
//            }
//        });

//        Arrays.sort(ages1, (Integer o1, Integer o2) -> {
//                return o2 - o1; //  降序
//        });


//        Arrays.sort(ages1, ( o1,  o2) -> {
//            return o2 - o1; //  降序
//        });

        Arrays.sort(ages1, ( o1,  o2 ) ->  o2 - o1 );

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

        System.out.println(;---------------------------;);
        JFrame win = new JFrame(;登录界面;);
        JButton btn = new JButton(;我是一个很大的按钮;);
//        btn.addActionListener(new ActionListener() {
//            ;Override
//            public void actionPerformed(ActionEvent e) {
//                System.out.println(;有人点我;点我;点我;;;);
//            }
//        });

//        btn.addActionListener((ActionEvent e) -> {
//                System.out.println(;有人点我;点我;点我;;;);
//        });

//        btn.addActionListener(( e) -> {
//            System.out.println(;有人点我;点我;点我;;;);
//        });

//        btn.addActionListener( e -> {
//            System.out.println(;有人点我;点我;点我;;;);
//        });

        btn.addActionListener( e -> System.out.println(;有人点我;点我;点我;;;) );



        win.add(btn);
        win.setSize(400, 300);
        win.setVisible(true);
    }
}

 

网友评论

快盘下载暂未开通留言功能。

关于我们| 广告联络| 联系我们| 网站帮助| 免责声明| 软件发布

Copyright 2019-2029 【快快下载吧】 版权所有 快快下载吧 | 豫ICP备10006759号公安备案:41010502004165

声明: 快快下载吧上的所有软件和资料来源于互联网,仅供学习和研究使用,请测试后自行销毁,如有侵犯你版权的,请来信指出,本站将立即改正。