黑马java学习笔记11(阶段二 第三章3-1~3-2)

已于 2024-09-22 18:16:13 修改
阅读量604 收藏 11
点赞数 7
分类专栏： 黑马程序员Java学习笔记 文章标签： java 学习 笔记
于 2024-09-19 16:36:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaozhuzhu__/article/details/142363969
版权

以下学习笔记记录于：2024.09.11-2024.09.17

文章目录

阶段二 JavaSE进阶

第三章 JDK8新特性、算法、正则表达式、异常

3-1 JDK8新特性

1）Lambda表达式
66 认识Lambda表达式

image-20240911200819898

LambdaTest1.java:

public class LambdaTest1 {
    public static void main(String[] args) {
//        Swimming s = new Swimming(){
//            @Override
//            public void swim() {
//                System.out.println("学生快乐地游泳~~~");
//            }
//        };

        // 用Lambda表达式来对函数式接口的匿名内部类进行简化
        Swimming s = () -> {
                System.out.println("学生快乐地游泳~~~");
        };
        s.swim();
    }
}

interface Swimming{
    void swim();
}

运行结果：

image-20240911202832170

之前代码中可以用Lambda表达式简化的部分例子如下：

用“ctrl + 鼠标点击”即可进入具体的代码部分，若看到标志词“@FunctionalInterface”或仅有一个抽象方法的接口，则可以用Lambda表达式进行简化。

  • 在第二章2-4的“63 基本使用”中，ArraysTest1有以下代码可以进行简化
//        Arrays.setAll(prices, new IntToDoubleFunction() {
//            @Override
//            public double applyAsDouble(int value) {
//                BigDecimal p = BigDecimal.valueOf(prices[value]);
//                double a = 0.8;
//                BigDecimal p1 = p.multiply(BigDecimal.valueOf(a));
//                return p1.doubleValue();
                return prices[value] * 0.8;       // 可以选择用BigDecimal计算（此处不会失真可直接return）
//            }
//        });
        Arrays.setAll(prices, (int value) -> {
                BigDecimal p = BigDecimal.valueOf(prices[value]);
                double a = 0.8;
                BigDecimal p1 = p.multiply(BigDecimal.valueOf(a));
                return p1.doubleValue();
        });
  • 在第二章2-4的“65 自定义排序规则的方式二”中，ArraysTest2有以下代码可以进行简化
//        Arrays.sort(students, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return Double.compare(o1.getHeight(), o2.getHeight());  // 升序
//            }
//        });
        Arrays.sort(students, (Student o1, Student o2) -> {
                return Double.compare(o1.getHeight(), o2.getHeight());  // 升序
        });
67 Lambda表达式的省略规则

image-20240912191050891

  • 在第二章2-4的“63 基本使用”中，ArraysTest1的以下代码可以继续进行简化
//        Arrays.setAll(prices, (int value) -> {
//                BigDecimal p = BigDecimal.valueOf(prices[value]);
//                double a = 0.8;
//                BigDecimal p1 = p.multiply(BigDecimal.valueOf(a));
//                return p1.doubleValue();
//        });

//        Arrays.setAll(prices, (value) -> {
//            BigDecimal p = BigDecimal.valueOf(prices[value]);
//            double a = 0.8;
//            BigDecimal p1 = p.multiply(BigDecimal.valueOf(a));
//            return p1.doubleValue();
//        });

        Arrays.setAll(prices, value -> {
            BigDecimal p = BigDecimal.valueOf(prices[value]);
            double a = 0.8;
            BigDecimal p1 = p.multiply(BigDecimal.valueOf(a));
            return p1.doubleValue();
        });
  • 在第二章2-4的“65 自定义排序规则的方式二”中，ArraysTest2的以下代码可以进一步进行简化
//        Arrays.sort(students, (Student o1, Student o2) -> {
//                return Double.compare(o1.getHeight(), o2.getHeight());  // 升序
//        });

//        Arrays.sort(students, ( o1,  o2 ) -> {
//            return Double.compare(o1.getHeight(), o2.getHeight());  // 升序
//        });

        Arrays.sort(students, ( o1,  o2 ) -> Double.compare( o1.getHeight(), o2.getHeight()) );
