常用API、Lambda、常见算法

目录

日期与时间

Date

SimpleDateFormat

Calendar

JDK8新增日期类

概述、LocalTime/LocalDate/LocalDateTime

Instant

DateTimeFormatter

Duration/Period

ChronoUnit

包装类

包装类练习

正则表达式

正则表达式概述、初体验

正则表达式的匹配规则

正则表达式的常见案例

正则表达式在方法中的应用

正则表达式爬取信息

Arrays类

Arrays类的概述、常用功能演示

Arrays类对于Comparator比较器的支持

Lambda表达式

Lambda概述

Lambda实战-简化常见函数接口

Lambda表达式的省略规则


日期与时间

Date

Date类概述
    Date类的对象在Java中代表的是当前所在系统的此刻日期时间

Date的构造器

名称说明
public Date()创建一个Date对象,代表的是系统当前此刻日期时间

Date的常用方法

名称

说明

public long getTime()获取时间对象的毫秒值
Date类记录时间的2种格式
形式1:日期对象
//1、创建一个日期对象代表了:当前系统的此刻日期时间对象
Date d = new Date();
System.out.println(d);
形式2:时间毫秒值
指的是从1970年1月1日 00:00:00走到此刻的总毫秒数,应该是很大的
//2、获取当前时间毫秒值
long time = d.getTime();
System.out.println(time);
案例
请计算出当前时间往后走1小时121秒之后的时间是多少。

时间毫秒值->日期对象 

构造器说明
public Date(long time)把时间毫秒值转换成Date日期对象。
Date方法说明
public void setTime(long time)设置日期对象的时间为当前时间毫秒值对应的时间
1、日期对象如何创建,如何获取时间毫秒值?
    Date date = new Date();
    Long time = date. getTime ();
2、时间毫秒值怎么恢复成日期对象
    Dated=new Date(time);
    d.setTime(time);
import java.util.Date;

//学会使用Date类处理时间,获取时间信息
public class Test {
    public static void main(String[] args) {
        //1、创建一个日期对象代表了:当前系统的此刻日期时间对象
        Date d = new Date();
        System.out.println(d);//Fri Feb 03 13:28:52 CST 2023

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

        System.out.println("-----------------");
        //请计算出当前时间往后走1小时121秒之后的时间是多少。
        //1、得到当前时间毫秒值
        Date d1 = new Date();
        System.out.println(d1);//Fri Feb 03 13:48:32 CST 2023

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

        /*//3、把时间毫秒值转换成对应的时间对象
        Date d3 = new Date(d2);
        System.out.println(d3);//Fri Feb 03 14:50:33 CST 2023*/

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

SimpleDateFormat

SimpleDateFormat类作用
    可以对Date对象或时间毫秒值格式化成我们喜欢的时间形式。
    也可以把字符串的时间形式解析成日期对象。

 SimpleDateFormat的

构造器说明
public SimpleDateFormat()构造一个SimpleDateFormat,使用默认格式
public SimpleDateFormat(String pattern)构造一个SimpleDateFormat,使用指定的格式

SimpleDateFormat的格式化方法

格式化方法说明
public final String format(Date date)将日期格式化成日期/时间字符串
public final String format(Object time)将时间毫秒值式化成日期/时间字符串

格式化的时间形式的常用的模式对应关系如下:

yMdHms
2020年11月11日 13:27:06yyyy年MM月dd日 HH:mm:ss
2020-11-11 13:27:06

yyyy-MM-dd HH:mm:ss

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

//SimpleDateFormat简单日期格式化类的使用
public class Test {
    public static void main(String[] args) {
        //1、日期对象
        Date d = new Date();
        System.out.println(d);//Fri Feb 03 14:36:27 CST 2023

        //2、格式化这个日期对象(指定最终格式化的形式)
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");//年月日 时分秒 周几 上/下午

        //3、开始格式化日期对象成为喜欢的字符串格式
        String rs = sdf.format(d);//将日期格式化
        System.out.println(rs);//2023年02月03日 14:36:27 周五 下午
        System.out.println("-------------------");

        //4、格式化时间毫秒值
        //需求:请问121秒后时间是多少
        long time = d.getTime() + 121 * 1000;
        String rs1 = sdf.format(time);
        System.out.println(rs1);//2023年02月03日 14:38:28 周五 下午
    }
}

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

解析方法说明
public Date parse(String source)从给定字符串的开始解析文本以生成日期
案例
请计算出2021年08月06日11点11分11秒,往后走2天14小时49分06秒后的时间是多少。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
        案例
        请计算出2021年08月06日 11点11分11秒,往后走2天14小时49分06秒后的时间是多少。
 */
public class Test {
    public static void main(String[] args) throws ParseException {
        //1、把时间拿到程序中
        String timeStr = "2021年08月06日 11点11分11秒";

        //2、把字符串时间解析成日期对象 形式必须与被解析时间的形式完全一样,否则运行解析报错!
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH点mm分ss秒");
        Date d = sdf.parse(timeStr);
        //Date d = sdf.parse("2021年08月06日 11点11分11秒");

        //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));
    }
}

 

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.zip.DataFormatException;

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

        //4、判断是否秒杀成功
        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("小皮秒杀失败!");
        }
    }
}

