JavaSE基础学习——包装类、正则表达式、Arrays类、选择排序、二分查找、Lambda表达式

已于 2022-04-08 10:36:11 修改
阅读量333 收藏 1
点赞数
文章标签： java idea
于 2022-04-07 14:06:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44018911/article/details/124014524
版权
本文介绍了Java中的包装类，包括自动装箱和拆箱特性，以及如何将基本类型转换为字符串。接着讲解了正则表达式的概念和应用，通过示例展示了如何校验手机号码和邮箱格式。然后探讨了Arrays类在数组操作中的作用，特别是自定义排序规则。最后，简述了Lambda表达式的基本使用和简化规则，展示了如何用Lambda简化匿名内部类的代码形式。
摘要由CSDN通过智能技术生成

1. 包装类

1.1 包装类概述

  • 其实就是8种数据类型对应的引用类型
    在这里插入图片描述
  • Java为了实现一切皆对象，为8种基本类型提供了对应的引用类型。
  • 后面的集合和泛型其实也只能支持包装类型，不支持基本数据类型。

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

1.2 包装类的特有功能

  • 包装类的变量默认值可以是null，容错率更高。
  • 可以把基本类型的数据转换成字符串类型（用处不大）
    在这里插入图片描述
  • 可以把字符串类型的数值转换成真实的数据类型（很有用）
    在这里插入图片描述
/**
    目标：明白包装类的概念，并使用。
 */
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(it);

        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(number);
        double score = Double.valueOf(number1);
        System.out.println(score + 0.1);
    }
}

2. 正则表达式

2.1 正则表达式概述

  • 正则表达式可以用一些规定的字符来制定规则，并用来校验数据格式的合法性。

2.2 正则表达式的匹配规则

在这里插入图片描述
在这里插入图片描述

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 tel = sc.next();
            // 判断电话格式是否正确 027-234823748 027-234823748
            if(tel.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();
            // 判断邮箱格式是否正确 755414220@qq.com
            // 判断邮箱格式是否正确 7554142dad20@163.com
            // 判断邮箱格式是否正确 7554142dad20@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("格式有误！");
            }
        }
    }
}

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

在这里插入图片描述

2.4 正则表达式爬取信息

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

/**
 拓展：正则表达式爬取信息中的内容。(了解)
 */
public class RegexDemo5 {
    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);
        }
    }
}

3. Arrays类

3.1 Arrays类概述

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

3.2 Arrays类的常用API

在这里插入图片描述

3.3 Arrays类对于Comparator比较器的支持

3.3.1 Arrays类的排序方法

在这里插入图片描述

3.3.2 自定义排序规则

  • 设置Comparator接口对应的比较器对象，来定制比较规则。
    在这里插入图片描述
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));
    }
}

4. 选择排序、二分查找

4.1 选择排序

4.1.1 选择排序的思想

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

4.1.2 选择排序的关键

  • 确定总共需要选择几轮：数组的长度 - 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; 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));
    }
}

4.2 二分查找

  • 二分查找正常的检索条件应该是开始位置min <= 结束位置max
/**
    目标：理解二分搜索的原理并实现。
 */
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]) {
                // 往右边找，左位置更新为 = 中间索引 + 1
                left = middleIndex + 1;
            }else if(data < arr[middleIndex]) {
                // 往左边找，右边位置更新为 = 中间索引 - 1
                right = middleIndex - 1;
            }else {
                return middleIndex;
            }
        }
        return -1;//查无此元素
    }
}

5. Lambda表达式

5.1 Lambda概述

  • Lambda表达式是JDK 8开始后的一种新语法形式。
  • 作用：简化匿名内部类的代码写法。

5.2 Lambda表达式的简化格式

在这里插入图片描述
什么是函数式接口？

  • 首先必须是接口、其次接口中有且仅有一个抽象方法的形式
  • 通常我们会在接口上加上一个@FunctionalInterface注解，标记该接口必须是满足函数式接口。
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("老师游泳贼溜~~~~");
            };
        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();
}

5.3 Lambda表达式的省略规则（进一步在Lambda表达式的基础上简化）

  • 参数类型可以省略不写。
  • 如果只有一个参数，参数类型可以省略，同时（）也可以省略。
  • 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写，同时要省略分号！
  • 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省略";"不写
//        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; // 降序
//        });
//        System.out.println(Arrays.toString(ages1));

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

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

