API:官方给开发人员提供的一个说明文档，对语言有哪些类，类中有哪些方法进行说明。
函数库：
API文档：
例：String
获取字符串长度
获取摸个位置上的字符
学习java语言中提供的类
Object类
java.lang.Object
是java类体系结构中最顶层的类
Object类·方法：
toString()
不重新写toString(),调用时是Object类中默认的输出的是哈希值
equals(Object obj)
判断两个对象是否相等的逻辑
“==” ：比较等号两边是否相等：
当==用于基本类型比较时，比较的是变量的值是否相等；
当==用于引用类型比较时，比较的是对象的地址是否相等；
equals 方法默认使用==比较,比较的是对象地址，想要比较引用对象的值，就必须重写方法：
@Override
public boolean equals(Object obj) {
if (obj instanceof Person){
Person other = (Person) obj;
return this.name.equals(other.name) && this. age == other.age;
}
return false;
}
在Java中，equals()方法用于比较两个对象的内容是否相等。该方法定义在Object类中，所有的对象都继承自Object类，因此都可以使用equals()方法进行对象内容的比较。当需要判断两个对象的内容是否相等时，可以使用equals()方法来进行比较。
需要注意的地方包括：
-
覆盖equals()方法：在自定义类中，需要根据对象的内容定义equals()方法，以实现内容的比较。通常需要重写equals()方法，同时也需要重写hashCode()方法。
-
对象为空的情况：在使用equals()方法时，需要考虑对象是否为空。如果对象为null，则不能调用equals()方法，否则会抛出NullPointerException异常。
-
调用equals()方法时需要进行类型判断：当使用equals()方法进行对象比较时，需要先进行类型判断，确保比较的两个对象属于同一类型。可以使用instanceof关键字进行类型判断。
-
重写equals()方法时需要遵循规范：在覆盖equals()方法时，需要遵循一些规范，例如满足自反性、对称性、传递性和一致性等要求。
总之，在使用equals()方法时，需要注意以上几点，以确保对象内容的比较能够得到正确的结果。
Arrays类
● java.util.Arrays类用于操作数组工具类，里面定义了常见操作数组的静态方法.
● sort －排序
● 作用于数组的所有元素 public static void sort(type[] a）
●binarySearch
-使用二分搜索算法搜索指定数组
public static int binarySearch(type[] a, type key)
public static int binarySearch(long[] a,int fromIndex,int toIndex,long key)
a - 要搜索的数组。
key - 要搜索的值。
fromIndex - 要排序的第一个元素的索引（包括）。
toIndex - 要排序的最后一个元素的索引（不包括）。
● copyOf方法
● 数组复制,将指定数组中的元素复制到一个指定长度的新数组中,并返回 新数组.
● static int[] copyOf(int[] a, int newLength)
● fill方法
● 将指定的int值分配给指定的int数组的每个元素。
● fill(int[] a, int val)
toString() 方法
● public static String toString(type[] a)
● 返回指定数组内容的字符串表示形式
● equals 方法
比较两个数组对象中元素是否相等.
而数组对象中的equals用来判断与另一个数组对象是否相等
String类
java.lang.String
java中所有的字符串都是此类的实例；
"abc" -- > 字符串对象 底层是一个char数组 private final char value[];
//String s = "abc";
先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找 有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中 的”abc”，如果常量池中有,则直接指向改地址即可,不用重新创建;
//字不变符串，它们的值在创建后不能被更改
String s = "abc";//第一个字符串对象 s += "cde"//第二个字符串对象，虽然允许，但这是创建了一个新对象
传码·解码
package javaapi.StringDome;
import java.util.Arrays;
public class String1 {
public static void main(String[] args) {
/*String a1 = "abc";
a1+="d";*/
String s1 = new String();
String s2 = new String("abc");
String s3 = "你好";
byte[] b1 = s3.getBytes();
System.out.println(Arrays.toString(b1));
String s4 = new String(b1);
System.out.println(s4);
char[] b2 = s3.toCharArray();
Arrays.sort(b2);
String s5 = new String(b2);
System.out.println(s5);
}
}
编码与解码 所用的译码 应该是以一样的，不然输出会变成乱码
把一个字符串转为一个有序的字符串：
先转为字符数组，再排序，再转为字符串；
● 判断功能
boolean equals(Object obj) boolean //比较字符串对象内容是否相等; equalsIgnoreCase(String str) //比较字符串对象的内容相等，并忽略大小写; boolean contains(String str) //判断字符串中是否包含指定的子串; boolean isEmpty() //判断字符串值是否为""（是空串）; boolean startsWith(String prefix) //判断字符串是否以指定的子串开头; boolean endsWith(String suffix)//判断字符串是否指定的子串结尾;
●获取功能
String s = "acbcdefg";
// 编号 01234567
System.out.println(s.length()); //获取字符串长度；
System.out.println(s.charAt(2));//获取字符串中 指定位置 的字符（位置默认从零开始）；
System.out.println(s.indexOf("b"));//获取字符串中 字符--首次出现的位置；
System.out.println(s.indexOf("c",2));//从指定的位置开始 往后获取字符串中 字符 首次出现 的位置
System.out.println(s.lastIndexOf("e"));//从后往前查找
System.out.println(s.substring(3));//从指定位置开始到最后，截取这段字符串副本
System.out.println(s.substring(3, 5));//从开始指定位置 开始到 最后指定位置（不包括最后指定位置），截取这段字符串副本
8
b
2
3
5
cdefg
cd
int length() //获取字符串长度；
char charAt(int index)//获取字符串中 指定位置 的字符（位置默认从零开始）；
int indexOf(String str)//获取字符串中 字符--首次出现的位置；
int indexOf(String str,int fromIndex)//从指定的位置开始 往后获取字符串中 字符 首次出现 的位置；
int lastIndexOf(String str)//从后往前查找
String substring(int start) //从指定位置开始到最后，截取这段字符串副本
String substring(int start,int end)//从开始指定位置开始到最后指定位置（不包括最后指定位置），截取这段字符串副本
● 转换功能
byte[] getBytes() //将字符串转为byte数组 char[] toCharArray() //将字符串转为字符数组 static String valueOf(char[] chs) //将传入的参数转化为字符串 String toLowerCase() //将英文字母转为小写 String toUpperCase() //将英文字母转为大写 String concat(String str) //拼接指定的字符串内容导员字符串末尾 返回一个新的字符串对想 Stirng[] split(分割符);//将一个字符串用指定的分隔符拆分成一个字符串数组
● 替换功能
String replace(char old,char new) //
String replace(String old,String new) //将新内容替换字符串中指定的字符串
replaceAll(String regex, String replacement) //将新内容替换字符串中正则表达式匹配的字符串
replaceFirst(String regex, String replacement) //将新内容替换字符串中正则表达式匹配的字符串，只替换第一个
//
String s = "ab1cd2ef3g5";
System.out.println(s.replace("1", "c"));
System.out.println(s.replaceAll("\\d","m"));
//
abccd2ef3g5
abmcdmefmgm
● 去除字符串两空格
String trim()// 字符串两端 String s1 = " .s e. "; System.out.println(s1.trim()); .s e.
● StringBuffer类
概述 ：我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String 对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题 线程安全的可变字符序列
StringBuffer是内容可以改变的字符串
char[] value 没有使用final修饰，每次添加内容都是对此数组进行操作，不会创建新的字符串对象
因为String声明的字符串对象的值一旦给定就不能改变了，每次拼接，都会构建一个新的String 对象，既耗时，又浪费空间
StringBuffer是内容可改变的字符串
其底层在每次操作时是在数组上进行的
● 添加功能
public StringBuffer append(String str) //想字符串末尾添加内容
public StringBuffer insert(int offset,String str) //向指定位置上插入指定的字符串
● 删除功能
public StringBuffer deleteCharAt(int index) //删除指定位置的字符
public StringBuffer delete(int start,int end)//删除指定区间的字符串（包含开始，不包含结尾）
● 替换功能
public StringBuffer replace(int start,int end,String str) //用指定字符串替换指定区间字符
● 反转功能
public StringBuffer reverse()//反转字符串
● 截取功能
public String substring(int start) //
public String substring(int start,int end) //从开始指定位置 开始到 最后指定位置（不包括最后指定位置），截取这段字符串副本，返回给一个String类型，原对象不变
// 截取功能和前面几个功能的不同 返回值类型是String类型，本身没有发生改变
● StringBuilder类功能和StringBuffer功能完全一致, StringBuffer是线程 安全的
● String：是字符常量,适用于少量的字符串操作的情况 ,他的值不可以改变
● StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况，值可以改变且不需要创建新对象，方法都加上了锁，是在多线程（任务）执行时是安全的
● StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况 ，值可以改变且不需要创建新对象，由于方法没加锁，是在多线程（任务）执行时是不安全的，适合单线程。
Math类
● java.lang.Math提供了一系列静态方法用于科学计算；
其方法的参数和 返回值类型一般为double型。
abs 绝对值 sqrt 平方根 pow(double a, double b) a的b次幂 max(double a, double b) min(double a, double b) flooor() random() 返回 0.0 到 1.0 的随机数 long round(double a) double型的数据a转换为long型（四舍五入）
● Random类概述
此类用于产生*随机数
Random类是
Java中用于生成伪随机数的类，它提供了各种方法用于生成不同类型的随机数。Random类位于java.util包中。
构造方法：
Random类有两个构造方法：
-
Random(); //使用系统当前时间作为种子，创建一个新的随机数生成器。 Random(long seed); //使用指定的种子值创建一个新的随机数生成器。 // public Random() //成员方法: public int nextInt() public int nextInt(int n)
使用方法： Random类的常用方法包括：
-
1. nextInt()： //生成一个int类型的随机数。 2. nextDouble()： //生成一个double类型的随机数。 3. nextBoolean()： //生成一个boolean类型的随机数。 4. nextLong()： //生成一个long类型的随机数。 5. setSeed(long seed)： //设置随机数生成器的种子值。
示例：
import java.util.Random;
public class RandomExample {
public static void main(String[] args) {
Random random = new Random();
int num = random.nextInt(10); // 生成一个0-9的随机数
System.out.println("随机数：" + num);
}
}//在Java中，你可以使用setSeed(long seed)方法来设置随机数生成器的种子。种子是一个长整型数值，它作为随机数生成器的初始值，用于产生随机数序列。
//以下是一个示例代码：
```java
import java.util.Random;
public class RandomSeedExample {
public static void main(String[] args) {
// 创建一个随机数生成器
Random random = new Random();
// 设置种子
long seed = 12345;
random.setSeed(seed);
// 生成随机整数
int randomNumber = random.nextInt(100);
System.out.println("随机整数: " + randomNumber);
}
}
//在上面的示例中，我们首先创建了一个Random对象，
//然后使用setSeed(long seed)方法设置了种子为12345。
///接着使用nextInt()方法生成一个0到99之间的随机整数。
//因为我们已经设置了种子，所以每次运行程序时，生成的随机数都将是一样的，
//因为种子确定了随机数序列的起始状态。
//注意：需要构造对象来使用 Radom random = new Random(); //注意： random.nextInt(6);//给定范围后，就是从0~~~~6;
在上面的示例中，我们首先创建了一个Random对象，然后使用nextInt()方法生成一个0-9的随机数，并将其打印输出。
● Date类
● 使用Date类代表当前系统时间
Date d = new Date(); Date d = new Date(long d);
Calendar类
● Calendar类是一个抽象类，
在实际使用时实现特定的子类的对象，
创建对象的过程对程序员来说是透明的，
只需要使用getInstance方法创建 即可。
Calendar c1 = Calendar.getInstance(); c1.get(Calendar. YEAR);
Calendar类常用的方法有：
-
1. get(int field); //获取指定字段的值，例如Calendar.YEAR、Calendar.MONTH、Calendar.DAY_OF_MONTH等。 //使用方法： Calendar calendar = Calendar.getInstance(); int year = calendar.get(Calendar.YEAR); int month = calendar.get(Calendar.MONTH) + 1; // 月份从0开始，需要加1 int day = calendar.get(Calendar.DAY_OF_MONTH); 2. set(int field, int value); //设置指定字段的值。 //使用方法： Calendar calendar = Calendar.getInstance(); calendar.set(Calendar.YEAR, 2022); calendar.set(Calendar.MONTH, 0); // 月份从0开始，0表示一月 calendar.set(Calendar.DAY_OF_MONTH, 1); 3. add(int field, int amount); //在指定字段上增加或减少指定的时间量。 //使用方法： Calendar calendar = Calendar.getInstance(); calendar.add(Calendar.YEAR, 1); calendar.add(Calendar.MONTH, -1); calendar.add(Calendar.DAY_OF_MONTH, 7); 4. getTime(); //获取Calendar对象对应的Date对象。 //使用方法： Calendar calendar = Calendar.getInstance(); Date date = calendar.getTime(); 5. setTime(Date date); //设置Calendar对象对应的Date对象。 //使用方法： Calendar calendar = Calendar.getInstance(); Date newDate = new Date(); calendar.setTime(newDate);
//在Java中，可以使用以下方法获取系统当前的毫秒值： 1. System.currentTimeMillis()//这是最常用的获取当前时间毫秒值的方法。它返回自UTC 1970年1月1日午夜起至现在的毫秒数。 ```java long currentTimeMillis = System.currentTimeMillis(); ``` 2. System.nanoTime()：//这个方法返回自某个未指定的原点起来的相对时间，准确度更高，可以用于性能分析。 ```java long nanoTime = System.nanoTime(); ``` //这两种方法都可以用来获取系统当前的毫秒值，但是具体使用哪种方法取决于你的需求。如果只是需要获取当前时间的毫秒值，推荐使用System.currentTimeMillis()方法。如果需要更高精度或者需要测量代码块的执行时间，可以考虑使用System.nanoTime()方法。
//在Java中，这三个方法分别用于获取当前的时间毫秒值，但有一些区别： 1. `date.getTime()`：`Date`类的`getTime()`方法返回的是`Date`对象表示的时间自UTC 1970年1月1日午夜起至现在的毫秒数。需要先实例化一个`Date`对象，然后调用`getTime()`方法获取毫秒值。 Date date = new Date(); long timeInMillis = date.getTime(); System.out.println(timeInMillis); 2. `calendar.getTimeInMillis()`：`Calendar`类的`getTimeInMillis()`方法返回的也是表示`Calendar`对象当前时间与UTC 1970年1月1日午夜之间的时间差，以毫秒为单位。 ```java Calendar calendar = Calendar.getInstance(); long timeInMillis = calendar.getTimeInMillis(); System.out.println(timeInMillis); ``` 3. `System.currentTimeMillis()`：`System.currentTimeMillis()`方法是直接调用`System`类的静态方法，返回的是当前系统时间自UTC 1970年1月1日午夜至现在的毫秒数，是最常用的获取当前时间毫秒值的方法。 long currentTimeMillis = System.currentTimeMillis(); System.out.println(currentTimeMillis); //总的来说，这三个方法本质上都是获取当前时间的毫秒值，但是实现方式略有不同。`System.currentTimeMillis()`是最简单和通用的方式，推荐在大多数情况下使用。而`Date.getTime()`和`Calendar.getTimeInMillis()`需要创建对象，对于处理时间和日期相关的操作更为方便。
在使用这些常用方法时，需要注意以下事项：
-
月份是从0开始的，所以在设置和获取月份时需要注意。
-
对于一些字段如年、月、日等，需要注意它们的取值范围，例如月份的取值范围是0-11，年份可能需要考虑闰年的情况。
-
在设置时间时，要注意传入的值是否合理，避免出现不符合实际情况的时间。
● SimpleDateFormat 日期格式化类
// ● 构造方法 //SimpleDateFormat(格式); // yyyy-MM-dd //● 日期转字符串 Date now=new Date(); myFmt.format(now); //● 字符串转日期 myFmt.parse(“2018-02-10”); //字符串日期格式与 指定格式必须一致 //例如: String s = “2018-03-15”; new SimpleDateFormat(“yyyy-MM-dd”)
BigInteger
● 在 Java 中，有许多数字处理的类，
比如 Integer类，但是Integer类有一定的局限性。
● 我们都知道 Integer 是 Int 的包装类，int 的最大值为 2^31-1。
若希望描述更大的 整数数据时，使用Integer 数据类型就无法实现了，所以Java中提供了BigInteger 类。
● BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意 精度的整数，
也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而 不会丢失任何信息。
● BigInteger类位于java.math包中
//● 构造方法
BigInteger(String val)
BigInteger(byte[] val)
//... 基本运算方法
add()，
subtract()，
multiply()，
divide()
BigDecimal
● 在计算机中
float 还是double都是浮点数，
而计算机是二进制的，浮点数会失 去一定的精确度。
● 根本原因是:
十进制浮点值没有完全相同的二进制表示形式;
十进制浮点值的二进 制表示形式不精确,只能无限接近于那个值
. System.out.println((0.1 + 0.2)==0.3);
//结果是?
但是，在项目中，我们不可能让这种情况出现，特别是金融项目，
因为涉及金 额的计算都必须十分精确，你想想，如果你的支付宝账户余额显示 193.99999999999998，那是一种怎么样的体验？
//• Java在java.math包中提供的API类BigDecimal • //构造方法
BigDecimal(String val)
基本运算方法
add()，subtract()，multiply()，divide()
ChronoUnit
在Java中，ChronoUnit是一个枚举类型
用于表示不同的时间单位，例如年、月、日、小时、分钟、秒等。它可以用于计算两个时间点之间的时间差，或者在日期时间操作中指定单位。
下面是一些ChronoUnit的用法示例：
LocalDate date1 = LocalDate.of(2022, 1, 1);
LocalDate date2 = LocalDate.of(2022, 12, 31);
long daysBetween = ChronoUnit.DAYS.between(date1, date2);
System.out.println("Days between date1 and date2: " + daysBetween);
LocalTime time1 = LocalTime.of(12, 0);
LocalTime time2 = LocalTime.of(18, 0);
long hoursBetween = ChronoUnit.HOURS.between(time1, time2);
System.out.println("Hours between time1 and time2: " + hoursBetween);
LocalDateTime dateTime1 = LocalDateTime.of(2022, 1, 1, 12, 0);
LocalDateTime dateTime2 = LocalDateTime.of(2022, 12, 31, 18, 0);
long monthsBetween = ChronoUnit.MONTHS.between(dateTime1, dateTime2);
System.out.println("Months between dateTime1 and dateTime2: " + monthsBetween);
这些示例展示了如何使用ChronoUnit来计算两个日期、时间或日期时间之间的时间差，并打印结果。通过使用ChronoUnit枚举类型，可以非常方便地进行时间单位的计算和处理。
LocalDate
在Java中，LocalDate是用于表示日期的类。它不包含任何时间信息，只有年、月、日信息。常用的函数包括：
-
1. of()：//静态方法，用于创建指定年、月、日的LocalDate对象。 2. now()：//静态方法，用于获取当前日期。 3. getYear()、getMonthValue()、getDayOfMonth()：//分别用于获取年、月、日的值。 4. getDayOfWeek()：//用于获取日期对应的星期几。 5. plusDays()、minusDays()、plusMonths()、minusMonths()、plusYears()、minusYears()：/、用于对日期进行加减操作。 6. isAfter()、isBefore()、isEqual()：//用于比较日期的先后顺序。
示例代码中的程序使用LocalDate类创建一个指定日期的对象，然后通过getDayOfWeek()方法获取该日期对应的星期几，并输出结果。
基本数据类型包装类
● Java语言是一个面向对象的语言，
但是Java中的基本数据类型却是不面 向对象的，
这在实际使用时存在很多的不便，为了解决这个不足，
在设 计类时为每个基本数据类型设计了一个对应的类进表示，
这样八个和基 本数据类型对应的类统称为包装类.
● 包装类（如：Integer，Double等）
这些类封装了一个相应的基本数据 类型数值，并为其提供了一系列操作方法
基本数据类型封装类
● 装箱和拆箱Auto-boxing/unboxing
● 装箱 自动将基本数据类型转换为包装器类型 装箱的时候自动调用的是Integer的valueOf(int)方法
● 拆箱 自动将包装器类型转换为基本数据类型 拆箱的时候自动调用的是Integer的intValue方法
//装箱
int a = 12;
Integer b = Integer.valueOf(a);
//自动装箱
//默认调用valueof()方法，
//在valueof()中如果基本类型在-128-------+127之间，会从缓存数组中直接提取一个Integer对象返回，也就是说地址是一样的
int a = 12; //Integer b = a; Integer b = Integer.valueOf(a);
//拆箱
Integer b = new Integer(10); //int c = b; int c = b.intValue();
//自动拆箱
int c = b
使用Integer.parseInt()方法
将一个字符串里面的数字转化成整数型数字。例如：
String str = "123"; int number = Integer.parseInt(str); System.out.println(number); // 输出 123
需要注意的是，如果字符串中包含非数字字符，或者超出了整数表示范围，将会抛出NumberFormatException异常。
使用String.valueOf() 方法
用于将指定类型的参数转换为字符串。它是一个静态方法，因此可以直接通过类名调用，例如：String.valueOf(123)。该方法接受 char、boolean、int、long、float、double、Object 等类型的参数，并返回对应类型的字符串表示。例如：
int number = 123; String str = String.valueOf(number); System.out.println(str); // 输出 "123"
同样，这个方法还可以用于将其它基本类型或对象类型转换为字符串。值得注意的是，对于null值，String.valueOf()方法会返回字符串 "null"。
在Java中，Integer类是一个包装类，用于封装基本数据类型int的值，并提供了一系列方法来对int类型进行操作和转换。以下是Integer类的一些常用方法：
-
parseInt(String s): 将指定字符串 s 解析为带符号的十进制整数。 -
parseInt(String s, int radix): 将指定基数 radix 中的字符串 s 解析为带符号的整数。 -
toString(int i): 返回 int 参数的字符串表示形式。 -
valueOf(String s): 返回保存指定字符串 s 所表示的 int 值的 Integer 对象。 -
valueOf(int i): 返回一个表示指定的 int 值的 Integer 实例。 -
toBinaryString(int i): 返回整数参数的二进制补码字符串。 -
toHexString(int i): 返回整数参数的无符号十六进制数。 -
toOctalString(int i): 返回整数参数的八进制字符串。 -
compare(int x, int y): 将两个 int 值进行比较。 -
equals(Object obj): 比较此对象与指定对象是否相等。
这些是Integer类中的一些常用方法，还有其他方法可以用于对整数进行位操作、处理大小端字节顺序等。您可以查阅Java官方文档以获取更多关于Integer类的详细信息和方法说明。
正则表达式
正则表达式（Regular Expression,简称regex
正则表达式时一种规则（模式）匹配语法。
可以使他一些正则表达式中定义的特殊符号来定义一种规则，然后用此规则去匹配摸个字符串
如果字符串与规则相匹配 返回true，否则返回false
| 正则表达式 | 描述 |
|---|---|
| \d | 匹配任意一个数字 |
| \w | 匹配字母、数字或下划线 |
| \s | 匹配任意空白字符 |
| \D | 匹配任意非数字字符 |
| \W | 匹配任意非字母、数字或下划线字符 |
| \S | 匹配任意非空白字符 |
| ^ | 匹配字符串的开始 |
| $ | 匹配字符串的结束 |
| . | 匹配除换行符以外的任意字符 |
| [abc] | 匹配a、b或c中的任意一个字符 |
| [a-z] | 匹配任意小写字母 |
| [A-Z] | 匹配任意大写字母 |
| [0-9] | 匹配任意数字 |
| [^abc] | 匹配除了a、b、c之外的任意字符 |
| (exp) | 匹配exp并捕获该匹配的子表达式 |
| exp1|exp2 | 匹配exp1或exp2 |
| ? | 匹配零次或一次其之前的表达式 |
| * | 匹配零次或多次其之前的表达式 |
| + | 匹配一次或多次其之前的表达式 |
| {n} | 匹配n次其之前的表达式 |
| {n,} | 匹配至少n次其之前的表达式 |
| {n,m} | 匹配n到m次其之前的表达式 |
//
| 方法 | 描述 |
|---|---|
| Pattern.compile(String regex) | 通过给定的正则表达式创建一个 Pattern 对象 |
| Matcher matcher(CharSequence input) | 创建一个Matcher对象，并指定要匹配的输入字符序列 |
| Matcher.matches() | 尝试将整个区域与模式匹配 |
| Matcher.find() | 尝试查找输入序列中与模式匹配的子序列 |
| Matcher.group() | 返回当前匹配的子序列 |
| Matcher.start() | 返回当前匹配的起始索引 |
| Matcher.end() | 返回当前匹配的结束索引 |
| Matcher.replaceAll(String replacement) | 用指定的替换字符串替换匹配到的结果 |
| Matcher.reset() | 重置匹配器，可以在同一个Matcher对象中重新设置要匹配的输入字符序列 |
| Matcher.lookingAt() | 尝试从区域的开始匹配模式，不需要匹配整个区域 |
2157
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
