基础知识
正则
-
判断是否符合正则规则
需要匹配的内容.matches("正则规则"); -
从正则规则中爬出指定数据
// 获取匹配规则对象 Pattern patther = Pattern.complie("正则规则"); // 从匹配规则对象中获取匹配器对象 Mather mather = patter.mather("需要匹配的内容"); // 查找 while(mather.find()) { mather.group(); }
/**
* @Program: basic
* @Description: 正则表达式
* @Author Mokairui
* @Date 2021/4/3 16:14
*/
public class RegexDemo {
/**
* 字符类
* [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&&[def233]] d,e或f 交集
* [a-z&&[^bc]] a到z，除了b和c [ad-z]
* [a-z&&[^m-p]] a到z，除了m到p [a-lq-z]
* 预定符
* . 任意字符
* \d 数字
* \D 非数字
* \s 空白字符
* \S 非空白字符
* \w 单词字符 [a-zA-Z_0-9]
* \W 非单词字符
* 以上正则匹配只能检验单个字符
* 数量词
* ? 0到1次
* + 1到多次
* * 0到多次
*
* @param args
*/
public static void main(String[] args) {
getMatches("123456as34drf35");
}
/**
* matches 需要校验的内容.mathes(正则规则)
* 匹配是否符合规则
* @param qq 需要校验的内容
* @return boolean
*/
public static boolean checkQQ(String qq) {
return qq != null && qq.matches("\\d{4,}");
}
/**
* 通过匹配器爬取指定规则的内容
* @param msg
* @return
*/
public static void getMatches(String msg) {
// 1.定义正则规则
String regex = "\\d{1,}";
// 2.编译正则表达式成为一个匹配规则对象
Pattern pattern = Pattern.compile(regex);
// 3.通过匹配规则对象得到一个匹配数据内容得匹配器对象
Matcher matcher = pattern.matcher(msg);
// 4.通过匹配器去内容中爬出信息
while (matcher.find()) {
System.out.println(matcher.group());
}
}
}
JDK1.8新特性
stream 流
-
Stream流式思想的核心
是先得到集合或数组的Stream流（就是一根传送带）
然后就用这个Stream流操作集合或则数组的元素
然后用Stream流简化替代集合操作的API获取流的API 集合获取流的API default Stream<E> stream(); 小结： 集合获取Stream流用 Stream() 数组：Arrays.stream(数组) / Stream.of(数组) -
Stream流常用API
forEach:遍历
count：统计个数
-- long count()
filter：过滤元素
-- Streamfilter(Predicate<? super T> predicate
limit：提取几个元素 就是要前面的
skip：跳过前面几个 就是要后面的
map：加工方法
concat：合并流 collect:收集，通过Collectors的方法将其可以设置为对应的集合
/**
* @Program: basic
* @Description: stream流的使用 用来解决集合和数组之间api不好用的情况
* @Author Mokairui
* @Date 2021/4/3 16:10
*/
public class StreamDemo {
public static void main(String[] args) {
makeStream();
}
/**
* Stream流式思想的核心
* 是先得到集合或数组的Stream流（就是一根传送带）
* 然后就用这个Stream流操作集合或则数组的元素
* 然后用Stream流简化替代集合操作的API
*
* 获取流的API
* 集合获取流的API
* default Stream<E> stream();
*
* 小结：
* 集合获取Stream流用 Stream()
* 数组：Arrays.stream(数组) / Stream.of(数组)
*/
public static void getStream() {
/** --------------------Collection集合获取流------------- */
Collection<String> c = new ArrayList<>();
Stream<String> stream = c.stream();
/** --------------------Map集合获取流-------------- */
Map<String, Integer> map = new HashMap<>();
// 获取键的Stream流
Stream<String> keyStream = map.keySet().stream();
// 获取值的Stream流
Stream<Integer> valueStream = map.values().stream();
// 获取键值对的Stream流
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
/** --------------------数组获取流-------------- */
String[] arr = new String[]{"Java", "JavaEE", "JavaScript"};
// 参数为可变参数
Stream<String> stringStream = Stream.of(arr);
// 获取数组的
Stream<String> arrStream = Arrays.stream(arr);
}
/**
* Stream流常用API
* forEach:遍历
* count：统计个数
* -- long count()
* filter：过滤元素
* -- Stream<T> filter(Predicate<? super T> predicate
* limit：提取几个元素 就是要前面的
* skip：跳过前面几个 就是要后面的
* map：加工方法
* concat：合并流
*/
public static void makeStream() {
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
// 张无忌, 张三丰
list.stream().filter(s -> s.length() == 3).filter(s -> s.startsWith("张"))
.forEach(System.out::println);
// 莫铠瑞:张无忌, 莫铠瑞:周芷若, 莫铠瑞:赵敏, 莫铠瑞:张强, 莫铠瑞:张三丰
list.stream().map(s -> "莫铠瑞:" + s).forEach(System.out::println);
// 将名字加工为学生对象
list.stream().map(s -> new Student(s)).forEach(System.out::println);
list.stream().map(Student::new).forEach(System.out::println);
// 合并流
Stream<Integer> s1 = Stream.of(10, 20, 30, 40, 50);
Stream<String> s2 = list.stream();
Stream<Object> concat = Stream.concat(s1, s2);
concat.forEach(System.out::println);
// 将Stream流转换为Set集合
list.stream().collect(Collectors.toSet());
// 将Stream流转换为List集合
list.stream().collect(Collectors.toList());
// 将Stream流转换表为
Object[] objects = list.stream().toArray();
String[] strings = list.stream().toArray(String[]::new);
}
}
class Student {
private String name;
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}
Optional
public class OptionalDemo {
/**
* Optional有三种创建方式：
* empty() 创建一个空的
* of() 将一个对象转换为Optional类型
* ofNullable() 同上，区别就是这个可以放空对象，上面如果放空对象，会报空指针异常,而这个是在调用时报异常
*/
@Test
public void method01() {
User user = null;
Optional<User> empty = Optional.empty();
Optional<User> ofUser = Optional.of(user); // java.lang.NullPointerException
Optional<User> ofNullableUser = Optional.ofNullable(user);
empty.get(); // java.util.NoSuchElementException
ofNullableUser.get(); // java.util.NoSuchElementException
}
/**
* 常用API，一般使用ofNullable可以存放空对象，有判断是否为空的API
* isPresent() 判断对象里的值是否为空如果为空返回true，非空false
* ifPresent(Consumer消费者) 定义一个消费者,如果传入的参数不为空，那么就执行里面的表达式
*
* orElse(返回一个默认对象) 如果前面的对象为空，返回这个默认对象，注意返回值是你定义的对象类，上面的两种返回类型是Optional
* orElseGet(Supplier) 效果同上，区别：如果对象不为空，上面也会执行表达式中的内容，而此方法是不会执行的
*
* map() 将返回的值包装在 Optional 中
* flatmap() 解开Optional的包装直接获取值，就是可能属性会是Optional这个时候要直接获取泛型里面的类型的值就是使用这个解开封装
*
* filter(Predicate) 过滤器返回的结果是true的值，如果测试结果是false就返回一个空对象
*/
@Test
public void method02() {
User user = new User("zhangsan", "123@163.com");
Optional<User> opt = Optional.ofNullable(user);
System.out.println(opt.isPresent()); // true , 空为ture
// 只有user不为null的时候才会执行断言
opt.ifPresent(u -> assertEquals(user.getEmail(), u.getEmail()));
User emptyUser = null;
User userOpt = Optional.ofNullable(emptyUser).orElse(user);
User userOpt2 = Optional.ofNullable(emptyUser).orElseGet(() -> user);
// 指定报错的异常，在这里如果user为空就会抛出 IllegalArgumentException 这个异常
Optional.ofNullable(user).orElseThrow(() -> new IllegalArgumentException());
// map就是将值封装为Optional，这样我们就可以实现链式编程，flatmap就是解除这个封装
String email = Optional.ofNullable(user).map(u -> u.getEmail()).orElse("default@gmail.com");
// filter过滤器返回的是表达式为true的对象的值，false的话就是返回一个空的对象
Optional<User> result = Optional.ofNullable(user)
.filter(u -> u.getEmail() != null && u.getEmail().contains("@"));
}
}
class User {
private String name;
private String email;
public User() {
}
public User(String name, String email) {
this.name = name;
this.email = email;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
Optional
public class OptionalDemo {
/**
* Optional有三种创建方式：
* empty() 创建一个空的
* of() 将一个对象转换为Optional类型
* ofNullable() 同上，区别就是这个可以放空对象，上面如果放空对象，会报空指针异常,而这个是在调用时报异常
*/
@Test
public void method01() {
User user = null;
Optional<User> empty = Optional.empty();
Optional<User> ofUser = Optional.of(user); // java.lang.NullPointerException
Optional<User> ofNullableUser = Optional.ofNullable(user);
empty.get(); // java.util.NoSuchElementException
ofNullableUser.get(); // java.util.NoSuchElementException
}
/**
* 常用API，一般使用ofNullable可以存放空对象，有判断是否为空的API
* isPresent() 判断对象里的值是否为空如果为空返回true，非空false
* ifPresent(Consumer消费者) 定义一个消费者,如果传入的参数不为空，那么就执行里面的表达式
*
* orElse(返回一个默认对象) 如果前面的对象为空，返回这个默认对象，注意返回值是你定义的对象类，上面的两种返回类型是Optional
* orElseGet(Supplier) 效果同上，区别：如果对象不为空，上面也会执行表达式中的内容，而此方法是不会执行的
*
* map() 将返回的值包装在 Optional 中
* flatmap() 解开Optional的包装直接获取值，就是可能属性会是Optional这个时候要直接获取泛型里面的类型的值就是使用这个解开封装
*
* filter(Predicate) 过滤器返回的结果是true的值，如果测试结果是false就返回一个空对象
*/
@Test
public void method02() {
User user = new User("zhangsan", "123@163.com");
Optional<User> opt = Optional.ofNullable(user);
System.out.println(opt.isPresent()); // true , 空为ture
// 只有user不为null的时候才会执行断言
opt.ifPresent(u -> assertEquals(user.getEmail(), u.getEmail()));
User emptyUser = null;
User userOpt = Optional.ofNullable(emptyUser).orElse(user);
User userOpt2 = Optional.ofNullable(emptyUser).orElseGet(() -> user);
// 指定报错的异常，在这里如果user为空就会抛出 IllegalArgumentException 这个异常
Optional.ofNullable(user).orElseThrow(() -> new IllegalArgumentException());
// map就是将值封装为Optional，这样我们就可以实现链式编程，flatmap就是解除这个封装
String email = Optional.ofNullable(user).map(u -> u.getEmail()).orElse("default@gmail.com");
// filter过滤器返回的是表达式为true的对象的值，false的话就是返回一个空的对象
Optional<User> result = Optional.ofNullable(user)
.filter(u -> u.getEmail() != null && u.getEmail().contains("@"));
}
}
class User {
private String name;
private String email;
public User() {
}
public User(String name, String email) {
this.name = name;
this.email = email;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
浙公网安备 33010602011771号