登山则情满于山，观海则意溢于海。
--南朝梁·刘勰《文心雕龙》
一、枚举
使用枚举的条件
1. 创建枚举类的属性(成员变量)，必须是作为私有常量出现
2. 必须将构造方法私有化，这是为了保证类的对象是有限个的目的
3. 提供公共的静态的final方法给外界获取枚举类中多个对象
4. 提供公共的获取属性的方法
5. 重写toString()方法
package day22;
/*
1. 创建枚举类的属性(成员变量)，必须是作为私有常量出现
2. 必须将构造方法私有化，这是为了保证类的对象是有限个的目的
3. 提供公共的静态的final方法给外界获取枚举类中多个对象
4. 提供公共的获取属性的方法
5. 重写toString()方法
*/
class Season{
private String name;
private String describe;
private Season(){}
private Season(String name,String describe){
this.name = name;
this.describe = describe;
}
public static final Season SPRING = new Season("春天","春暖花开");
public static final Season SUMMER = new Season("夏天","夏日炎炎");
public static final Season AUTUMN = new Season("秋天","硕果累累");
public static final Season WINTER = new Season("冬天","万里雪疆");
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescribe() {
return describe;
}
public void setDescribe(String describe) {
this.describe = describe;
}
@Override
public String toString() {
return "Season{" +
"name='" + name + '\'' +
", describe='" + describe + '\'' +
'}';
}
}
public class EnumDemo1 {
public static void main(String[] args) {
Season summer = Season.SUMMER;
System.out.println(summer.getName());
System.out.println(summer.getDescribe());
}
}上述代码是我们正常的思路所写的，虽然没有错，但是存在大量的重复工作，极大的减少了我们工作的效率，Java专门为这种重复的工作提供了一个方法就是enum方法。
package day22;
/*
在jdk1.5之后，java提供了一关键词，可以描述一个枚举类 enum
1. 将枚举相关的对象放在开头
SPRING("春天", "春暖花开")
2. 创建枚举类的属性(成员遍历)，必须是作为私有常量出现
3. 必须将构造方法私有化，这是为了保证类的对象是有限个的目的
4. 提供公共的获取属性的方法
5. 重写toString()方法
*/
enum Season2{
//表示有限个对象，必须放在枚举类第一个部分
SPRING ("春天","春暖花开"),
SUMMER ("夏天","夏日炎炎"),
AUTUMN ("秋天","硕果累累"),
WINTER ("冬天","万里雪疆");
private String name;
private String describe;
private Season2(){}
private Season2(String name,String describe){
this.name = name;
this.describe = describe;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescribe() {
return describe;
}
public void setDescribe(String describe) {
this.describe = describe;
}
@Override
public String toString() {
return "Season{" +
"name='" + name + '\'' +
", describe='" + describe + '\'' +
'}';
}
}
public class EnumDemo2 {
public static void main(String[] args) {
Season2 spring = Season2.SPRING;
Season2 summer = Season2.SUMMER;
System.out.println(spring);
System.out.println(summer);
}
}
二、lambda
（1）介绍：
从JDK1.8开始为了简化使用者进行代码开发，专门提供有Lambda表达式的支持，利用此操作形式可以实现函数式的编程，对于函数式编程比较著名的语言：Scala，利用函数式的编程可以避免掉面向对象编程之中的一些繁琐的问题。 面向对象在其长期发展的过程中一直有一部分的反对者认为面向对象过于繁琐。
lambda表达式是一把双刃剑。（极度简洁，但是不便于理解和修改）
（2）写Lamdba表达式的场景
- 能够使用 Lambda 表达式的一个重要依据是必须有相应的函数接口。所谓函数接口，是指内部有且仅有一个抽象方法的接口。
- Lambda 表达式的另一个依据是类型推断机制。在上下文信息足够的情况下，编译器可以推断出参数列表的类型，而不需要显式指名。
（3）案例
案例1：
现在有一个存储员工的集合，员工id、name、age、salary
需求1：过滤出年龄是大于18岁的，返回新的集合
需求2：过滤出薪资是大于10000块的，放回新的集合
接口Confition
package day21.lambdademo2;
public interface Condition {
boolean filter(Staff staff);
}判断年龄的方法类
package day21.lambdademo2;
public class FilterStaffWithAge implements Condition{
@Override
public boolean filter(Staff staff) {
return staff.getAge()>18;
}
}判断工资的方法类
package day21.lambdademo2;
public class FilterStaffWithSalary implements Condition{
@Override
public boolean filter(Staff staff) {
return staff.getSalary()>10000;
}
}员工类
package day21.lambdademo2;
public class Staff {
private String id;
private String name;
private int age;
private int salary;
public Staff() {
}
public Staff(String id, String name, int age, int salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
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 int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Staff{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
'}';
}
}测试类
package day21.lambdademo2;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/*
案例1：
现在有一个存储员工的集合，员工id、name、age、salary
需求1：过滤出年龄是大于18岁的，返回新的集合
需求2：过滤出薪资是大于10000块的，放回新的集合
*/
public class StaffDemo1 {
private static List<Staff> staffArrays = Arrays.asList(
new Staff("1001","张三",19,11000),
new Staff("1002","李四",18,12000),
new Staff("1003","王五",15,7500),
new Staff("1004","赵六",16,8000),
new Staff("1005","孙七",29,40000)
);
public static void main(String[] args) {
//调用方法进行过滤
List<Staff> staffList1 = filterStaff(staffArrays,new FilterStaffWithAge());
for(Staff staff : staffList1){
System.out.println(staff);
}
System.out.println("=======================================");
List<Staff> staffList2 = filterStaff(staffArrays,new FilterStaffWithSalary());
for(Staff staff : staffList2){
System.out.println(staff);
}
}
public static List<Staff> filterStaff(List<Staff> stafflist,Condition condition){
ArrayList<Staff> list = new ArrayList<>();
for(Staff staff : stafflist){
if(condition.filter(staff)){
list.add(staff);
}
}
return list;
}
}改进案例（使用匿名内部类进行改进）
接口类：
package day21.lambdademo3;
public interface Condition {
boolean filter(Staff staff);
}员工类：
package day21.lambdademo3;
public class Staff {
private String id;
private String name;
private int age;
private int salary;
public Staff() {
}
public Staff(String id, String name, int age, int salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
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 int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Staff{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
'}';
}
}测试类：
package day21.lambdademo3;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/*
案例3：使用匿名内部类进行改进
现在有一个存储员工的集合，员工id、name、age、salary
需求1：过滤出年龄是大于18岁的，返回新的集合
需求2：过滤出薪资是大于10000块的，放回新的集合
*/
public class StaffDemo1 {
private static List<Staff> staffArrays = Arrays.asList(
new Staff("1001","张三",19,11000),
new Staff("1002","李四",18,12000),
new Staff("1003","王五",15,7500),
new Staff("1004","赵六",16,8000),
new Staff("1005","孙七",29,40000)
);
public static void main(String[] args) {
//调用方法进行过滤
List<Staff> staffList1 = filterStaff(staffArrays, new Condition() {
@Override
public boolean filter(Staff staff) {
return staff.getAge()>18;
}
});
for(Staff staff : staffList1){
System.out.println(staff);
}
System.out.println("=======================================");
List<Staff> staffList2 = filterStaff(staffArrays, new Condition() {
@Override
public boolean filter(Staff staff) {
return staff.getSalary()>10000;
}
});
for(Staff staff : staffList2){
System.out.println(staff);
}
}
public static List<Staff> filterStaff(List<Staff> stafflist, Condition condition){
ArrayList<Staff> list = new ArrayList<>();
for(Staff staff : stafflist){
if(condition.filter(staff)){
list.add(staff);
}
}
return list;
}
}再次改进（使用lambda表达式来写）
接口类和员工类同上
测试类：
package day21.lambdademo4;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/*
案例3：使用匿名内部类进行改进
现在有一个存储员工的集合，员工id、name、age、salary
需求1：过滤出年龄是大于18岁的，返回新的集合
需求2：过滤出薪资是大于10000块的，放回新的集合
使用lambda表达式改写的前提：
1、要有一个接口
2、接口中有且只有一个抽象方法
两个前提同时满足才可以使用lambda表达式进行改进
lambda表达式写法：
(xxx,xxx...) -> {
xxxx;
return;
}
*/
public class StaffDemo1 {
private static List<Staff> staffArrays = Arrays.asList(
new Staff("1001","张三",19,11000),
new Staff("1002","李四",18,12000),
new Staff("1003","王五",15,7500),
new Staff("1004","赵六",16,8000),
new Staff("1005","孙七",29,40000)
);
public static void main(String[] args) {
//调用方法进行过滤
List<Staff> staffList1 = filterStaff(staffArrays,(e) -> {
boolean b = e.getAge() > 18;
return b;
});
/**
* () : 表示的是接口中那个唯一的方法的参数
* e : 运行过程中方法接收的参数
* -> : lambda表达式标志，左边是参数，右边是方法体。
*/
for(Staff staff : staffList1){
System.out.println(staff);
}
System.out.println("=======================================");
List<Staff> staffList2 = filterStaff(staffArrays, e -> e.getName().startsWith("李"));
for(Staff staff : staffList2){
System.out.println(staff);
}
}
public static List<Staff> filterStaff(List<Staff> stafflist, Condition condition){
ArrayList<Staff> list = new ArrayList<>();
for(Staff staff : stafflist){
if(condition.filter(staff)){
list.add(staff);
}
}
return list;
}
}再次规范写法（用跟规范的lambda表达式来书写）（最终版）
/**
* () : 表示的是接口中那个唯一的方法的参数
* e : 运行过程中方法接收的参数
* -> : lambda表达式标志，左边是参数，右边是方法体。
*/
员工类和接口类同上
测试类：
package day21.lambdademo8;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
/*
案例3：使用匿名内部类进行改进
现在有一个存储员工的集合，员工id、name、age、salary
需求1：过滤出年龄是大于18岁的，返回新的集合
需求2：过滤出薪资是大于10000块的，放回新的集合
使用lambda表达式改写的前提：
1、要有一个接口
2、接口中有且只有一个抽象方法
两个前提同时满足才可以使用lambda表达式进行改进
lambda表达式写法：
(xxx,xxx...) -> {
xxxx;
return;
}
*/
public class StaffDemo1 {
private static List<Staff> staffList = Arrays.asList(
new Staff("1001","张三",19,11000),
new Staff("1002","李四",18,12000),
new Staff("1003","王五",15,7500),
new Staff("1004","赵六",16,8000),
new Staff("1005","孙七",29,40000)
);
public static void main(String[] args) {
//调用方法进行过滤
List<Staff> staffList1 = filterStaff(staffList,(e)->{
boolean b = e.getAge()>18;
return b;
});
/**
* () : 表示的是接口中那个唯一的方法的参数
* e : 运行过程中方法接收的参数
* -> : lambda表达式标志，左边是参数，右边是方法体。
*/
for(Staff staff : staffList1){
System.out.println(staff);
}
System.out.println("=======================================");
List<Staff> staffList2 = filterStaff(staffList,(e) -> e.getSalary()>10000 );
for(Staff staff : staffList2){
System.out.println(staff);
}
}
public static List<Staff> filterStaff(List<Staff> stafflist, Predicate<Staff>predicate){
ArrayList<Staff> list = new ArrayList<>();
for(Staff staff : stafflist){
if(predicate.test(staff)){
list.add(staff);
}
}
return list;
}
}（4）Lambda表达式
根据使用方式分为6类：
1. 无参数，无返回值。
2. 有一个参数，无返回值。
3. 若只有一个参数，小括号可以省略不写。
4. 有两个以上的参数，有返回值，并且 Lambda 体中有多条语句。
5. 若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写。
6. Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”。
（5）方法的引用
（a）对象的引用::实例方法名
（b）类::静态方法名
（c）类::实例方法名
（d）构造方法引用ClassName::new
（e）数组的引用
package day21.lambdademo12;
import java.util.Arrays;
import java.util.List;
public class Demo7 {
public static void main(String[] args) {
//对象的引用::实例方法名
String str = "aklsdhfa中国asdnhfhd";
// show(8,9,(x,y)->str.substring(x,y));
show(8,10,str::substring);
System.out.println("------------------------------");
//当方法只有一条语句时，且方法体是一个类调用一个静态方法时，且这个静态方法的参数正好是lambda表达式左边的变量，就可以改写
//类名::静态方法名
show2(Arrays::asList,"hello","java","world","apple");
System.out.println("---------------------------------");
// show3("hello_world_java_hadoop_redis","_","@",(s1,s2,s3)->s1.replace(s2,s3));
show3("hello_world_java_hadoop_redis","_","@", String::replace);
//当方法只有一条语句时，且方法体是lambda表达式第一个参数调用方法时，将其他参数作为该方法值传入，就可以改写
//类::实例方法名
show4("1001","张三",19,10000,(a,b,c,d)->new Staff(a,b,c,d));
//当lambda表达式方法逻辑只有一条的时候，且是创建对象返回，并且将左边所有的参数作为创建对象的参数传入的时候，就可以改写
show4("1001","张三",19,10000, Staff::new);
System.out.println("---------------------------------");
// show5(5,e->new String[e]);
show5(5, String[]::new);
}
public static String[] show5(int number,Inter12 inter12){
return inter12.getStringArray(number);
}
public static void show4(String id,String name,int age,int salary,Inter11 inter11){
Staff staff = inter11.getOneStaff(id, name, age, salary);
System.out.println(staff);
}
public static void show(int a,int b,Inter8 inter8 ){
System.out.println(inter8.fun(a,b));
}
public static void show2(Inter9 inter9,String... arr ){
List<String> list = inter9.fun1(arr);
System.out.println(list);
}
public static void show3(String bigStr,String oldStr,String newStr,Inter10 inter10){
String resStr = inter10.fun1(bigStr,oldStr,newStr);
System.out.println(resStr);
}
}
三、正则表达式
定义：正则表达式是一种强大的文本处理工具，用于描述、匹配一系列符合特定模式的字符串。它由普通字符和特殊字符（元字符）组成，能够用来匹配、查找、替换文本中的特定模式。正则表达式最初由Unix工具软件普及，如sed和grep，后来广泛应用于多种编程语言中，包括Perl、Python、Java、C#等。
正则表达式并不是Java独有的，而是通用于绝大多数的常用语言中，它可以极大的减少代码中的判断句式，从而提高代码的效率和简洁性。
（1）案例1
通过对比发现，正则表达式的使用确实要比普通的if-else语句简洁
但是呢，我们虽然使用起来很方便，但是写这个规则过程比较的麻烦，因为正则表达时的目的是为了对字符串进行匹配，替换，切分，截取。要保证我们写的正则表达式要达到一个通用的效果，需要寻找大量的规律1、正则表达式本质上也是一个字符串，只不过是由一些特殊的语法构成
2、正则表达式这门技术，不依附于任意一门的语言，一个正则表达式可以在任意一门语言中使用
package day22;
/*
通过对比发现，正则表达式的使用确实要比普通的if-else语句简洁
但是呢，我们虽然使用起来很方便，但是写这个规则过程比较的麻烦，因为正则表达时的目的是为了对字符串进行匹配，替换，切分，截取
要保证我们写的正则表达式要达到一个通用的效果，需要寻找大量的规律
1、正则表达式本质上也是一个字符串，只不过是由一些特殊的语法构成
2、正则表达式这门技术，不依附于任意一门的语言，一个正则表达式可以在任意一门语言中使用
*/
public class RegularDemo1 {
public static void main(String[] args) {
String qq = "1234567890";//5-11
//qq号没有零开头的
// System.out.println(yanZheng(qq));
System.out.println(yanzheng2(qq));
}
public static boolean yanzheng2(String qq){
return qq.matches("[1-9][0-9]{4,10}");
}
public static boolean yanZheng(String qq){
boolean flag = false;
char[] chars = qq.toCharArray();
if (!qq.startsWith("0")){
if (qq.length() >= 5 && qq.length() <= 11) {
boolean flag2 = true;
for(char c:chars){
if(!Character.isDigit(c)){
flag2=false;
break;
}
}
flag = flag2;
}
}
return flag;
}
}
（2）案例2
原义字符，普通的一个字符也可以充当一个正则表达式
package cday22;
/*
原义字符，普通的一个字符也可以充当一个正则表达式
*/
public class RegularDemo2 {
public static void main(String[] args) {
String str = "hellOWOrldjhghellonoihaoewqhelloappleEwq@";
String regular = "p";
System.out.println(str.replaceAll("o", "p"));
}
}
（3）案例3
正则表达是元字符的高级用法
**
* \d == [0-9] 代表的是数字
* \D == [^0-9]代表的是非数字
* \s == 空白字符（空格，tab键）
* \w == [a-zA-Z0-9_]
* \W == [^a-zA-Z0-9]
* . == 任意字符
*/
package day22;
public class RegularDemo3 {
public static void main(String[] args) {
// String str = "hellOWOrldjhghellonoihaoewqheolloappleEwq@";
// String regular = "[ol]";//表示匹配中括号中的任意一个字符
// System.out.println(str.replaceAll(regular, "_"));
//将所有的小写字母替换成_
// String str = "hellOWOrldjhghellonoihaoewqheolloappleEwq@";
// String regular = "[a-z]";//表示匹配中括号中的任意一个字符
// System.out.println(str.replaceAll(regular, "_"));
//将所有字母包括大小写都替换成_
// String str = "hellOWOrldjhg45hellono%347ihao@ewq246heollo#appl145eEwq@";
String regular = "[0-9A-z]";//表示匹配中括号中的任意一个字符
// String regular = "[%!#@]";
// System.out.println(str.replaceAll(regular, "_"));
/**
* \d == [0-9] 代表的是数字
* \D == [^0-9]代表的是非数字
* \s == 空白字符（空格，tab键）
* \w == [a-zA-Z0-9_]
* \W == [^a-zA-Z0-9]
* . == 任意字符
*/
String str = "hellOW_Orldjhg 45hell-ono%347i_h...ao@e wq24_6heo llo#appl145eEwq@";
// String regular = "\\d";// 匹配所有数字
// String regular = "\\D";// 除去数字
// String regular = "\\s";// 匹配空格
// String regular = "\\w";
// String regular = "\\W";
String regular = "\\.";
System.out.println(str.replaceAll(regular, "_"));
}
}
（4）案例4
//?:出现了0次或者1次
//+:代表出现了1次或者多次
//*:代表出现了任意次
package day22;
public class RegularDemo4 {
public static void main(String[] args) {
// String str = "张三很爱国";
// String regular = "^张三";
// String regular2 = "爱国$";
// System.out.println(str.replaceAll(regular,"_"));
// System.out.println(str.replaceAll(regular2,"_"));
//?:出现了0次或者1次
//+:代表出现了1次或者多次
//*:代表出现了任意次
// String str = "caaaaaaabaaaaaabaacbaaaaaaacbaafg";
// String regular = "^a?";
// String regular = "^a+";
// String regular = "^a*";
// System.out.println(str.replaceAll(regular,"_"));
String str = "caaaaaaabcaaaaaabaacbcaaaacaaacbaafg";
// String regular = "ca{3}";//caaa
// String regular = "ca{4,6}";//caaaa~caaaaaa
String regular = "ca{4,}";
System.out.println(str.replaceAll(regular,"_"));
}
}
（5）案例5
正则表达式的合并使用及符号
package day22;
public class RegularDemo5 {
public static void main(String[] args) {
//将连续出现了3次以上的abc替换成_
// String regex = "abc{3,}"; //ab后面接着3次以上的c abcccccccc
String regex = "(abc){3,}"; //使用小括号将abc看作是一组，然后匹配这组出现了3次以上 abcabcabc
String str = "abccccccccABC123ABC123abcABCabcabcabc123ABC123123"; // ABC(123){1,}
// System.out.println("要匹配的字符串为：\n" + str);
// System.out.println("==========================================");
// System.out.println(str.replaceAll(regex, "_"));
//需求2：ABC后面跟上出现1次以上的123为一个整体进行匹配
//ABC123123123
// regex = "ABC(123){1,}";
// System.out.println(str.replaceAll(regex, "_"));
//需求3：ABC后面跟上出现1次以上的123或者abc为一个整体进行匹配 ABCabc ABC123 ABCabcabc ABC123123123
// ABC(123|abc){1,}
//ABC123123
//ABCabcabc
regex = "ABC(123|abc){1,}";
System.out.println(str.replaceAll(regex, "_"));
}
}
（6）案例6
正则表达式的日期使用
package day22;
public class RegularDemo6 {
public static void main(String[] args) {
//日期案例
// 2022-03-28 ---> 03/28/2022
String str = "2022-03-28 dasdas 2022-04-05";
String regex = "(\\d{4})-(\\d{2})-(\\d{2})"; //"xxxx-xx-xx"
System.out.println(str.replaceAll(regex,"$2/$3/$1"));
//需求2：我不想你取出月份
regex = "(\\d{4})-(?:\\d{2})-(\\d{2})";
System.out.println(str.replaceAll(regex,"$2/$1"));
}
}
（7）案例7
正则表达式在Java中的应用
1、字符串的查找操作：Pattern和Matcher
2、字符串的匹配操作：可以使用字符串String类中matches()方法
3、字符串的分割操作：可以使用字符串String类中的split()方法
4、字符串的替换工作：字符串中的replaceAll()方法和replaceFirst()方法
package day22;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegularDemo7 {
public static void main(String[] args) {
// String regex = "\\w{3,}";
// String str = "abcdef123";
// //public boolean matches(String regex)告诉这个字符串是否匹配给定的regular expression 。
// System.out.println(str.matches(regex));
// System.out.println("======================================");
//
// regex = "[a-z]{2,}";
// str = "abc def hello 123dsa";
// System.out.println(str.matches(regex));
// System.out.println(str.replaceAll(regex, "_"));
// System.out.println(str.replaceFirst(regex, "_"));
// System.out.println("=======================================");
// String str = "hllhoo wdw wohorel spajhooork";
// //public String[] split(String regex)将此字符串拆分为给定的regular expression的匹配。
// String[] strings = str.split("ho{1,}");
// System.out.println(Arrays.toString((strings)));
// System.out.println("=======================================");
// String[] ws = str.split("w");
// String s = Arrays.toString(ws);
// System.out.println(s);
//
// System.out.println("=======================================");
//字符串的查找操作：Pattern和Matcher
String regex = "\\w{3,7}";
String str = "###abcd123qqqbbbbbb333";
//创建一个java对应的正则表达式对象
//public static Pattern compile(String regex)将给定的正则表达式编译为模式
Pattern compile = Pattern.compile(regex);
//public Matcher matcher(CharSequence input)创建一个匹配器，匹配给定的输入与此模式。
Matcher matcher = compile.matcher(str);
// //boolean matches()
//尝试将整个区域与模式进行匹配。
System.out.println(matcher.matches());//整体匹配
// System.out.println(matcher.find());//区域匹配
//int end()
//public int start()返回上一个匹配的起始索引。
System.out.println(matcher.start());
// System.out.println(matcher.end());//返回最后一个字符匹配后的偏移量。
//String group()
// //返回与上一个匹配匹配的输入子序列。
// System.out.println(matcher.group());
// System.out.println("====================================");
// //boolean find()
// //尝试找到匹配模式的输入序列的下一个子序列。
// System.out.println(matcher.find());
// //int end()
// //返回最后一个字符匹配后的偏移量。
// //public int start()返回上一个匹配的起始索引。
System.out.println(matcher.start());
// System.out.println(matcher.end());
// //String group()
// //返回与上一个匹配匹配的输入子序列。
// System.out.println(matcher.group());
System.out.println(matcher.group());
// System.out.println("================================");
// System.out.println(matcher.find());
// //int end()
// //返回最后一个字符匹配后的偏移量。
// //public int start()返回上一个匹配的起始索引。
System.out.println(matcher.start());
// System.out.println(matcher.end());
// //String group()
// //返回与上一个匹配匹配的输入子序列。
System.out.println(matcher.find());
System.out.println(matcher.group());
System.out.println(matcher.find());
System.out.println(matcher.group());
System.out.println("==================================");
// System.out.println(matcher.find());
// //int end()
// //返回最后一个字符匹配后的偏移量。
// //public int start()返回上一个匹配的起始索引。
System.out.println(matcher.start());
// System.out.println(matcher.end());
// //String group()
// //返回与上一个匹配匹配的输入子序列。
// System.out.println(matcher.group());
}
}
690
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
