常用API-三

包装类
正则表达式
Arrays类
- Arrays类概述，常用功能演示
- Arrays类对于Comparator比较器的支持
常见算法
- 选择排序
- 二分查找
Lambda表达式

包装类

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

为什么提供包装类

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

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

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

包装类的特有功能

包装类的变量默认是null，容错率更高。
可以把基本类型的数据转换成字符串类型
- 调用toString()方法得到字符串结果
- 调用Integer.toString(基本类型的数据)。
可以把字符串类型的数值转换成真实的数据类型
- Integer.parselnt("字符串类型的整数")
- Double.parseDouble("字符串类型的小数")

public class IntegerDemo1 {
    public static void main(String[] args) {
        int a = 10;
        Integer a1 = a;
        int a2 = a1;

        String s = Integer.toString(a2);
        System.out.println(s + 1);
        Integer a3 = a;
        String s1 = a3.toString();
        System.out.println(s1 + 2);

        //可以直接+字符串得到字符串类型
        String rs = a2 + "";
        System.out.println(rs + 34);

        System.out.println("---------------");
        //转换成整数
        String number = "123";
        //int age = Integer.parseInt(number);
        int age = Integer.valueOf(number);
        System.out.println(age + 2);

        String num2 = "99.9";
        double age2 = Double.valueOf(num2);
        System.out.println(age2 + 0.1);
    }
}
output:
101
102
1034
---------------
125
100.0

正则表达式

正则表示

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

正则表达式初体验

需求：假如现在要求校验一个qq号码是否正确，6-20位之内，必须全部是数字

package com.csl.d6_regex;

public class RegexDemo {
    public static void main(String[] args) {
        System.out.println(checkQQ("1345648"));
        System.out.println(checkQQ("null"));
        System.out.println(checkQQ("15s3a45"));

        System.out.println("--------------");
        System.out.println(checkQQ2("1345648"));
        System.out.println(checkQQ2("null"));
        System.out.println(checkQQ2("15s3a45"));

    }
    /*
    	正则表达式初体验
    */
    public static boolean checkQQ2(String qq){
        return qq != null && qq.matches("\\d{6,20}");
    }