//        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("有人点我，点我，点我！！"));
KnightZer0
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java基础，进阶（二）
努力学习ing
10-24 390
java进阶
黑马java学习笔记5 时间类和正则表达式
internetv的博客
12-21 229
黑马java学习笔记5 时间类和正则表达式
Java中的表达式
qq_57689612的博客
10-26 787
java中的表达式，重点是正则表达式和Lambda表达式
Java学习-面向对象进阶二
weixin_46051964的博客
07-20 277
从ava8开始，java.time包提供了新的日期和时间API,主要涉及的类型有LocalDate不包含具体时间的日期。LocalTime不含日期的时间。包含了日期及时间。Instant代表的是时间戳。DateTimeFormatter用于做时间的格式化和解析的Duration用于计算两个“时间”间隔Period用于计算两个“日期”间隔新增的API严格区分了时刻、本地日期、本地时间，并且,对日期和时间进行运算更加方便。正则表达式初体验需求。...
JavaSE基础进阶学习day07
q2524344929的博客
04-10 314
教学视频资源来自 https://www.bilibili.com/video/BV1Cv411372m?p=125&spm_id_from=pageDriver
JavaSe系列二十七: Java正则表达式
07-08
JavaSe系列二十七: Java正则表达式
JavaSE之包装类（基本类型-->包装类）
07-21
这个文件里的内容适合Java初学者，这个文件里边包含的是8基本数据类型的包装类、如何创建包装类以及包装类的使用方法。这也是小编在刚开学学习JavaSE时记录的一些笔记，里面的内容非常适合JavaSE入门者学习，都是...
JavaSE基础全套视频(环境搭建 面向对象 正则表达式 IO流 多线程 网络编程 java10
06-16
课程《Java零基础至高级应用》从基础入门开始进行系统教学，全套课程精细讲解，高级课程超过其他机构30%的课程量，经过我们全套课程系统学习的同学，可轻松从事Java高级工程师或系统架构师岗位，课程提供全套代码...
正则表达式及其应用简介
10-03
### 正则表达式及其应用简介 #### 一、引言 ...以上内容涵盖了正则表达式的基础概念、组成部分以及在不同编程语言中的实际应用，希望能够帮助读者全面地理解正则表达式，并在实际工作中灵活运用。
5. Java集合、API (中)
Buluchacha的博客
12-13 387
Java集合、API5. 包装类6. 正则表达式6.1 概述6.2 匹配规则6.3 常见案例6.4 在方法中的应用6.5 爬取信息7. Arrays类7.1 概述7.2 Arrays类对于Comparator比较器的支持8. Lambda表达式枚举8.1 概述8.2 简化常见函数式接口8.3 省略规则9. 常见算法9.1 冒泡排序9.2 选择排序9.3 二分查找 5. 包装类 public class Test { public static void main(String[] args)
Java使用Arrays.sort()对数组类型排序
qq_45929428的博客
10-28 859
对基本类型数组进行排序 int[] e= {7,1,2,6}; Arrays.sort(e); for(int a:e) { System.out.print(a+" "); } output：1 2 6 7 实现了对基本类型数组的自然序列排序（升序）。 如果要实现降序排序，则要使用包装类： Integer[] integers=new Integer[] {4,8,12,30}; Arrays.sort(integers,new Comparator<Integer>(){ @Overr
day13 日期与时间 包装类 array lambda表达式
weixin_52346838的博客
06-06 115
最近有些事，只能填充了部分内容，后续内容慢慢更新
Java中Arrays.sort自定义一维数组、二维数组的排序（以及出现的问题）
weixin_44915226的博客
04-29 3510
一维数组 方法一： //降序 Arrays.sort(arr, new Comparator<Integer>() { public int compare(Integer a, Integer b) { return b-a; } }); 问题： 可以试着把arr赋值为以下值： 也就是int的边界值 Integer[] arr = {-2147483648, 1, 2147483647}; 代码： Integer[] arr = {-2147483648,
Arrays.sort()自定义排序的实现
weixin_30701521的博客
10-27 2448
1. Arrays.sort(T[] a)是对数组元素按字典序进行升序排列 import java.util.*; public class Main { public static void main(String[] args){ Integer[] arr = {5,4,7,9,2,12,54,21,1}; //升序 ...
通过Arrays.sort()方法对数组进行排序
qq_36138652的博客
07-23 5918
一、Arrays.sort()方法是一种快速排序方法，它合适用于元素少于47个数的排序,具体排序可以参考下面的代码。 二、它可以用于数组的从小到大也可以用于数组的从大到小进行排序，下面讲解一下四种排序的方法。 a) 从小到大排序Arrays.sort(num)。 Integer[] arr = new Integer[]{3,60,2,1,4,55,6,8,47,2,3,5}; Ar...
【Java】包装类 正则表达式 Arrays类 常见算法 泛型
大珍珠
05-31 223
包装类，正则表达式，Arrays类，常见算法，冒泡排序，选择排序，二分查找，Lambda表达式，泛型
正则表达式的介绍及应用
wujianrenn的博客
11-29 1363
一、正则表达式 1.定义：用于定义字符串的内容 2.用途：（1）匹配单个，多个字符串(matches) （2）简化代码，让代码变得更简洁，更优雅 （3）校验信息，包括电话，座机，邮箱 （4）切割字符串，替换字符串 （5）爬取信息中的内容（可以强记忆，死代码）（pattern） 详细介绍： （1）匹配单个，多个字符串(matches) package Regex; /** ...
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 767
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
正则表达式学习资源大全
例如，JavaSE是Java的基础部分，涵盖了类、对象、异常处理、集合框架等内容；而.NET框架下的C#和VB.NET则涉及Windows应用程序开发；对于数据库操作，MySQL、SQL Server和Oracle分别代表了开源、商业和企业级数据库的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值