Calendar

Calendar概述
    Calendar代表了系统此刻日期对应的日历对象。
    Calendar是一个抽象类,不能直接创建对象。

 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()拿到此刻时间毫秒值
import java.util.Calendar;
import java.util.Date;

public class Test {
    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 month = cal.get(Calendar.MONTH) + 1;//从0开始记月的
        System.out.println(month);
        int day = cal.get(Calendar.DAY_OF_YEAR);
        System.out.println(day);

        //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);

        //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);
    }
}
注意:Calendar是可变日期对象,一旦修改后其对象本身表示的时间将产生变化

JDK8新增日期类

概述、LocalTime/LocalDate/LocalDateTime

Instant

DateTimeFormatter

Duration/Period

ChronoUnit

包装类

包装类
    将基本数据类型,包装成为类(变成引用数据类型)
变成类,就可以创建对象了,对象就可以调用方法方便的解决问题了

public class Test {
    /*
        包装类:将基本数据类型,包装成类,变成引用数据类型

        手动装箱:调用方法,手动将基本数据类型,包装成类
            1. public Integer(int value):通过构造方法(不推荐)
            2. public static Integer valueof(int i):通过静态方法
        手动拆箱:调用方法,手动将包装类,拆成(转换)基本数据类型
            1. public int intvalue():以int类型返回该 Integer的值

        JDK5版本开始,出现了自动拆装箱:
             1.自动装箱:可以将基本数据类型,直接赋值给包装类的变量
             2.自动拆箱:可以将包装类的数据,直接赋值给基本数据类型变量
             
             结论:基本数据类型,相对应的包装类,可以直接做运算,不需要操心转换问题了
        */
    public static void main(String[] args) {
        int num =10;
        Integer i1= Integer.valueOf(num);//手动装箱
        int i = i1.intValue();//手动拆箱

        Integer i2= num;//自动装箱
        int i3 = i2;//自动拆箱

        System.out.println(i);
    }
}

 Integer常用方法

public static String toBinaryString(inti)转二进制
public static String toOctalString(int i)转八进制
public static String toHexString (int i)转十六进制
public static int parseInt (String s)

将数字字符串,转换为数字

public class Test {
    /**
     * Integer 常用方法:
     * public static String toBinaryString(inti):转二进制
     * public static String toOctalString(int i):转八进制
     * public static String toHexString (int i):转十六进制
     * public static int parseInt (String s):将数字字符串,转换为数字
     */
    public static void main(String[] args) {
        int num = 100;
        System.out.println(Integer.toBinaryString(num));//1100100
        System.out.println(Integer.toOctalString(num));//144
        System.out.println(Integer.toHexString(num));//64
        String s = "123";

        System.out.println(Integer.parseInt(s) + 100);// 223
    }
}

包装类练习

public class Test {
    /**
     * 已知字符串 String s="10,50,30,20,40";
     * 请将该字符串转换为整数并存入数组
     * 随后求出最大值打印在控制台
     */
    public static void main(String[] args) {
        String s = "10,50,30,20,40";

        // 1. 根据逗号做切割,将字符串切割放进字符数组
        String[] sArr = s.split(",");

        //2.准备一个整数数组,准备存储转换后的数字
        int[] nums = new int[sArr.length];

        //3.遍历字符串数组
        for (int i = 0; i < sArr.length; i++) {
            //sArr[i]:每一个数字字符串
            //4.将数字字符串转换为整数,并存入数组
            nums[i] = Integer.parseInt(sArr[i]);
        }

        // 5. 求最大值
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > max) {
                max = nums[i];
            }
        }
        System.out.println("最大值为:" + max);//最大值为:50
    }
}

