JavaSE进阶（day04，复习自用）

最新推荐文章于 2025-12-27 15:45:53 发布

原创最新推荐文章于 2025-12-27 15:45:53 发布 · 228 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #算法

JavaSE进阶专栏收录该内容

14 篇文章

订阅专栏

本文详细介绍了JavaSE中关于Math、System、BigDecimal、日期与时间处理的相关API，包括Date、SimpleDateFormat、Calendar等类的使用。此外，还讲解了JDK8新增的日期类、包装类的特性和用途，以及正则表达式的匹配规则和应用。最后，讨论了Lambda表达式的概念和简化函数式接口的实践。

常用API（续上文）

Math

在这里插入图片描述

public class MathDemo {
    public static void main(String[] args) {
        //1.取绝对值
        System.out.println(Math.abs(-10.3));//10.3

        //2.向上取整
        System.out.println(Math.ceil(4.00001));//5.0

        //3.向下取整
        System.out.println(Math.floor(4.999999));//4.0


        //4.求指数次方
        System.out.println(Math.pow(2, 3));//8.0

        //5.四舍五入
        System.out.println(Math.round(4.499999));//4
        System.out.println(Math.round(4.5000001));//5

        //6.随机[0.0-1.0)的数
        System.out.println(Math.random());

        //拓展3-9之间的随机数(0-6)+3
        int data = (int)(Math.random()*7) + 3;
        System.out.println(data);

    }
}

System

在这里插入图片描述

System.exit(0);//JVM终止

在这里插入图片描述

//2.计算机认为时间有起源：返回1970-1-1 00:00:00 走到此刻的总的毫秒值：时间毫秒值
        long time = System.currentTimeMillis();
        System.out.println(time);

        long startTime = System.currentTimeMillis();
        //进行时间的计算，性能分析
        for (int i = 0; i < 10000; i++) {
            System.out.println("输出" + i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println((endTime - startTime)/1000.0+"s");

//3.数组拷贝(了解)
//        arraycopy(Object src,  int  srcPos,
//        Object dest, int destPos,
//        int length);
        /**
         * 参数一：被拷贝的数组
         * 参数二：从哪个索引位置开始拷贝
         * 参数三：复试的目标数组
         * 参数四：粘贴位置
         * 参数五：拷贝元素个数
         */
        int[] arr1 = {10,20,30,40,50,60,70};
        int[] arr2 = new int[6];//[0,0,0,0,0,0] ==>[0,0,40,50,60,0]
        System.arraycopy(arr1,3,arr2,2,3);
        System.out.println(Arrays.toString(arr2));

BigDecimal

在这里插入图片描述

import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigDecimalDemo {
    public static void main(String[] args) {
        //浮点数运算直接用+-*/的话可能会存在数据失真的问题（精度问题）
        //包装浮点数据成为大数据对象BigDecimal
        double a = 0.1;
        double b = 0.2;
        double c = a + b;
        BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);
        BigDecimal c1 = a1.add(b1);
        //BigDecimal c1 = a1.subtract(b1);
        //BigDecimal c1 = a1.multiply(b1);
        //BigDecimal c1 = a1.divide(b1);

        System.out.println(c1);

        //目标：double
        double rs = c1.doubleValue();
        System.out.println(rs);

        //注意事项：BigDecimal是一定要精度运算的
        BigDecimal a11 = BigDecimal.valueOf(10.0);
        BigDecimal b11 = BigDecimal.valueOf(3.0);
        /**
         * 参数一：除数
         * 参数二：保留小数位
         * 参数三：舍入模式
         */
        BigDecimal c11 = a11.divide(b11,2, RoundingMode.HALF_UP);//3.333333
        System.out.println(c11);


    }
}

日期与时间

Date

在这里插入图片描述

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小时121秒之后的时间是多少
        //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);

    }

}

1、日期对象如何创建，如何获取时间毫秒值？
public Date();
public long getTime();
2、时间毫秒值怎么恢复成日期对象
public Date(long time);
public void setTime(long time);

SimpleDateFormat

在这里插入图片描述

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);
        System.out.println("Date d = "+d);


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

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


    }
}

在这里插入图片描述
1、SimpleDateFormat代表什么，有什么作用？
简单日期格式化对象
可以把日期对象及时间毫秒值格式化成我们想要的字符串形式。
可以把字符串的时间形式解析成Date日期对象。
2、SimpleDateFormat的对象如何创建？
public SimpleDateFormat(String pattern)
3、SimpleDateFormat格式化，以及解析时间的方法是怎么样的？
public final String format(Date d):格式化日期对象
public final String format(Object time):格式化时间毫秒值
public Date parse(String source)：解析字符串时间
在这里插入图片描述

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("小皮秒杀失败!");
        }



    }
}

