Lambda表达式
Lambda表达式主要用于替换函数式接口，对于匿名内部类的写法可以进行极限简化，去掉冗余代码
Lambda固定写法 “ -> ”左侧为形式参数，右侧为代码块（将要执行的方法体）
/*
(匿名内部类被重写方法的形参列表) -> {
被重写方法的方法体
}
Lambda表达式只能简化函数式接口
极限省略规则：
1. 如果lambda表达式方法体只有一行，可以省略大括号不写，同时省略分号
2. 根据1：如果这行式return语句，则return必须省略，分号也要省略
3. 参数类型可以省略不写
4. 如果只有一个参数，参数类型可以忽略，()也可以忽略
*/
函数式接口
- 函数式接口是指该接口中只有一个抽象方法的接口，在函数式接口上会标有注解–> @FuntionalInterFace
//如下为函数式接口
@FunctionalInterface
public interface InterfaceA {
//函数式接口- - - - - -> 注解FunctionalInterface，只包含一个抽象方法的接口
void run();
}
Lambda简化Runnable创建线程
public class Demo {
public static void main(String[] args) {
//Runnable - - ->FunctionnalInterface函数式接口
//Runnable接口创建线程的Lambda写法
Thread t = new Thread(() -> { System.out.println(Thread.currentThread().getName()+"线程执行~~~");
});
t.start();
//继续简化:同样是Runnable接口方式
new Thread(() -> { System.out.println(Thread.currentThread().getName()+"执行~~~");
});
//极限简化：省略大括号，三行变一行
new Thread(() -> System.out.println(Thread.currentThread().getName()+"执行~~~"));
/*
理解如：
Thread类提供了专门存放Runnable对象作为形参的构造器
源码如下：
public Thread(Runnable target)
尽管在上述Lambda写法中并未出现Runnable关键字但是Java会自动识别这是Runnable对象
又因为：Runnable只有一个抽象方法
所以Java会自动判断出来执行run方法
*/
}
}
Lambda简化Comparator比较器
public class Student {
private String name;
private int age;
private char sex;
public Student() {
}
public Student(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
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 char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || this.getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && sex == student.sex && name.equals(student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age, sex);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
'}';
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Demoo {
public static void main(String[] args) {
List<Student> lists = new ArrayList<>();
Student stu1 = new Student("玩家1", 17, '男');
Student stu2 = new Student("玩家2", 21, '女');
Student stu3 = new Student("玩家3", 15, '男');
Collections.addAll(lists,stu1,stu2,stu3);
/*
public static <T> boolean addAll(Collection<? super T> c, T... elements)
可变参数，直接将数据全部存入
*/
//下面按照年龄升序排序----->匿名内部类写法
/*Collections.sort(lists, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()-o2.getAge();
}
});*/
//Lambda表达式写法
Collections.sort(lists,(Student o1, Student o2) -> {
return o1.getAge()-o2.getAge();
});
//极限Lambda写法：如果方法体只有一行，如果是return，则return必须省略不写、参数类型也可以省略不写
Collections.sort(lists,(o1, o2) -> o1.getAge() - o2.getAge());
for (Student list : lists) {
System.out.println(list);
}
}
}
使用Lambda表达式遍历集合
public static void main(String[] args) {
Map<String, Integer> maps = new HashMap<>();
//Lambda表达式遍历Map集合
maps.forEach((k,v) -> System.out.println("key="+k+",value="+v));
Set<Integer> sets = new TreeSet<>();
//Lambda表达式遍历Set集合
sets.forEach(set -> System.out.println("set="+set));
//Lambda表达式遍历List集合
List<Integer> lists = new ArrayList<>();
lists.forEach(list -> System.out.println("list="+list));
}
正则表达式
用于描述或匹配一系列符合某个语句规则的字符串
单个符号
- 英文句点
.用于匹配任意单个字符- 表达式：
t.t可以用于匹配txt、tet等
- 表达式：
- 中括号
[]只有中括号内指定的字符才能参与匹配，也只能匹配单个字符- 表达式：
p[1234]p可以用于匹配p2p、p4p等
- 表达式：
|符号，表示“ 或 ”- 表达式a[tt|pp|cc]x可用于匹配attx、appx等
- 转义符
\，许多字符在正则表达式中有特殊含义所以通常在其之前加上\进行转义- \ \d表示单个数字字符（0-9）
^表示“ 否 ” 如[ ^ p] 表示第一个字符不能是字母p
快捷符号
- \d表示[0-9]
- \D表示[ ^0-9]
- \w表示[0-9A-Za-z]
- \W表示[ ^0-9A-Za-z]
表示次数的符号
| 符号 | 次数 |
|---|---|
| * | 0次或多次 |
| + | 1次或多次 |
| ？ | 0次或1次 |
| { n } | 恰好n次 |
| {n , } | 至少n次 |
| {n , m} | 至少n次，但是不超过m次 |
实例
public class Demoo {
public static void main(String[] args) {
String qqNum = "20729a8458";
System.out.println(checkqq(qqNum));
System.out.println("a".matches("[abc]"));
System.out.println("a".matches("[^abc]"));
System.out.println("1".matches("\\d"));//true
System.out.println("12".matches("\\d"));//false
System.out.println("a".matches("\\d"));//false
System.out.println("a".matches("\\w"));//true
System.out.println("2".matches("\\w"));//true
System.out.println("我".matches("\\w"));//false
System.out.println("A".matches("\\w"));//false
/*
仅能校验单个字符
两个\\的原因是：第一个\要告诉第二个\“你就是个\”
\\d只能是单个字符的数字
\\D--->校验非数字
\\w只能是单个字符的数字或者大小写字母(包含了下划线)
*/
/*
数量词判断
x? x ----> 一次或一次也没有
x* x ----> 零次或多次
x+ x ----> 一次或多次
x{n} x ----> 恰好n次
x{n,} x ----> 至少n次
x{n,m} x ----> 至少n次,但是不超过m次
*/
/*核验密码*/
System.out.println("asd1￥23".matches("\\w{6,12}"));
/*核验验证码，不包含下划线*/
System.out.println("asd2".matches("[a-zA-Z0-9]{4}"));
System.out.println("=================================");
/*核验邮箱*/
String ema = "207yuqu@163.com";
String ema1 = "2072988458@163.com.cn";
String ema2 = "207yuqu@qq.com";
System.out.println(checkEmail(ema));
System.out.println(checkEmail(ema1));
System.out.println(checkEmail(ema2));
System.out.println("=============================");
/*核验手机号*/
String tel1 = "13523025288";
String tel2 = "18736089926";
System.out.println(checkTel(tel1));
System.out.println(checkTel(tel2));
}
private static boolean checkTel(String tel) {
return tel.matches("[01][35789]\\d{9,}");
}
private static boolean checkEmail(String ema) {
return ema.matches("\\w{3,15}@\\w{2,12}(\\.\\w{2,10}){1,2}");
}
private static boolean checkqq(String qqNum) {
//\\d判断是否纯数字，{}单值长度，双值表示长度范围
return qqNum != null && qqNum.matches("\\d{4,}");
//x{n,} --代表--> x至少出现n次 在此处表示数字至少有四个
}
}
838
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