正则表达式

正则表达式概述、初体验

正则表示
正则表达式可以用一些规定的字符来制定规则,并用来校验数据格式的合法性。
正则表达式初体验
需求:假如现在要求校验一个qq号码是否正确,6位及20位之内,必须全部是数字。
先使用目前所学知识完成校验需求;然后体验一下正则表达式检验。
public class Test {
    //校验一个qq号码是否正确,6位及20位之内,必须全部是数字
    public static void main(String[] args) {
        System.out.println(checkQQ("123421784"));//true
        System.out.println(checkQQ("12342a1784"));//false
        System.out.println(checkQQ("11784"));//false
        System.out.println(checkQQ(null));//false

        System.out.println("-------------------");
        //正则表达式初体验
        System.out.println(checkQQ2("123421784"));//true
        System.out.println(checkQQ2("12342a1784"));//false
        System.out.println(checkQQ2("11784"));//false
        System.out.println(checkQQ2(null));//false
    }

    //正则表达式
    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中是否全是数字
        for (int i = 0; i < qq.length(); i++) {
            char ch = qq.charAt(i);//获取每位字符
            if (ch < '0' || ch > '9') {
                return false;
            }
        }
        return true;
    }
}

正则表达式的匹配规则

//全面深入学习正则表达式的规则
public class Test {
    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("ssds3c0".matches("\\w{6,}"));//true
        System.out.println("ssdsc".matches("\\w{6,}"));//false

        //验证码:必须是数字和字符 必须是4位
        System.out.println("32ob".matches("[a-zA-Z0-9]{4}"));//true
        System.out.println("32_b".matches("[a-zA-Z0-9]{4}"));//false
        System.out.println("32ob".matches("[\\w&&[^_]]{4}"));//true
        System.out.println("32_b".matches("[\\w&&[^_]]{4}"));//false
    }
}

正则表达式的常见案例

案例
请使用正则表达式完成如下需求
需求
    1、请编写程序模拟用户输入手机号码、验证格式正确,并给出提示,直到格式输入正确为止。请编写程序模拟
    2、户输入邮箱号码、验证格式正确,并给出提示,直到格式输入正确为止。请编写程序模拟用户输入电话号码、
    3、验证格式正确,并给出提示,直到格式输入正确为止。
分析
    定义方法,接收用户输入的数据,使用正则表达式完成检验,并给出提示。
import java.util.Scanner;

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

    //电话
    public static void checkTel() {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入您的注册电话:");
            String tel = sc.next();
            //判断电话的格式是否正确  021-154269  021154269
            if (tel.matches("0\\d{2,6}-?\\d{5,20}")) {
                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 static void checkEmail() {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入您的注册邮箱:");
            String email = sc.next();
            //判断邮箱的格式是否正确  23572@qq.com
            //判断邮箱的格式是否正确  14523572@163.com
            //判断邮箱的格式是否正确  2dhus3267@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 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 Test {
    public static void main(String[] args) {
        String names = "小路dhdfhdf342蓉儿43fdffdfbjdfaf过儿";
        String[] arr = names.split("\\w+");//切割
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);//输出切割后的字符数组内容
        }

        //将数字字母下划线替换成空格
        String names2 = names.replaceAll("\\w+", " ");
        System.out.println(names2);//小路 蓉儿 过儿
    }
}

正则表达式爬取信息

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

public class Test {
    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})|(0\\d{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);
        }
    }
}

Arrays类

Arrays类的概述、常用功能演示

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 Test {
    public static void main(String[] args) {
        //使用Arrays类常用API并理解其原理
        int[] arr = {10, 2, 55, 23, 21, 155};
        System.out.println(arr);

        //1、返回数组内容的toString(数组)
//        String rs = Arrays.toString(arr);
//        System.out.println(rs);//数组内容:[10, 2, 55, 23, 21, 155]

        System.out.println(Arrays.toString(arr));//[10, 2, 55, 23, 21, 155]

        //2、排序API(默认升序排序)
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));//[2, 10, 21, 23, 55, 155]

        //3、二分查找技术(前提是数组元素必须是排好序的)
        int index = Arrays.binarySearch(arr, 23);
        System.out.println(index);//3

        //返回不存在的元素规律:-(应该插入的位置索引+1)
        int index1 = Arrays.binarySearch(arr, 230);
        System.out.println(index1);//-7

        //注意:数组如果没有排好序,可能会找不到元素,从而出现bug
        int[] arr1 = {12, 36, 34, 25, 13, 24, 234, 100};
        System.out.println(Arrays.binarySearch(arr1, 13));//-2
    }
}

