本文主要是介绍java基础_day13，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

一 正则表达式

1 正则表达式的使用

实现相同的功能， 用String、StringBuffer、StringBuilder可以实现， 用正则表达式也可以
实现。
​
示例代码：
public class Regex1 {
public static void main(String[] args) {
System.out.println(checkWithRegex("123456")); // true
System.out.println(checkWithRegex("1234")); // false
System.out.println(checkWithRegex("1234567890987")); // false
System.out.println(checkWithRegex("123.456")); // false
System.out.println(checkWithRegex("abcdefg")); // false
System.out.println(checkWithRegex("0123456")); // false
}
/**
* 使用正则表达式，验证一个字符串是否是一个合法的QQ号码
* @param str 字符串
* @return 验证的结果
*/
private static boolean checkWithRegex(String str) {
return str.matches("[1-9]\\d{5,10}");
}
/**
* 验证一个字符串是否是一个合法的QQ号码
* @param str 字符串
* @return 验证的结果
*/
private static boolean check(String str) {
// 1. 校验长度
if (str.length() < 6 || str.length() > 11) {
return false;
}
// 2. 校验纯数字组成
try {
Long.parseLong(str);
}
catch (NumberFormatException e) {
// 说明不是纯数字，无法转成long型的变量
return false;
}
// 3. 首字符校验
return str.charAt(0) != '0';
    }
}
​

2 基本的元字符

正则表达式的匹配规则：
逐个字符进行匹配， 判断是否和正则表达式中定义的规则一致。
​
示例代码：
public class Regex2 {
public static void main(String[] args) {
// 校验规则:
System.out.println(",ello".matches("[ahj1,8]ello"));
System.out.println("fello".matches("[a-z]ello"));
// 需求: 首位字符，可以是任意的小写字母，或者是 HAQ
System.out.println("Hello".matches("[Ha-zAQ]ello"));
// 需求: 首位字符，可以是任意的字母，包括大写字母和小写字母
System.out.println("hello".matches("[a-zA-Z]ello"));
// 需求: 首位字符，可以是除了h之外的任意字符
System.out.println("Hello".matches("[^hel]ello"));
// 需求: 首位字符，不可以是任意的小写字母，但是 h、e、q 除外
System.out.println("lello".matches("[^a-z[heq]]ello"));
// 希望首位字符，可以是 h e [
System.out.println("]ello".matches("[he\\[]ello"));
// 希望首位字符，可以是 a - z
System.out.println("hello".matches("[a-z]ello"));
System.out.println("hello".matches("hel+o"));
System.out.println("hello".matches("hel?o"));
System.out.println("heo".matches("hel*o"));
System.out.println("hello".matches("hel{3}o"));
System.out.println("hello".matches("hel{3,}o"));
System.out.println("hello".matches("hel{2,5}o"));
// 需求: 匹配一个字符串可以是 126 或者是 163 或者是 qq 或者是 QQ
System.out.println("123".matches("126|163|qq|QQ"));
// 需求: 匹配一个qq邮箱、126邮箱、163邮箱
System.out.println("admin@sina.com".matches("admin@(qq|126|163)\\.com"));
    }
}

3 . String类中的常用的方法

3.1字符串的匹配

// QQ号的规则：
// 1. 纯数字组成的
// 2. 不能以0作为开头
// 3. 长度在 [6,11]
private static boolean chechQQ(String qqNumber) {
return qqNumber.matches("[1-9]\\d{5,10}");
}
// 验证邮箱的合法性
// 1. 126
// 2. 前半部分可以是任意的单词字符, 长度限制在 [4,12]
// 3. 以.com作为结尾
private static boolean checkEmail(String email) {
return email.matches("\\w{4,12}@126\\.com");
}
​

3.2字符串的切割

private static void split() {
// 需求: 将一个存储有所有的姓名的字符串，切割出每一个名字。
String names = "lily lucy polly Jim LiLei
HanMeimei";
// 实现: 借助字符串的一个方法 split(String regex)
// 将字符串中，满足正则规则的子部分，切割掉
String[] nameArr = names.split(" +");
System.out.println(Arrays.toString(nameArr));
}
​

