《Java面向对象程序设计》学习笔记——第 9 章 常用实用类
笔记汇总：《Java面向对象程序设计》学习笔记
第 9 章 常用实用类
9.1 String 类
java. lang 包中的 String 类为 final 类，因此用户不能扩展 String 类，即 String 类不可以有子类。
9.1.1 构造 String 对象
String 常量是用双引号（英文输入法输入的双引号）括起的字符序列。
（括号中没有内容也合法）
（单引号括起来的是字符，字符常量！！！）
String s;
s = new String("we are students");
s 中存放着引用， s 的实体是字符序列 we are students ，即 String 对象封装的是字符序列。
可以用一个已创建的 String 对象创建另一个 String 对象。
String tom = new String(s);
引用 String 常量
String 常量也是对象。 Java 把用户程序中的 String 常量放入常量池。 String 常量对象也有自己的引用和实体。
可以把 String 常量的引用赋值给一个 String 变量。
String s,s1,s2;
s = new String("student"); // 对实体的引用
s1 = "student"; // 对常量的引用
s2 = "student"; // 对常量的引用
// 其实这里应该输出其引用，但是String 类重写了 Object 类的 String toString() 方法，所以输出的是对象的实体
System.out.println(s);
System.out.println(s.toString());
// new构造出的对象的引用每次都是不同的，它是动态的，所以和常量是s1，s2不同
System.out.println(s == s1); // false，不是相同的引用
System.out.println(s2 == s1); // true，都是对常量的引用
用户无法输出 String 对象的引用，输出的是对象的实体。因为 String 类重写了 Object 类的 String toString() 方法。
注：可以这样简单地理解常量池：常量池中的字符序列的“引用”在程序运行期间再也不允许改变。非常量池中的 String 对象的引用可以发生变化。
new构造出的对象的引用每次都是不同的，它是动态的，所以和常量是s1，s2不同
9.1.2 String 类的常用方法
1 public int length(String s)
使用 String 类中的 length() 方法可以获取一个 string 对象封装的字符序列的长度，即 String 对象的字符序列的长度。
String tom = "我们是学生";
int n1,n2;
n1 = tom.length(); // 5
n2 = "你好 abcd".length(); // 7
2 public boolean equals(String s)
比较当前 String 对象的字符序列是否与参数 s 指定的 String 对象的字符序列相同。
相同返回true，反之返回false。
String s1,s2;
s1=new String("we are students");
s2=new String("we are students");
System.out.println(s1.equals(s2)); //输出结果是：true
System.out.println(s1==s2); //输出结果是：false
String s3,s4;
s3="how are you";
s4="how are you";
System.out.println(s3.equals(s4)); //输出结果是：true
System.out.println(s3==s4); //输出结果是：true
可以简单的理解为
s1.equals(s2)是比较值，s1 == s2是比较引用/所在地址空间
所以两个 String 对象的值相等不一定代表引用相等，尽量不要使用 ==，使用equals()
5 public int compareTo(String s)
按字典序与参数的字符序列比较大小。
当前 String 对象的字符序列与 s 的字符序列相比，相同返回值 0，大于返回正值，否则返回负值。
6 public boolean contains(String S)
判断当前 string 对象的字符序列是否含有 s 的字符序列。
7 public int indexOf(String s)
从当前 String 对象的字符序列索引位置 0 开始检索，并返回 首次出现 s 的字符序列的位置。如果没有检索到 s 的字符序列，该方法返回的值是 -1 。
String tom1 = "I am a good cat";
tom1.indexOf("a"); // 值是 2
tom1.indexOf("good", 2 ); // 值是 7
tom1.indexOf("a", 7 ); // 值是 13
tom1.indexOf("w", 2 ); // 值是-1
8 public String substring(int startpoint)
返回一个新的 String 对象，返回的 String 对象的字符序列是从当前 string 对象的字苻序列索引位置 startpoint 开始（包括位置 startpoint 上的字符） 截取到最后，所得到的字符序列。
String tom2 = "ABCDEFGH";
String ss1 = tom2.substring(2); // 2到最后，即[2,]
String ss2 = tom2.substring(2,5); // 2到5（不包括5），即[2,5)
System.out.println(ss1); // CDEFGH
System.out.println(ss2); // CDE
使用场景
String path = "c:\\book\\javabook\\xml.doc"; // 引用文件要写\\，因为\是转义字符
int index = path.indexOf("\\"); // 2 首次出现\\的位置
index = path.indexOf("\\", index); // 2 首次出现\\的位置，和上面一样
String sub = path.substring(index); // \book\javabook\xml.doc 从上面位置往后截截子串，只有一个\是因为\是转义字符，转义掉了一个\
index = path.lastIndexOf("\\"); // 16 最后出现\\的位置
sub = path.substring(index + 1); // xml.doc 从上面的位置往后截截子串
接下来的方法了解即可，用的不是很多
3 public boolean startsWith(String s)、endsWith(String s)
判断当前 String 对象的字符序列 前/后缀 是否是参数 s 指定的 String 对象的字符序列
String = "260221", jerry = "210220"
tom.startsWith("260"); // true
jerry.startsWith("260"); // false
4 public boolean regionMatches(int first.Start , String other , int orthcrStart , int length)
从当前 String 对象的字符序列 firststart 位置开始，取长度为 length 的一个字符序列，并将这个字符序列和参数 other 的字符序列的一个子字符序列进行比较。
其中， other 的子字符序列是从参数 othertstart 指定的位置开始，取长度为 length 的一个子字符序列。如果两个子字符序列相同，该方法就返回 true ，否则返回 false。
该方法的重载方法（当 b 取 true 时，忽略大小写）：
public regionMatches(boolean b , int first.Start , String other , int orthcrStart , int length)
9 public String trim()
一返回一个 String 对象，返回的 String 对象的字符序列 s 的字符序列去掉前后空格后所得到的字符序列。
9.1.3 String 对象与基本数据的相互转化
String 对象的字符序列转化为数字
public static int parselnt(String s)
该方法返回 int 型数据
如果参数 s 的字符序列中的字符有非“数字"字符，如" 1ab56 "，那么该方法在执行过程中会抛出 NumberFormatException 异常
货币值样式的字符序列转化为数字
String currency = "124,019,578.8768¥";
String str = "###,###¥"; // 按千分组
DecimalFormat df = new DecimalFormat(str); // 格式化
Number num = df.parse(currency); // 赋值给number类型
double d = num.doubleValue();
数字转化为 String 对象
任何数字和 String 常量 “” 做并运算 “+” 都将得到一个 String 对象
String str = 3.14 + "";
String 类的类方法 public static String valueOf()
实际上应用程序中的 main 方法中的参数 args 能接受用户从键盘输入的字符序列（String[] args）。
int number=8642;
String binaryString=Long.toBinaryString(number); // 转换成二进制形式的字符串
System.out.println(number+"的二进制表示:"+binaryString);
System.out.println(number+"的十六进制表示:"+Long.toString(number,16));
把数字转换成 String对象，就可调用很多的方法。
比如截取小数点后几位、输出浮点数有几位小数。
double pi = 3.1415926;
String numberStr = ""+pi;
int index1 = numberStr.indexOf("."); // 1 . 出现在字符串的位置
String zs = numberStr.substring(0,index1); // 3 截取 . 之前的字符串
String xs = numberStr.substring(index1+1); // 1415926 截取 . 之后的字符串
System.out.println(pi+"有"+zs.length()+"位整数,"+xs.length()+"位小数.");
9.1.4 对象的 String 表示
所有的类都默认是 java.lang 包中 0bject 类的子类或间接子类。
Object 类有一个 public String toString() 方法，一个对象通过调用该方法可以返回一个 String 对象，称这个 string 对象是当前对象的 String 表示。
一个对象调用 toString() 方法返回的 String 对象的字符序列的一般形式为
创建对象的类的名字 @ 对象的引用的字符序列表示
0bject 类的子类或间接子类也可以重写 toString() 方法。例如， java. util 包中的 Date 类就重写了 toString 方法，重写的方法返回时间的字符序列表示。
9.1.5 字符序列与字符、字节数组
字符数组
public void getChars( int start, int end, char c[], int offset ）
将当前 String 对象的字符序列中的一部分字符复制到参数 c 指定的数组中，将 String 对象的字符序列中从索引位置 start 到 end- 1 位置上的字符复制到数组中，并从数组的 offset 处开始存放这些字符。
需要注意的是，必须保证数组 c 能容纳下要被复制的字符。
char[] a, b, c;
String sss = "巴西足球队击败德国足球队";
a = new char[2];
sss.getChars(5, 7, a, 0); // 击败 字符串的 [5,7) 传给字符数组a（从0开始放）
System.out.println(a);
public char[] toCharArray()
String 对象调用该方法，将它的字符序列依次存放在一个字符数组的单元中，并返回该数组的引用。
c ="大家好，很高兴认识大家".toCharArray();
for(char ch:c)System.out.print(ch); // 大家好，很高兴认识大家
字节数组
String 类的构造方法 String(byte[]) 用指定的字节数组构造一个 String 对象。
String(byte[] , int offset , int length ）
构造方法用指定的字节数组的一部分，即从数组起始位置 offset 开始取 length 个字节构造一个 String 对象。
public byte() getBytes()
String 对象调用该方法，将它的字符序列转换为平台的默认编码，将编码依次存放在 byte 数组的单元中，并返回 byte 数组的引用。
byte d1[] = "abc你我他".getBytes();
System.out.println("数组d的长度是(gb2312编码,一个汉字占2个字节):" + d1.length);
String s11 = new String(d1, 3, 2); // 你 [3,3+2)
try {d1 = "abc你我他".getBytes("utf-8"); // 如果使用utf-8编码，一个汉字占3个字节System.out.println("数组d的长度是(utf-8编码,一个汉字占3个字节):" + d1.length);
} catch (Exception exp) {
}
9.2 正则表达式
一个正则表达式是含有一些具有特殊意义字符的字符序列，这些特殊字符称作正则表达式中的元字符。
public boolean matches(String regex)
判断当前 String 对象的字符序列是否和参数 regex 指定的正则表达式相匹配，即是否和 regex 的字符序列相匹配。
如果一个 String 对象的字符序列和regex 的字符序列相匹配，就简称 String 对象的字符序列和 regex 相匹配。
String regex1 = "\\dhello"; // \\d 匹配数字 后面的是匹配值
String str1 = "8hello";
System.out.println(str1.matches (regex1)); // \\d 匹配8 hello匹配hello
在正则表达式中可以用中括号括起若干个字符来表示一个元字符，该元字符代表中括号中的任何一个字符。
例如 String regex =“ [159]ABC ”，那么“ 1ABC ”、“ 5ABC ”和“ 9ABC ”都和 regex 相匹配。
元字符| 元字符 | 在正则表达式中的写法 | 意义 |
|---|---|---|
| . | “.” | 代表任何一个字符 |
| \d | “\\d” | 代表 0 ～ 9 的任何一个数字 |
| \D | “\\D” | 代表任何一个非数字字符 |
| \s | “\\s” | 代表空格类字符， ‘\t’ 、‘\n’、‘\x0B’、‘\f’、‘\r’ |
| \S | “\\S” | 代表非空格类字符 |
| \w | “\\w” | 代表可用于标识符的字符（不包括美元符号），任意一个字母、数字或下划线 |
| \W | “\\W” | 代表不能用于标识符的字符 |
| \p{Lower} | \\p{Lower} | 小写字母[a ~ z] |
| \p{Upper} | \\p{Upper} | 大写字母[A~Z] |
| \p{ASCII} | \\p{ASCII} | ASCII 字符 |
| \p{AIpha} | \\p{AIpha} | 字母 |
| \p{Digit} | \\p{Digit} | 数字字符， 即 [0~9] |
| \p{Alnum} | \\p{Alnum} | 字母或数字 |
| \p{Punct} | \\p{Punct} | 标点符号：!"#$%&'()*+,-./:;<=>?@[]^_`{ |
| \p{Graph} | \\p{Graph} | 可视字符： \p{Alnum}\p{Punct} |
| \p{Print} | \\p{Print} | 可打印字符： \p{Graph} |
| \p{Blank} | \\p{Blank} | 空格或制表符 [\t] |
| \p{Cntrl} | \\p{Cntrl} | 控制字符：[\x00 - \x1F\x7F] |
中括号元字符的意义如下：
- [abc] ：代表 a 、 b 、 c 中的任何一个。
- [^abc] ：代表除了 a 、 b 、 c 以外的任何字符。
- [a-zA-Z] ：代表英文字母中的任何一个。
- [a-d] ；代表 a ~ d 中的任何一个。
另外，中括号里允许嵌套中括号，可以进行并、交、差运算，举例如下
- [a-d[m-p]] ：代表 a~d 或 m~p 中的任何字符（并）。
- [a-z&&[def] ：代表 d 、e 或 f 中的任何一个（交）。
- [a-f&&[^bc]] ：代表 a 、 d 、 e 、 f （差 )。
注：由于“，”代表任何一个字符，所以在正则表达式中如果想使用普通意义的点字符，必须使用 **[.] 或 \\ **
String regex2 = "[abc]\\dhello"; // [abc]匹配a、b、c \\d 匹配数字 后面的是匹配值
String str2 = "a8hello";
System.out.println(str2.matches (regex2)); // a匹配[abc] \\d 匹配8String regex3 = "[^1234567890]\\dhello"; // [^123456789]匹配非数字 \\d 匹配数字 后面的是匹配值
String str3 = "%8hello";
System.out.println(str2.matches (regex3)); // %匹配[^123456789] \\d 匹配8 hello匹配hello
在正则表达式中可以使用限定修饰符。例如，对于限定修饰符“？"，如果 X 代表正则表达式中的一个元字符或普通字符，那么“ X ？”就表示 X 出现 0 次或 1 次，例如：
String regex = "hello[2468]?";
那么 "hello ” "hello 2 ” "hello 4 ” "hello 6 ” "hello 8 ”都与 regex 相匹配。
（即出现0或1次都成立）
限定符| 带限定符号的模式 | 意义 |
|---|---|
| X? | X 出现 0 次或 1 次 |
| X* | X 出现 0 次或多次 |
| X+ | X 出现 1 次或多次 |
| X{n} | X 恰好出现 n 次 |
| X{n,} | X 至少出现 n 次 |
| X{n,m} | X 出现 n~m 次 |
| XY | X 的后缀是 Y |
| X|Y | X 或 Y |
// 下面这个例子输出true，虽然比较抽象
// 匹配一个或多个由字母数字字符和一个标点符号组成的字符串。String regex4 = "(\\p{Alnum}+\\p{Punct}{1})+";String str4 = "hello123abc,hi456!";
// 字符串中有两个匹配项："hello123abc," 和 "hi456!"。
// 这两个匹配项都是由字母数字字符和一个标点符号组成的。
// 由于正则表达式要求匹配项出现一次或多次，因此整个字符串被视为匹配项。System.out.println(str4.matches(regex4)); // trueString regex5 = "[a-zA-Z0-9]"; // 匹配一个单个的字母、数字字符String str5 = "h";System.out.println(str5.matches(regex5)); // 字母出现，匹配String str51 = "A";System.out.println(str51.matches(regex5)); // 字母出现，匹配String str52 = "8";System.out.println(str52.matches(regex5)); // 数字都出现，匹配String regex6 = "[a-zA-Z0-9]+"; // 匹配一个或多个字母数字字符的字符串String str6 = "hello1";System.out.println(str6.matches(regex6)); // 一个或多个字母数字存在，匹配String regex7 = "([a-zA-Z0-9]+)+"; // 匹配一个或多个由字母数字字符组成的字符串String str7 = "hello1hi2";System.out.println(str7.matches(regex7)); // 一个或多个由字母数字字符组成的字符串存在，匹配
9.2.2 常用的正则表达式
匹配形如 整数 的正则表达式
String regex = "-?[1-9]\\\d + "; // -?表示0或1个-号，即正负性。[1~9]表示出现1~9，即首位不能为0。\\\d+表示数字任意排列。
限定为n位数，就将+改为{n-1}。
匹配形如 浮点数 的正则表达式
String regex = "-?[0-9][0-9]*[.][0-9]+";
匹配形如 整数和浮点数 的正则表达式
String regexnum = "-?[0-9]\\d*[.]?[0-9]+"; // 匹配整数和浮点数 最后的应该是*，但测试有发现怪怪的
String strnum = "-0123";
System.out.println(strnum.matches(regexnum)); // 匹配
匹配形如 email 的正则表达式
// 邮箱的规范
// \\w 表示可用于标识符的字符，即任意一个字母、数字或下划线
// 域名只能是字母，当然后面也可能存在二级域名
String regexemail = "\\w+@\\w+\\.[a-z]+(\\.[a-z]+)?"; // @前面是标识符，后面是标识符，点后面是域名
String stremail = "229600398@qq.com";
System.out.println(stremail.matches(regexemail)); // 匹配
匹配身份证号码的正则表达式
这里给出匹配 18 位身份证号码（最后一位是数字或字母）的正则表达式。
String regex = "\[1-9][0-9]{16}[a-zA-Z0-9]{1}"
匹配日期的正则表达式
不考虑二月的特殊情况，给出匹配日期（年限制为 4 位）的正则表达式。
正则表达式不能加判断，其实只能检测输入是否有错误，不能判断符合日期的详细规范。
String year = "[1-9][0-9]{3}"; // 年份不能0开头
String month = "((0?[1,9])|1(012))";
String day = "((0?[1,9])|(12[0-9])|(3[01]?))";
String regex = year + "[-./]" + month + "[-./]" + day;
9.2.3 字符序列的替换与分解
public String replaceAII( String regex, String replacement)
方法返回一个新的 S tring 对象，返回的 String 对象的字符序列是把当前 String 对象的字符序列中，所有和参数 regex 相匹配的子字符序列替换成参数 replacement 指定的字符序列所得到的字符序列。
String s3 = "12hello567";
String result = s3.replaceAll("\\d+","你好。");
System.out.println(result); // 你好。hello你好。
注：当前 String 对象 s 调用 replaceAll() 方法返回一个新的 String 对象，不改变当前String 对象 s 的字符序列。
public String[] split(String regex)
String 对象调用该方法时，使用参数指定的正则表达式 regex 作为分隔标记，分解出 String 对象的字符序列中的单词，并将分解出的单词存放在 String 数组中。
如果准备分解出全部由数字字符组成的单词，则必须用非数字字符序列作为分隔标记，因此，可以使用正则表达式：
String regex = "\\D +";
需要特别注意的是， split 方法认为分隔标记的左右是单词，额外规则是，如果左面的单词是不含任何字符的字符序列，这个字符序列仍然算成一个单词，但右边的单词心须是含有字符的字符序列。
String str8 = "请记住 1931 年 09 月 18日晚，日本发动侵华战争，请记住这个日子！";
String regex = "\\D+";
String words[] = str8.split(regex);
for(int i=0;i0)System.out.println(words[i]);
}
//1931
//09
//18
9.3 StringTokenizer 类
使用 java. util 包中的 StringTokenizer 类的对象分解字符序列（将字符序列分解成可被独立使用的单词）。
和 split() 方法不同的是， StringTokenizer 对象不使用正则表达式做分隔标记。
该类的对象是一个字符序列分析器，该类有两个构造方法。
- StringTokenizer(String s) ：构造一个 StringTokeizer 对象，例如 fenxi。 fenxi 使用默认的分隔标记（空格符、换行符、回车符、 Tab 符、进纸符）分解出参数 s 的字符序列中的单词，即这些单词成为 fenxi 中的数据。
- StringTokenizer(String s , String delim) ：构造一个 StringTokeizer 对象，例如 fenxi。fenxi 用参数 dilim 的字符序列中的字符的任意排列作为分隔标记，分解出参数 s 的字符序列中的单词，即这些单词成为中的数据
注：分隔标记的任意排列仍然还是分隔标记。
常用方法：
-
fenxi 调用 String nextToken() 方法逐个获取 fenxi 中的单词。
-
fenxi 调用 boolean hasMoreTokens() 方法可以返回一个 boolean 值，只要 fenxi 中还有单词，该方法就返回 true ，否则返回 false。
-
fenxi 调用 countTokens() 方法可以返回当前 fenxi 中单词的个数。
// 分别输出字符序列中的单词，并统计出单词个数。
String s4 = "we are stud,ents";
StringTokenizer fenxi = new StringTokenizer(s4, " ,"); // 用空格和逗号的任意组合作为分隔标记
int number1 = fenxi.countTokens();
while (fenxi.hasMoreTokens()) { // 类似堆栈取值，拿出一个少一个String str9 = fenxi.nextToken();System.out.println(str9);System.out.println("还剩" + fenxi.countTokens() + "个单词");
}
System.out.println("s共有单词：" + number1 + "个");
//we
//还剩3个单词
//are
//还剩2个单词
//stud
//还剩1个单词
//ents
//还剩0个单词
//s共有单词：4个//计算话费
String s5 = "市话费:28.89圆,长途话费:128.87圆,上网费:298圆。";
String delim = "[^0-9.]+"; // 非数字序列都匹配delim
s5 = s5.replaceAll(delim, "#"); // #28.89#128.87#298#
StringTokenizer fenxi1 = new StringTokenizer(s5, "#");// 用#字符作为分隔标记
double totalMoney = 0;
while (fenxi1.hasMoreTokens()) {double money = Double.parseDouble(fenxi1.nextToken());System.out.println(money); // 28.89 128.87 298.0totalMoney += money;
}
System.out.println("总费用：" + totalMoney + "圆"); // 总费用：455.76圆
9.4 Scanner 类
scanner 默认地使用空格作为分隔标记来解析 s 的字符序列中的单词。
也可以让Scanner Scanner 对象调用方法正则表达式
useDelimiter(正则表达式);
将正则表达式作为分隔标记，即 Scanner 对象在解析 s 的字符序列时，把与正则表达式匹配的字符序列作为分隔标记。
特点如下：
-
scanner 调用 next () 方法依次返回 s 的字符序列中的单词，如果最后一个单词已被next() 方法返回。scanner 调用 hasNext() 将返回 false ，否则返回 true。
-
对于 s 的字符序列中的数字型的单词，例如 876 ， 2398.89 等 ，scanner 可以用 nextlnt()或 nextDouble()方法来代替 next()方法，即 scanner 可以调用 nextlnt()或nextDouble()方法将数字型单词转化为 int 或 double 数据返回。
-
如果单词不是数字型单词， scanner 调用 nextlnt() 或 nextDouble() 方法将发生InputMismatchException 异常，在处理异常时可以调用 next() 方法返回该非数字化单词。
String cost = "话费清单：市话费76.89元，长途花费167.38元，短信费12.68元。";
Scanner scanner = new Scanner(cost);
scanner.useDelimiter("[^0123456789.]+"); // scanner设置分隔标记
double sum = 0;
while (scanner.hasNext()) {try {double price = scanner.nextDouble(); // 这一步是需要的，因为满足正则表达式的不一定是double数，比如....sum = sum + price;System.out.println(price); // 76.89 167.38 12.68} catch (InputMismatchException exp) {String t = scanner.next();}
}
System.out.println("总费用:" + sum + "圆"); // 总费用:256.95圆
StringTokenizer类 和 Scanner类 的区别
-
StringTokenizer 类把分解出的全部单词都存放到 StringTokenizer 对象的实体中，能快速地获得单词，但占用较多的内存
-
Scanner 类不把单词存放到对象的实体中，而是仅仅存放怎样获取单词的分隔标记，获得单词的速度相对较慢，但节省内存空间
-
StringTokenizer 对象一旦诞生就立刻知道单词的数目，使用 countTokens() 方法返回单词的数目。
-
Scanner 类不能提供这样的方法。如果想知道单词的数目，就必须一个一个地获取，并记录单词的数目。
9.5 Pattern 与 Matcher 类
模式匹配就是检索和指定模式匹配的字符序列。
Matcher 类的对象直接检索出和 Pattern 类的对象匹配的 String 对象。
Pattern 模式对象
使用正则表达式 regex 作为参数得到一个称为模式的 Pattern 类的实例 pattern。
（相当于对正则表达式的封装）
String regex = "\\w+@\\w+\\.[a-z]+(\\.[a-z]+)?";
Pattern pattern = Pattern.compile(regex);
matcher 对象
pattern 得到可用于检索 input 的 Matcher 类的实例 matcher( 称为匹配对象）。
Matcher matcher = pattern.matcher(input);
模式对象 pattern 调用 matcher （ CharSequence input) 方法返回一个 Matcher 对象，称为匹配对象，参数 input 是 matcher 要检索的 String 对象。
之后，对象 matcher 就可以调用各种方法检索 input。
常用方法：
public boolean find()
matcher 依次调用 booelan find() 方法，检索 input 的字符序列中和 regex匹配的子字符序列。
int statrt() 和 int end()
得到 find() 方法检索到的字符序列的开始和结束位置。
String group()
matcher. group() 返回的 String 对象，该对象的字符序列是 find() 方法在 input 的字符序列中找到的匹配 regex 的子字符序列。
其他方法：P242
Pattern pattern; // 模式对象
Matcher matcher; // 匹配对象
String regex8 = "-?[0-9][0-9]*[.]?[0-9]*";// 匹配数字,整数或浮点数的正则表达式
pattern = Pattern.compile(regex8); // 初试化模式对象
String input = "市话：76.89元，长途67.38元，短信12.68元。";
matcher = pattern.matcher(input); // 初始化匹配对象,用于检索input
double sum1 = 0;
while (matcher.find()) {String str9 = matcher.group();sum1 += Double.parseDouble(str9);System.out.print("从" + matcher.start() + "到" + matcher.end() + "匹配的子序列:");System.out.println(str9);
}
System.out.println("通信总费用:" + sum1 + "元");
String[] weatherForecast = { "北京:-9度至7度", "广州:10度至21度", "阿尔滨:-29度至-7度" };
double averTemperture[] = new double[weatherForecast.length];// 存放三地的平均气温
for (int i = 0; i < weatherForecast.length; i++) {matcher = pattern.matcher(weatherForecast[i]);sum1 = 0;int count = 0;while (matcher.find()) {count++;sum1 = sum1 + Double.parseDouble(matcher.group());}averTemperture[i] = sum1 / count; // 计算出平均气温，并存放到数组的单元中
}
System.out.println("三地的平均气温:" + Arrays.toString(averTemperture));
Arrays.sort(averTemperture);
System.out.println("三地的平均气温(升序):" + Arrays.toString(averTemperture));//从3到8匹配的子序列:76.89
//从12到17匹配的子序列:67.38
//从21到26匹配的子序列:12.68
//通信总费用:156.95元
//三地的平均气温:[-1.0, 15.5, -18.0]
//三地的平均气温(升序):[-18.0, -1.0, 15.5]
9.6 StringBuffer 类
String 类是 final 类，不提供修改字符序列的方注，也就是说， String 对象不能修改、删除、或替换字符序列中的某个字符，即 String 对象一旦创建，那么实体是不可以再发生变化的，称这样的对象是不可变对象。
StringBuffer 类
该类的对象的实体的内存空间可以自动的改变大小，便于存放一个可变的字符序列。
常用方法
-
StringBuffer insert (int index ， String str)
将参数 str 指定的字符列插入到参数 index 指定的位置，并返回当前对象的引用。
-
public StringBuffer reverse()
reverse() 方法将该对象实体中的字符翻转，并返回当前对象的引用。
-
StringBuffer delete(int startlndex ， int endlndex)
-
StringBuffer replace( int startlndex ， int endlndex ， String str)
将当前 StringBuffer 对象的 startlndex 到 endlndex - 1 的字符序列替换成参数 str 指定的字符序列，并返回当前 StringBuffer 对象的引用。
StringBuffer str9 = new StringBuffer("he like Java");
str9.setCharAt(0, 'w');
str9.setCharAt(1, 'e');
System.out.println(str9); // we like Java
str9.insert(2, " all");
System.out.println(str9); // we all like Java
int index2 = str9.indexOf("Java");
str9.replace(index2, str9.length(), "apple");
System.out.println(str9); // we all like apple
9.7 日期与时间
LocalDate 、 LocalDateTime 和 LocalTime 类的对象封装和日期、时间有关的数据（如年、月、日、时、分、秒、纳秒和星期等），这 3 个类都是 final 类，而且不提供修改数据的方法，即这些类的对象的实体是不可再发生变化的，属于不可变对象（和 String 类似）。
LocalDate
LocalDate 调用 now() 方法可以返回一个 LocalDate 对象，该对象封装本地当前日期有关的数据（年、月、日、星期等）。
LocaIDate 调用 LocaIDate of(int year ， int month ， int dayOfMonth) 方法可以返回一个LocalDate 对象，该对象封装参数指定日期有关的数据（年、月、日、星期等）。
LocaIDateTime
LocaIDateTime 相对 LocalDate 类， LocalDateTime 类的对象中还可以封装时、分、秒和纳秒（ 1 纳秒是 1秒的 10 亿分之一）等时间数据。
LocalDateTime 调用 LocaIDateTime of(int year ， int month ， int dayOfMonth ， int hour ，int minute ， int second ， int nanoOfSecond ）方法可以返回一个 LocaIDateTime 对象，该对象封装参数指定日期有关的数据（年、月、日、星期、时、分、秒等）。
LocaITime
相对 LocalDateTime 类的对象， LocalTime 只封装时、分、秒和纳秒等时间数据。
注： LocaITime 、 LocaIDateTime 、 LocaIDate 类都重写了 toString() 方法，例如对于LocalDate 对象 date ， System. out. println(date) 将输出 date 封装的数据，而不是 date 变量中的引用信息。
LocaIDate 对象 date 也可以调用 int compareTo(LocaIDate other) 方法与 other 比较大小，规则是：按年、月、日三项的顺序进行比较。
不想记了，应该不咋考吧。。。
9.8 Math 、 BigInteger 和 Random 类
9.8.1 Math 类
java. lang包中的 Math 类包含许多用来进行科学计算的类方法，这些方法可以直接通过类名调用。
相关类方法见书P254
9.8.2 Biglnteger类
程序有时需要处理大整数， java.math 包中的 Biglnteger 类提供任意精度的整数运算。
可以使用构造方法,构造一个十进制的 BigInteger 对象。
public BigInteger(String val)
相关类方法见书P254
9.8.3 Random 类
尽管可以使用 Math 类调用其类方法 random() 返回一个 0 ～ 1 的随机数（包括 0 ，但不包括 1），即随机数取值范围是[ 0.0 ， 1. 0 ）的左闭右开区间。
(int)(Math.random().100)+1; // 得到 1 ～ 100 的一个随机整数（包括 1 和 100 ）
但是， Java 提供了更为灵活的用于获得随机数的 Random 类。人们习惯地将 Random 对象称为随机数生成器。
// 构造方法
public Random(); // 用计算机本机的时间做种子（将时间转化为毫秒，即从 1970-1-1 到当前时刻所需要的毫秒数
pubiic Random(long seed); // 使用参数 seed 指定的种子创建一个 Random 对象// 调用不带参数的 nextlnt()方法返回一个随机整数
Random = new Random();
random.nextInt();random.nextlnt(100); // 返回一个 0~m（包括 0 ，但不包括 m) 的随机数 , 参数 m 必须取正整数random.nextBoolean(); // 随机得到 true 和 false 两个表示真和假的 boolean 值
注：需要注意的是，对于具有相同种子的两个 Random 对象，二者依次调用 nextlnt() 方法获取的随数序列是相同的。
Random random = new Random(19);
Random random1 = new Random(19); // 两者使用的种子相同，所以返回的值相同
System.out.println(random.nextInt(100)); // 25
System.out.println(random1.nextInt(100)); // 25
System.out.println(random.nextInt(100)); // 44
System.out.println(random1.nextInt(100)); // 44
9.9 小结
- 熟练掌握 String 类的常用方法，处理字符序列信息。
- 熟悉正则表达式中常用的元字符和限定符，以及常用的正则表达式。
- 掌握 String 类和 StringBuffer 类的不同，以及二者之间的联系。
- StringTokenizer 和 Scanner 类分析字符序列，获取字符序列中被分隔符分隔开的单词。
- 当程序需要处理日期时间时，使用 LocalDate 、 LocalDateTime 和 LocalTime 类。
- 如果需要处理特别大的整数，使用 BigInteger 类。
- 当需要模式匹配时，使用 Pattern 和 Match 类。
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！