Arrays类对于Comparator比较器的支持

Arrays类的排序方法

方法名说明
public static void sort(类型[] a)对数组进行默认升序排序
public static <T> void sort(类型[] a, Comparator<? super T> c)使用比较器对象自定义排序
自定义排序规则
    设置Comparator接口对应的比较器对象,来定制比较规则。
        如果认为左边数据 大于 右边数据 返回正整数
        如果认为左边数据 小于 右边数据 返回负整数
        如果认为左边数据 等于 右边数据 返回0
import java.util.Arrays;
import java.util.Comparator;

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

        //2、需求:降序排序(自定义比较器对象,只能支持引用类型的排序!)
        Integer[] ages1 = {34, 12, 43, 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;
                }else {
                    return 0;
                }*/

                //return o1-o2;//默认升序
                return o2 - o1;//默认降序
            }
        });
        //Arrays.sort(ages1, ( o1,  o2) ->  o2 - o1);简化写法

        System.out.println(Arrays.toString(ages1));
    }
}
import java.util.Arrays;
import java.util.Comparator;

public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("阿珍", 20, 170);
        students[1] = new Student("阿强", 23, 180.5);
        students[2] = new Student("星星", 24, 185.5);

        //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));
    }
}

Lambda表达式

Lambda概述

Lambda概述
    Lambda表达式是JDK 8开始后的一种新语法形式。
    作用:简化匿名内部类的代码写法。
Lambda表达式的简化格式
    (匿名内部类被重写方法的形参列表)->{
        被重写方法的方法体代码。
     {
    注:->是语法形式,无实际含义
注意:Lambda表达式只能简化函数式接口的匿名内部类的写法形式
什么是函数式接口?
    首先必须是接口、其次接口中有且仅有一个抽象方法的形式
public class Test {
    public static void main(String[] args) {
        //学会使用Lambda的标准格式化匿名内部类的代码形式
        //Lambda只能简化接口中只有一个抽象方法的匿名内部类

//        Swimming s1 = new Swimming() {
//            @Override
//            public void swim() {
//                System.out.println("老师游泳贼溜~~~");
//            }
//        };

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

        System.out.println("--------------------");
//        Swimming s2 = new Swimming() {
//           @Override
//            public void swim() {
//                System.out.println("学生游泳很开心~~~");
//            }
//        };
        /*go(new Swimming() {
            @Override
            public void swim() {
                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();
}
1、Lambda表达式的基本作用?
    简化函数式接口的匿名内部类的写法。
2、Lambda表达式有什么使用前提?
    必须是接口的匿名内部类,接口中只能有一个抽象方法
3、Lambda的好处?
    Lambda是一个匿名函数,我们可以把Lambda表达式理解为是一段可以传递的代码,
    它可以写出更简洁、更灵活的代码,作为一种更紧凑的代码风格,
    使Java语言表达能力得到了提升。

Lambda实战-简化常见函数接口

import java.util.Arrays;
//Lambda
public class Test {
    public static void main(String[] args) {
        int[] ages = {34, 12, 43, 23};
        Arrays.sort(ages);
        System.out.println(Arrays.toString(ages));

        Integer[] ages1 = {34, 12, 43, 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, (Integer o1, Integer o2)->  o2 - o1);

        Arrays.sort(ages1, ( o1,  o2)->  o2 - o1);
        
        System.out.println(Arrays.toString(ages1));
    }
}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

Lambda表达式的省略规则

Lambda表达式的省略写法(进一步在Lambda表达式的基础上继续简化)
    参数类型可以省略不写。
    如果只有一个参数,参数类型可以省略,同时()也可以省略。
    如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号!
    如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。
    此时,如果这行代码是return语句,必须省略return不写,同时也必须省略”;“不写
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==
  • 2
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值