3.3 字符串的替换

private static void replace() {
// 需求: 将这个存储有所有的名字的字符串，名字之间的分隔用, 来替代
String names = "lily lucy polly Jim LiLei
HanMeimei";
// 实现: 借助字符串中的一个方法 replaceAll(String regex, String
replacement)
// 将字符串中，满足指定正则的部分，替换成 replacement
// String result = names.replaceAll(" +", ", ");
String result = names.replaceFirst(" +", ", ");
System.out.println(result);
}
​
​
private static void example() {
// 需求: 将一个手机号的中间4位替换成 ****
// 17788889999 => 177****9999
String phoneNumber = "17788889999";
// 在replace方法中，使用$1获取第一个分组的值
String result = phoneNumber.replaceAll("(1\\d{2})(\\d{4})(\\d{4})",
"$1****$3");
System.out.println(result);
}

4 Pattern和Matcher类

Pattern类： 在Java中，正则表达式的载体。使用正则表达式进行字符串的校验、切割、替
换，都需要使用到这个类。
在Java中，使用字符串的形式来写正则表达式。此时，如果需要这个字符串被当做是一
个正则表达式使用， 必须先由这样的字符串编译为 Pattern 类的对象。然后才可以使用
这个对象的某些方法， 进行常见的操作（校验、切割、替换）。
Matcher类： 在Java中， 对一个正则校验的结果描述。

4.1 示例代码：