Calendar

在这里插入图片描述

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

public class CalendarDemo01 {
    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);//Sat Jul 15 11:31:57 CST 2023

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


    }
}

JDK8新增日期类

概述、LocalTime /LocalDate / LocalDateTime

在这里插入图片描述

Instant

在这里插入图片描述

DateTimeFormatter

在这里插入图片描述

Duration/Period

在这里插入图片描述

ChronoUnit

在这里插入图片描述

包装类

在这里插入图片描述

1、包装类是什么，作用是什么？
基本数据类型对应的引用类型，实现了一切皆对象。
后期集合和泛型不支持基本类型，只能使用包装类。

2、包装类有哪些特殊功能？
可以把基本类型的数据转换成字符串类型(用处不大)
可以把字符串类型的数值转换成真实的数据类型（真的很有用）

/**
 * 目标：明白包装类的概念，并使用。
 */
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);
    }
}

正则表达式

正则表达式概述、初体验

在这里插入图片描述

public class RegexDemo1 {
    public static void main(String[] args) {
        //需求：校验QQ号码，必须全部数字6-20位
        System.out.println(checkQQ("24141532"));
        System.out.println(checkQQ("2414a1532"));
        System.out.println(checkQQ(null));
        System.out.println(checkQQ("2344"));

        //正则表达式的初体验
        System.out.println("----------------------------");
        System.out.println(checkQQ2("24141532"));
        System.out.println(checkQQ2("2414a1532"));
        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
        for (int i = 0; i < qq.length(); i++) {
            char ch = qq.charAt(i);//获取每个字符
            if(ch <'0'||ch >'9'){
                return false;
            }
        }
        return true;
    }




}

正则表达式的匹配规则

在这里插入图片描述

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

        // 验证码 必须是数字和字符  必须是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.Scanner;

public class RegexTest3 {
    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 phone = sc.next();
            //判断电话号码的格式是否正确 020-357457 020357457
            if(phone.matches("0\\d{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();
            //判断邮箱的格式是否正确
            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[] split(String regex)：
 *  按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组。
 *  public String replaceAll(String regex,String newStr)
 *  按照正则表达式匹配的内容进行替换
 */

public class RegexDemo04 {
    public static void main(String[] args) {
        String names = "路飞denskjn海贼王dawtskgn一定可以";
        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);
    }
}

运行结果：
路飞
海贼王
一定可以
路飞海贼王一定可以

正则表达式爬取信息

在这里插入图片描述

Arrays类

Arrays类概述，常用功能演示

在这里插入图片描述

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,555);
        System.out.println(index2);


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


    }
}

Arrays类对于Comparator比较器的支持

在这里插入图片描述

import java.util.Arrays;
import java.util.Comparator;

public class ArraysDemo2 {
    public static void main(String[] args) {
        //目标：自定义数组的排序规则：Comparator比较器对象
        //1.Array的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 -(o1 - o2);//默认降序
            }
        });

        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(o1.getHeight(),o2.getHeight());//比较浮点型可以这样写 降序
            }
        });
        System.out.println(Arrays.toString(students));
    }
}

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;

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

        //2.定义一个循环控制选择几轮：arr.length -1
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));


    }
}

二分查找

//目标：理解二分搜索的原理并实现
public class Test2 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {10,14,16,25,28,30,35,88,100};
        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]){
                left = middleIndex + 1;
            }else if(data <arr[middleIndex]){
                right = middleIndex;
            }else{
                return middleIndex;
            }

        }
        return -1;//查无此元素
    }
}

Lambda表达式

Lambda概述

在这里插入图片描述

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

    }
}

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

1、Lambda表达式的基本作用？
简化函数式接口的匿名内部类的写法。
2、Lambda表达式有什么使用前提？
必须是接口的匿名内部类，接口中只能有一个抽象方法

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("学生游泳很开心~~");
        });


    }


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

    }
}

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

Lambda表达式的省略规则

在这里插入图片描述

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[] ages = {66, 33, 22, 55, 88};

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

//        //简化之后的代码
//        Arrays.sort(ages, (Integer o1, Integer o2)-> {
//                return o2 - o1;
//        });

        //再简化之后的代码
        Arrays.sort(ages, ( o1,  o2)-> {
            return o2 - o1;
        });

        //再简化之后的代码
        Arrays.sort(ages, ( o1,  o2)-> o2 - o1);

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

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

    }
}