2）方法引用

方法引用简化Lambda表达式一共有4种常见的简化场景：静态方法的引用、实例方法的引用、特定类型方法的引用、构造器引用。方法引用的标志性符号"::"，双冒号。

68 静态方法的引用、实例方法的引用

image-20240912201856746
image-20240912210829990

Student.java:

package com.itheima.hello.ObjectDemo.d5_arrays;

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public double getHeight() {
        return height;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", height=" + height +
                ", age=" + age +
                '}';
    }
}

CompareByData.java:

package com.itheima.hello.ObjectDemo.d7_method_references;

import com.itheima.hello.ObjectDemo.d5_arrays.Student;

public class CompareByData {
    // 静态方法
    public static int compareByAge(Student o1, Student o2){
        return o1.getAge() - o2.getAge();   // 升序
    }
    
    // 实例方法
    public int compareByAgeDesc(Student o1, Student o2){
        return o2.getAge() - o1.getAge();   // 降序
    }
}

Test1.java:

package com.itheima.hello.ObjectDemo.d7_method_references;
import com.itheima.hello.ObjectDemo.d5_arrays.Student;

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

public class Test1 {
    public static void main(String[] args) {
        Student[] students = new Student[4];
        students[0] = new Student("蜘蛛精",169.6, 890);
        students[1] = new Student("紫霞",165.5, 18);
        students[2] = new Student("至尊宝",183.0, 1000);
        students[3] = new Student("兔精",158.9, 248);

        // 原始写法：对数组中的学生对象按照年龄升序排序
//        Arrays.sort(students, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return o1.getAge() - o2.getAge();
//            }
//        });

        // 使用Lambda简化后的形式
//        Arrays.sort(students, ( o1, o2) -> o1.getAge() - o2.getAge());

//        Arrays.sort(students, ( o1, o2) -> CompareByData.compareByAge(o1, o2));
        // 静态方法的引用
        Arrays.sort(students, CompareByData::compareByAge);

        for (Student student : students) {
            System.out.println(student);
        }
        
        // 使用Lambda简化后的形式（降序）
//        Arrays.sort(students, (o1, o2) -> o2.getAge() - o1.getAge());

        CompareByData compare = new CompareByData();
//        Arrays.sort(students, (o1, o2) -> compare.compareByAgeDesc(o1, o2));
        // 实例方法的引用
        Arrays.sort(students, compare::compareByAgeDesc);

        System.out.println("-----------------------------------------------");
        System.out.println("按照年龄降序排序结果如下：");
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i]);
        }
    }
}

运行结果：

image-20240912210851234

69 特定类型方法的引用

image-20240912211857997

Test2.java:

package com.itheima.hello.ObjectDemo.d7_method_references;

import java.util.Arrays;

public class Test2 {
    public static void main(String[] args) {
        String[] names = {"boby", "angela", "Andy" ,"dlei", "caocao", "Babo", "jack", "cici"};

        // 进行排序(默认是按照字符串的首字符编号(ASCII码)进行升序排序的)
//        Arrays.sort(names);

        // 要求忽路首字符大小写进行排序。
//        Arrays.sort(names, new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.compareToIgnoreCase(o2);      // Java提供的方法
//            }
//        });

        // Lambda简化
//        Arrays.sort(names, ( o1,  o2) -> o1.compareToIgnoreCase(o2));

        // 特定类型的方法引用
        Arrays.sort(names, String::compareToIgnoreCase);

        System.out.println(Arrays.toString(names));
    }
}

运行结果：

image-20240912212851314

70 构造器引用（很少使用场景）

image-20240913211458335

Car.java:

package com.itheima.hello.ObjectDemo.d7_method_references;

public class Car {
    private String name;
    private double price;