//Pattern 类的使用：
public class Regex1 {
public static void main(String[] args) {
// 1. 静态的校验
boolean ret = Pattern.matches("[1-9]\\d{5,10}", "123456");
System.out.println(ret);
// 2. 将一个字符串编译为正则表达式对象(Pattern对象)
Pattern pattern = Pattern.compile(" +");
// 3. 字符串切割
String[] array1 = pattern.split("Lily Lucy Polly Jim
Tom");
System.out.println(Arrays.toString(array1));
String[] array2 = pattern.split("Lily Lucy Polly Jim
Tom", 0);
System.out.println(Arrays.toString(array2));
    }
}

Matcher:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @Author 千锋大数据教学团队
* @Company 千锋好程序员大数据
* @Date 2020/4/16
* @Description Pattern和Matcher类的综合使用
*/
public class Regex2 {
public static void main(String[] args) {
// 1. 准备一个数据源
String data = "abc123hello world456lily789lucy012uncle111wang";
// 2. 将一个字符串变异成正则对象
Pattern pattern = Pattern.compile("\\d+");
// 3. 使用一个正则和一个字符串进行校验
Matcher matcher = pattern.matcher(data);
// 3.1. 获取整体校验的结果
// 匹配逻辑：
// 从第0个字符开始，判断每一个字符是否否则当前的正则。
// 当找到了有不符合当前正则部分的时候，就会停止继续向后查找，直接返
回false
System.out.println(matcher.matches());
// 3.2. find()
while (matcher.find()) {
System.out.print("匹配到了字符串: " + matcher.group() + ", ");
System.out.println("下标范围: [" + matcher.start() + ", " +
matcher.end() + ")");
}
// 3.3. lookingAt()
System.out.println(matcher.lookingAt() + ", " + matcher.group() +
", [" + matcher.start() + ", " + matcher.end() + ")");
}
}
​

二 lambda表达式

1 Lambda表达式的简介

通常来讲， 使⽤lambda表达式， 是为了简化接⼝实现的。
关于接⼝实现， 可以有很多种⽅式来实现。 例如： 设计接⼝的实现类、 使⽤匿名内部类。 但是lambda表达式， ⽐这两种⽅式都简单。
​
实例代码：
public class Program {
 public static void main(String[] args) {
 // ⽆参、⽆返回值的函数式接⼝
 interfaceImpl();
 }
 private static void interfaceImpl() {
 // 1. 使⽤显式的实现类对象
 SingleReturnSingleParameter parameter1 = new Impl();
 // 2. 使⽤匿名内部类实现
 SingleReturnSingleParameter parameter2 = new
SingleReturnSingleParameter() {
 @Override
 public int test(int a) {
 return a * a;
 }
 };
 // 3. 使⽤lambda表达式实现
 SingleReturnSingleParameter parameter3 = a -> a * a;
 System.out.println(parameter1.test(10));
 System.out.println(parameter2.test(10));
 System.out.println(parameter3.test(10));
 }
 private static class Impl implements
SingleReturnSingleParameter {
 @Override
 public int test(int a) {
 return a * a;
        }
    }
}

2 . Lambda表达式的基础语法

lambda表达式， 其实本质来讲， 就是⼀个匿名函数。 因此在写lambda表达式的时候， 不需要关⼼⽅法名是什么。
实际上， 我们在写lambda表达式的时候， 也不需要关⼼返回值类型。
我们在写lambda表达式的时候， 只需要关注两部分内容即可： 参数列表 和 ⽅法体
​
（参数） -> {
 ⽅法体
}；
​
参数部分 ： ⽅法的参数列表， 要求和实现的接⼝中的⽅法参数部分⼀致， 包括参数的数量和类型。⽅法体部分 ： ⽅法的实现部分， 如果接⼝中定义的⽅法有返回值， 则在实现的时候， 注意返回值的返回。-> : 分隔参数部分和⽅法体部分
​
​
示例代码：
public class Syntax {
 public static void main(String[] args) {
 // 1. ⽆参、⽆返回值的⽅法实现
 NoneReturnNoneParameter lambda1 = () -> {
 System.out.println("⽆参、⽆返回值⽅法的实现");
 };
 lambda1.test();
 // 2. 有参、⽆返回值的⽅法实现
 NoneReturnSingleParameter lambda2 = (int a) -> {
 System.out.println("⼀个参数、⽆返回值⽅法的实现: 参数是
" + a);
 };
 lambda2.test(10);
 // 3. 多个参数、⽆返回值⽅法的实现
 NoneReturnMutipleParameter lambda3 = (int a, int b) -> {
 System.out.println("多个参数、⽆返回值⽅法的实现: 参数a是
" + a + ", 参数b是 " + b);
};
 lambda3.test(10, 20);
 // 4. ⽆参、有返回值的⽅法的实现
 SingleReturnNoneParameter lambda4 = () -> {
 System.out.println("⽆参、有返回值⽅法的实现");
 return 666;
 };
 System.out.println(lambda4.test());
 // 5. ⼀个参数、有返回值的⽅法实现
 SingleReturnSingleParameter lambda5 = (int a) -> {
 System.out.println("⼀个参数、有返回值的⽅法实现: 参数是
" + a);
 return a * a;
 };
 System.out.println(lambda5.test(9));
 // 6. 多个参数、有返回值的⽅法实现
 SingleReturnMutipleParameter lambda6 = (int a, int b) ->
{
 System.out.println("多个参数、有返回值的⽅法实现: 参数a是
" + a + ", 参数b是 " + b);
 return a * b;
 };
 System.out.println(lambda6.test(10, 20));
 }
}

3.Lambda表达式的语法进阶

在上述代码中， 的确可以使⽤lambda表达式实现接⼝， 但是依然不够简洁， 有简化的空间
​
参数的类型：
由于在接⼝的⽅法中，已经定义了每⼀个参数的类型是什么。 ⽽且在使⽤
lambda表达式实现接⼝的时候， 必须要保证参数的数量和类型需要和接⼝中的⽅法保持⼀致。 因此， 此时lambda表达式中的参数的类型可以省略不写。
注意事项：
如果需要省略参数的类型， 要保证： 要省略， 每⼀个参数的类型都必须省略不写。 绝对不能出现， 有的参数类型省略了， 有的参数类型没有省略。
​
// 多个参数、⽆返回值的⽅法实现
NoneReturnMutipleParameter lambda1 = (a, b) -> {
 System.out.println("多个参数、⽆返回值⽅法的实现: 参数a是
" + a + ", 参数b是 " + b);
 };
​

这篇关于java基础_day13的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！