    public static boolean checkQQ(String qq) {
        if (qq == null || qq.length() < 6 || qq.length() > 20) {
            return false;
        }
        for (int i = 0; i < qq.length(); i++) {
            //获取每位字符
            char ch = qq.charAt(i);
            // 判断这个字符是否不是数字，不是数字直接返回false
            if (ch < '0' || ch > '9') {
                return false;
            }
        }
        return true;
    }
}
output:
true
false
false
--------------
true
false
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`, or `f`(intersection)
`[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]`
`\h`	水平空白字符： `[ \t\xA0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000]`
`\H`	非水平空白字符： `[^\h]`
`\s`	空白字符： `[ \t\n\x0B\f\r]`
`\S`	非空白字符： `[^\s]`
`\v`	垂直空白字符： `[\n\x0B\f\r\x85\u2028\u2029]`
`\V`	非垂直空白字符： `[^\v]`
`\w`	一个字字符： `[a-zA-Z_0-9]`
`\W`	非单词字符： `[^\w]`

贪心量词(配合匹配多个字符)

X`?`	X，一次或一次
X`*`	X , 零次或多次
X`+`	X , 一次或多次
X `{`n`}`	X , 正好n次
X `{`n`,` }	X，至少n次
X `{`Ñ`,`米`}`	X，至少n 次但不超过m次

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

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

正则表达式的常见案例

案例：请使用正则表达式完成如下需求：

需求：

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

分析：

定义方法，接收用户输入的数据，使用正则表达式完成校验，并给出提示。

package com.csl.d6_regex;

import java.util.Scanner;

public class RegexTest {
    public static void main(String[] args) {
        //checkPhone();
        //checkEmail();
        checkTel();
    }
    public static void checkTel(){
        //判断电话格式是否正确    021-456468  021165468


        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入你的电话号：");
            String tel = sc.next();
            if (tel.matches("0\\d{2,6}-?\\d{5,20}")){
                System.out.println("电话正确，完成注册！");
                break;
            }else {
                System.out.println("电话错误，请重新输入！");
            }
        }
    }
    public static void checkEmail(){
        //判断邮箱格式是否正确    546544654@qq.com
        //判断邮箱格式是否正确    54654465adg4@163.com
        //判断邮箱格式是否正确    5465dg4465ga4@pci.com.cn

        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("手机号码格式错误，请重新输入！");
            }
        }
    }
}
output:
请输入你的电话号：
021-54657468
电话正确，完成注册！

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

方法名	说明
public String replace(String regex,String newStr)	按照正则表达式匹配的内容进行替换
public String[] split(string regex)	按照正则表达式匹配的内容进行分割字符串，返回一个字符串数组

public class RegexDemo02 {
    public static void main(String[] args) {
        String name = "婷儿agahg121sdg龙哥j32ho2h小白";
        String[] arr = name.split("\\w+");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("------------");
        String name2 = name.replaceAll("\\w+", "  ");
        System.out.println(name2);
    }
}
output:
婷儿
龙哥
小白
------------
婷儿  龙哥  小白

正则表达式爬取信息

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

public class RegexDemo03 {
    public static void main(String[] args) {
        String rs = "开始爬取一些信息，Java，电话020-3819982;手机号码：13298892482，" +
                "邮箱是23433@cs.com,400-85921-384,4002384298" +
                "itsal@csl.cn,18840020302,13377777777";

        //需求：从上面的内容中爬取出，电话号码和邮箱
        //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 group = matcher.group();
            System.out.println(group);
        }
    }
}
output:
020-3819982
13298892482
23433@cs.com
400-85921-384
4002384298itsal@csl.cn
18840020302
13377777777

Arrays类

Arrays类概述，常用功能演示

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

Arrays类的常用API

方法名	说明
public static String toString(类型[] a)	对数组进行排序
public static void sort(类型[] a)	对数组进行默认升序排序
public static void sort(类型[] a，Comparator<? super T> c)	使用比较器对象自定义排序
public static int binarySearch(int[] a,int key)	二分搜索数组中的数据，存在返回索引，不存在返回-1

Arrays类对于Comparator比较器的支持

Arrays类的排序方法

方法名	说明
public static void sort(类型[] a)	对数组默认进行升序排序
public static void sort(类型[] a,Comparator<? super T> c)	使用比较器对象自定义排序

自定义排序规则

设置Comparator接口对应的比较器对象，来定制比较规则
- 如果认为左边数据大于右边数据返回正整数
- 如果认为左边数据小于右边数据返回负整数
- 如果认为左边数据等于右边数据返回0

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

public class ArraysDemo02 {
    public static void main(String[] args) {
        //1.Arrays的sort方法默认是升序排序
        int[] arr = {33, 12, 26, 9};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        //2.需求：降序排序(自定义比较器对象，只能支持引用类型的排序）
        Integer[] arr1 = {33, 12, 26, 9};
        Arrays.sort(arr1, 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 o2 - o1;//降序
            }
        });
        System.out.println(Arrays.toString(arr1));
        Student[] students = new Student[3];
        students[0] = new Student("张三", 22, 177.5);
        students[1] = new Student("李四", 19, 195.5);
        students[2] = new Student("王五", 20, 187.5);
        System.out.println(Arrays.toString(students));
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // return o1.getAge() - o2.getAge();
                return Double.compare(o1.getHeight(), o2.getHeight());//比较浮点数可以这样写，升序
            }
        });
        System.out.println(Arrays.toString(students));
    }
}
output:
[9, 12, 26, 33]
[33, 26, 12, 9]
[Student{name='张三', age=22, height=177.5}, Student{name='李四', age=19, height=195.5}, Student{name='王五', age=20, height=187.5}]
[Student{name='张三', age=22, height=177.5}, Student{name='王五', age=20, height=187.5}, Student{name='李四', age=19, height=195.5}]

常见算法

选择排序

选择排序的思想

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

选择排序的关键

确定总共需要几轮：数组的长度-1
控制每轮从以前位置为基准，与后面元素选择几次

package com.csl.d8_binarysearch;

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.lenth-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));
    }
}
output:
[1, 2, 3, 5]

二分查找

package com.csl.arrays;

import java.util.Arrays;

public class ArraysDemo03 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {12, 15, 22, 25, 33, 35, 40, 44, 66};
        System.out.println(binarySearch(arr, 33));
        System.out.println(binarySearch(arr, 333));

    }

    /**
     * 二分查找算法的实现
     *
     * @param arr  排序的数组
     * @param data 要查找的元素
     * @return 索引, 如果索引不存在，返回-1
     */
    public static int binarySearch(int[] arr, int data) {
        int left = 0;
        int right = arr.length - 1;

        while (left <= right) {
            //取中间索引
            int middleIndex = (left + right) / 2;
            if (data > arr[middleIndex]) {
                //往右边找，左位置更新为：中间索引+1
                left = middleIndex + 1;
            } else if (data < arr[middleIndex]) {
                // 往左边找， 右边位置=中间索引 -1
                right = middleIndex - 1;
            } else {
                return middleIndex;
            }
        }
        return -1;//查无此元素
    }
}
output:
4
-1

数组的二分查找的实现步骤是什么样的？

定义变量记录左边和右边位置。
使用while循环控制查询（条件是左边位置<=右边位置）
循环内部获得中间元素索引
判断当前要找的元素如果大于中间元素，左边位置=中间索引+1
判断当前要找的元素如果小于中间元素，右边位置= 中间索引-1
判断当前要找的元素如果等于中间元素，返回当前中间元素的索引。

Lambda表达式

Lambda概述

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

Lambda表达式的简化格式

（匿名内部类被重写方法的形参列表）-> {
    被重写方法的方法体代码。
}
注： ->是语法形式，无实际含义

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

什么是函数接口？

首先必须是接口、其次接口中有且仅有一个抽象方法的形式
通常我们会在接口上加上一个@FuctionnalInterface注解，标记这个接口必须满足函数式接口。

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

Lambda表达式的省略规则

参数类型可以省略不写
如果只有一个参数，参数类型可以省略，同时()也可以省略
如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写，同时要省略分号！
如果Lambda表达式的方法体代码只有一行代码，可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省略";"不写

posted @ 2022-01-12 22:08 tryAgainCs 阅读(57) 评论(0) 编辑收藏举报

刷新页面返回顶部

再试一次Again