    public Car() {
    }

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

Test3.java:

package com.itheima.hello.ObjectDemo.d7_method_references;

public class Test3 {
    public static void main(String[] args) {
        // 1、创建这个接口的匿名内部类对象
//        CreateCar cc = new CreateCar() {
//            @Override
//            public Car create(String name, double price) {
//                return new Car(name, price);
//            }
//        };

//        CreateCar cc = ( name,  price) -> new Car(name, price);

        // 构造器引用
        CreateCar cc = Car::new;

        Car c = cc.create("奔驰", 49.9);
        System.out.println(c);
    }
}

interface CreateCar{
    Car create(String name, double price);
}

运行结果：

image-20240913211434741

3-2 算法

72 排序算法——冒泡排序

image-20240913212922818

Test1.java:

package com.itheima.hello.d1_algorithm;

import java.util.Arrays;
// 冒泡排序
public class Test1 {
    public static void main(String[] args) {
        // 1、准备一个数组
        int[] arr = {5, 2, 3, 1};

        // 2、定义一个循环控制排几轮
        for (int i = 0; i < arr.length - 1; i++) {
            // i = 0 1 2     [5, 2, 3, 1]   比较次数
            // i = 0 第一轮    0  1  2          3
            // i = 1 第二轮    0  1             2
            // i = 2 第三轮    0                1

            // 3、定义一个循环控制每轮比较几次
            for (int j = 0; j < arr.length - i - 1; j++) {
                // 判断当前位置的元素值是否大于后一个位置处的元素值，如果是则交换
                if (arr[j] > arr[j+1]){
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
            System.out.println("第" + (i + 1) + "轮排序结果：" +Arrays.toString(arr));
        }
    }
}

运行结果：

image-20240913214023967

73 排序算法——选择排序

image-20240913215524054

Test2.java:

package com.itheima.hello.d1_algorithm;

import java.util.Arrays;

// 选择排序
public class Test2 {
    public static void main(String[] args) {
        // 1、准备一个数组
        int[] arr = {5, 1, 3, 2};

        // 2、控制选择几轮
        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++) {
                // 判断当前位置的元素值是否大于后面位置处的元素值，如果是则交换
                if (arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
            System.out.println("第" + (i + 1) + "轮排序结果：" + Arrays.toString(arr));
        }
    }
}

运行结果：

image-20240913215306421

74 查找算法——二分查找

前提条件：数组中的数据必须是有序的

核心思想：每次排除一半的数据，查询数据的性能明显提高极多

Test3.java:

package com.itheima.hello.d1_algorithm;

import java.util.Arrays;
import java.util.Scanner;

// 二分查找（折半查找）
public class Test3 {
    public static void main(String[] args) {
        // 1、准备好一个数组
        int[] arr = {7, 23, 79, 81, 103, 127, 131, 147};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入想要查找的数据值（int）：");
        int data = sc.nextInt();
        System.out.println(data + "在数组中的索引位置为：" + binarySearch(arr, data));
//        System.out.println(data + "在数组中的索引位置为：" + Arrays.binarySearch(arr, data));
    }

    public static int binarySearch(int[] arr, int data){
        // 1、定义两个变量，一个在左边，一个在右边
        int left = 0;
        int right = arr.length - 1;

        // 2、定义一个循环控制折半
        while(left <= right){
            // 3、每次折半，都算出中间位置处的索引
            int middle = (left + right) / 2;
            // 4、判断当前要找的元素值与中间位置处的元素值的大小情况
            if (data < arr[middle]){
                right = middle - 1;
            }else if (data > arr[middle]){
                left = right + 1;
            }else {
                return middle;
            }
        }
        return -1;      // 代表没有找到该数据
    }
}

运行结果：

image-20240919155458441

海盐之冬
关注
专栏目录
黑马java学习笔记12(阶段二 第三章3-3~第四章4-1)
xiaozhuzhu__的博客
09-24 819
黑马java学习笔记12(阶段二 第三章3-3~第四章4-1)
黑马java学习笔记7(阶段二 第一章 1-2~1-5)
xiaozhuzhu__的博客
08-21 902
黑马java学习笔记7(阶段二 第一章 1-2~1-5)
黑马java学习笔记1(阶段一 第一章1-1~1-4 08)
xiaozhuzhu__的博客
07-09 1195
黑马程序员Java学习路线：Java基础 → JavaWeb → 热门框架 → 苍穹外卖 → 服务框架 → 天机学堂 → 立可得→ 面试专题
黑马java学习笔记2(阶段一 第一章1-4 13~1-5 07)
xiaozhuzhu__的博客
07-17 281
注：在实际开发过程中建议使用“数据类型[] 数组名”的格式来写代码。// 方式一：静态初始化数组// 1.完整格式：// 数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, ……};// 存储的是数组在内存中的地址，所以是输出地址而不是值// 2.简化格式：// 推荐写法：数据类型[] 数组名 = {元素1, 元素2, ……};// 还可写成：数据类型 数组名[] = {元素1, 元素2, ……};// 方式二：动态初始化数组。
黑马java学习笔记10(阶段二 第二章2-2~2-4)第二章完结
xiaozhuzhu__的博客
09-11 1148
黑马java学习笔记10(阶段二 第二章2-2~2-4)第二章完结
黑马java学习笔记3(阶段一 第一章1-5 08~1-7)第一章完结
xiaozhuzhu__的博客
07-24 389
黑马java学习笔记3(第一章1-5 08~1-7)第一章完结
黑马java学习笔记9(阶段二 第二章2-1)
xiaozhuzhu__的博客
09-04 1005
黑马java学习笔记9(阶段二 第二章2-1)
黑马java学习笔记8(阶段二 第一章 1-6~1-7)第一章完结
xiaozhuzhu__的博客
08-28 803
黑马java学习笔记8(阶段二 第一章 1-6~1-7)第一章完结
黑马java学习笔记6(阶段二 第一章 1-1)
xiaozhuzhu__的博客
08-14 265
黑马java学习笔记6(阶段二 第一章 1-1)
Maven高级-黑马程序员学习笔记
05-21
它可以存储公司内部的库、第三方依赖的镜像，以及发布的项目构件。 1. **安装依赖到私服**：使用`mvn deploy`命令，可以将本地构建的项目上传到私服，供其他项目使用。 2. **配置settings.xml**：在用户的`.m2`目录...
Java学习 - 黑马（第二部分） - 随堂笔记 - 08_常用API
qq_43104872的博客
04-17 2765
Java学习 - 黑马（第二部分） - 随堂笔记 - 08_常用API 1. Math 1.1 Math类概述 Math包含执行基本数字运算的方法 没有构造方法，如何使用类中的成员呢？——通过查看帮助文档 看类的成员是否都是静态的，如果是，通过类名就可以直接调用 1.2 Math类的常用方法 package com.itheima; import jdk.swing.interop.SwingInterOpUtils; /* Math类的常用方法 */ public class Mat
Java学习 - 黑马 - 随堂笔记 - 12_基础知识练习
qq_43104872的博客
04-09 2908
Java学习 - 黑马 - 随堂笔记 - 12_基础知识练习 1. 案例：减肥计划 案例：减肥计划（if） 需求：输入星期数，显示今天的减肥活动 ​ 周一：跑步 ​ 周二：游泳 ​ 周三：慢走 ​ 周四：动感单车 ​ 周五：拳击 ​ 周六：爬山 ​ 周日：好好吃一顿 思路： 键盘录入一个星期数，用一个变量接收 对星期数进行判断，这里用if语句实现 在对应的语句控制中输出对应的减肥活动 package com.itheima; import java.util.Scanner; public clas
Java学习 - 黑马 - 随堂笔记 - 第一部分总目录
qq_43104872的博客
04-17 900
Java学习 - 黑马 - 随堂笔记 - 第一部分总目录 本内容仅为个人看视频记录的随手笔记，部分内容可能不全面，，可以作为学习黑马程序员Java基础视频参考使用或者看完之后进行复习巩固使用。 Java学习 - 黑马 - 随堂笔记 - 01_ Java概述 Java学习 - 黑马 - 随堂笔记 - 02_第一个程序 Java学习 - 黑马 - 随堂笔记 - 03_基础语法 Java学习 - 黑马 - 随堂笔记 - 04_运算符 Java学习 - 黑马 - 随堂笔记 - 05_数据输入 Java学习 - 黑马
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 94
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 554
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 221
BI商业智能：数据可视化、报表可视化系统。
Android系统：系统架构
liufeismart2024的博客
09-23 438
Android的系统结构的设计混合了分层设计和分块设计。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 716
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值