第8章 常用实用类

主要内容

基本内容：
◆ String类
◆ StringTokenizer类
◆ Scanner类
§8.1 String类
Java专门提供了用来处理字符序列的String类。
String类在java.lang包中，由于java.lang包中的类被默认引入，因此程序可以直接使用String类。
需要注意的是Java把String类声明为final类，因此用户不能扩展String类，即String类不可以有子类。
8.1.1 构造String对象
String对象，习惯地被翻译为字符串对象。
1．常量对象
2．String对象
3．引用String常量
8.1.2 字符串的并置
String对象可以用"+"进行并置运算，即首位相接得到一个新的String对象。
例子1
Example8_1.java

public class Example8_1 {
public static void main(String args[]) {
String hello = “你好”;
String testOne = “你”+“好”; //【代码1】
System.out.println(hello == testOne); //输出结果是true
System.out.println(“你好” == testOne); //输出结果是true
System.out.println(“你好” == hello); //输出结果是true
String you = “你”;
String hi = “好”;
String testTwo = you+hi; //【代码2】
System.out.println(hello == testTwo); //输出结果是false
String testThree = you+hi;
System.out.println(testTwo == testThree); //输出结果是false
}
}
8.1.3 String类的常用方法
1．public int length()
2．public boolean equals(String s)
下面的例子2说明了equals的用法。
例子2
Example8_2.java

public class Example8_2 {
public static void main(String args[]) {
String s1,s2;
s1 = new String(“天道酬勤”);
s2 = new String(“天道酬勤”);
System.out.println(s1.equals(s2)); //输出结果是：true
System.out.println(s1s2); //输出结果是：false
String s3,s4;
s3 = “we are students”;
s4 = new String(“we are students”);
System.out.println(s3.equals(s4)); //输出结果是：true
System.out.println(s3s4); //输出结果是：false
String s5,s6;
s5 = “勇者无敌”;
s6 = “勇者无敌”;
System.out.println(s5.equals(s6)); //输出结果是：true
System.out.println(s5==s6); //输出结果是：true
}
}

3．public boolean startsWith(String s)、public boolean endsWith(String s)方法

4．public int compareTo(String s)方法
按字典序比较两个String对象还可以使用public int compareToIgnoreCase(String s)方法，该方法忽略大小写。
下面的例子3中使用java.util包中的Arrays调用sort方法和自己编写SortString类中的sort方法将一个String数组按字典序排列。
例子3
SortString.java

public class SortString {
public static void sort(String a[]) {
int count = 0;
for(int i=0;i<a.length-1;i++) {
for(int j=i+1;j<a.length;j++) {
if(a[j].compareTo(a[i])<0) {
String temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
}
}

Example8_3.java

import java.util.*;
public class Example8_3 {
public static void main(String args[]) {
String [] a = {“melon”,“apple”,“pear”,“banana”};
String [] b = {“西瓜”,“苹果”,“梨”,“香蕉”};
System.out.println(“使用SortString类的方法按字典序排列数组a:”);
SortString.sort(a);
for(int i=0;i<a.length;i++) {
System.out.print(" “+a[i]);
}
System.out.println(”");
System.out.println(“使用类库中的Arrays类，按字典序排列数组b:”);
Arrays.sort(b);
for(int i=0;i<b.length;i++) {
System.out.print(" "+b[i]);
}
}
}

5．public boolean contains(String s)
6．public int indexOf (String s)和public int lastIndexOf(String s)
7．public String substring(int startpoint)
8．public String trim()
8.1.4 字符串与基本数据的相互转化
java.lang包中的Integer类调用其类方法public static int parseInt(String s)可以将由“数字”字符组成的字符序列，如"876"，转化为int型数据，例如：

int x;
String s = “876”;
x = Integer.parseInt(s);

例子4求若干个数之和，若干个数从键盘输入。
例子4
Example8_4.java

public class Example8_4 {
public static void main(String args[]) {
double sum=0,item=0;
boolean computable=true;
for(String s:args) {
try{ item=Double.parseDouble(s);
sum=sum+item;
}
catch(NumberFormatException e) {
System.out.println(“您输入了非数字字符:”+e);
computable=false;
}
}
if(computable)
System.out.println(“sum=”+sum);
}
}

8.1.5 对象的字符串表示
下面例子5中的TV类重写了toString()方法，并使用super调用隐藏的toString()方法。
例子5
TV.java

public class TV {
double price ;
public void setPrice(double m) {
price = m;
}
public String toString() {
String oldStr = super.toString();
return oldStr+"\n这是电视机，价格是:"+price;
}
}

Example8_5.java

public class Example8_5 {
public static void main(String args[]) {
Date date = new Date();
System.out.println(date.toString());
TV tv = new TV();
tv.setPrice(5897.98);
System.out.println(tv.toString());
}
}

8.1.6 字符串与字符、字节数组
1．字符串与字符数组
例子6具体地说明了getChars()和toCharArray()方法的使用。
例子6
Example8_6.java

public class Example8_6{
public static void main(String args[]) {
char [] a,c;
String s=“1945年8月15日是抗战胜利日”;
a = new char[4];
s.getChars(11,15,a,0);//数组a的单元依次放的字符是’抗’，‘战’，胜’，‘利’。
System.out.println(a);
c = “十一长假期间，学校都放假了”.toCharArray();
for(int i=0;i<c.length;i++)
System.out.print(c[i]);
}
}

2．字符串与字节数组
在下面的例子7中，假设机器的默认编码是GB2312。String常量：“Java你好”，调用getBytes()返回一个字节数组d，其长度为8，该字节数组的d[0]、d[1]、d[2]和d[3]单元分别是字符J、a、v和a的编码，第d[4]和d[5]单元存放的是字符’你’的编码（GB2312编码中，一个汉字占2个字节），第d[6]和d[7]单元存放的是字符’好’的编码。
例子7
Example8_7.java

public class Example8_7 {
public static void main(String args[]) {
byte d[]=“Java你好”.getBytes();
System.out.println(“数组d的长度是:”+d.length);
String s=new String(d,6,2); //输出：好
System.out.println(s);
s=new String(d,0,6);
System.out.println(s); //输出：Java你
}
}

3．字符串的加密算法
例子8
EncryptAndDecrypt.java

public class EncryptAndDecrypt {
String encrypt(String sourceString,String password) { //加密算法
char [] p = password.toCharArray();
int n = p.length;
char [] c = sourceString.toCharArray();
int m = c.length;
for(int k=0;k<m;k++){
int mima = c[k]+p[k%n]; //加密
c[k] = (char)mima;
}
return new String©; //返回密文
}
String decrypt(String sourceString,String password) { //解密算法
char [] p = password.toCharArray();
int n = p.length;
char [] c = sourceString.toCharArray();
int m = c.length;
for(int k=0;k<m;k++){
int mima = c[k]-p[k%n]; //解密
c[k] = (char)mima;
}
return new String©; //返回明文
}
}

Example8_8.java

import java.util.Scanner;
public class Example8_8 {
public static void main(String args[]) {
String sourceString = “今晚十点进攻”;
EncryptAndDecrypt person = new EncryptAndDecrypt();
System.out.println(“输入密码加密:”+sourceString);
Scanner scanner = new Scanner(System.in);
String password = scanner.nextLine();
String secret = person.encrypt(sourceString,password);
System.out.println(“密文:”+secret);
System.out.println(“输入解密密码”);
password = scanner.nextLine();
String source = person.decrypt(secret,password);
System.out.println(“明文:”+source);
}
}

8.1.7 正则表达式及字符串的替换与分解
1．正则表达式
正则表达式是一个String对象的字符序列，该字符序列中含有具有特殊意义字符，这些特殊字符称做正则表达式中的元字符。
表8.1列出了常用的元字符及其意义。
注：有关正则表达式的细节可查阅java.util.regex包中的Pattern类。
例子9程序判断用户从键盘输入的字符序列是由英文字母，数字或下划线所组成。
例子9
Example8_9.java

import java.util.Scanner;
public class Example8_9 {
public static void main (String args[ ]) {
String regex = “[a-zA-Z|0-9|_]+”;
Scanner scanner = new Scanner(System.in);
String str = scanner.nextLine();
if(str.matches(regex)) {
System.out.println(str+“是英文字母,数字或下划线构成”);
}
else {
System.out.println(str+“中有非法字符”);
}
}
}

2．字符串的替换
String对象调用public String replaceAll(String regex,String replacement)方法返回一个新的String对象，这个新的String对象的字符序列是把当前String对象的字符序列中所有和参数regex匹配的子字符序列，用参数replacement的字符序列替换后得到字符序列。

在下面的例子10中使用了replaceAll()方法。
例子10
Example8_10.java

public class Example8_10 {
public static void main (String args[ ]) {
String str = “欢迎大家访问http://www.xiaojiang.cn了解、参观公司”;
String regex = “(http://|www)\56?\w+\56{1}\w+\56{1}\p{Alpha}+”;
System.out.printf(“替换\n”%s"\n中的网站链接信息后得到的字符串:
\n",str);
str = str.replaceAll(regex,"******");
System.out.println(str);
String money = “89,235,678￥”;
System.out.print(money+“转化成数字:”);
String s = money.replaceAll("[,\p{Sc}]","") ; //"\p{Sc}"可匹配任何
货币符号
long number = Long.parseLong(s);
System.out.println(number);
}
}

3．字符序列的分解
String类提供了一个实用的方法public String[] split(String regex)，String对象调用该方法时，使用参数指定的正则表达式regex作为分隔标记分解出当前String对象的字符序列中的单词，并将分解出的单词存放在String数组中。
下面的例子11中，用户从键盘输入一行文本，程序输出其中的单词。用户从键盘输入 who are you(Caven?) 观察运行效果。
例子11
Example8_11.java

import java.util.Scanner;
public class Example8_11 {
public static void main (String args[ ]) {
System.out.println(“一行文本:”);
Scanner reader=new Scanner(System.in);
String str = reader.nextLine();
//regex匹配由空格、数字和!"#$%&’()*+,-./:;<=>?@[]^_`{|}~组成的字符序列
String regex = “[\s\d\p{Punct}]+”;
String words[] = str.split(regex);
for(int i=0;i<words.length;i++){
int m = i+1;
System.out.println(“单词”+m+":"+words[i]);
}
}
}
8.2 StringTokenizer类
当分析一个String对象的字符序列并将字符序列分解成可被独立使用的单词时，可以使用java.util包中的StringTokenizer类，该类有两个常用的构造方法。
• StringTokenizer(String s)：
• StringTokenizer(String s, String delim)：
例子12计算购物小票的中的商品价格的和。程序关心是购物小票中的数字，因此需要分解出这些数字，以便单独处理，这样就需要把非数字的字符序列替换成统一的字符，以便使用分隔标记分解出数字，例如，对于"12#25#39.87"，如果用字符#做分隔标记，就很容易分解出数字单词。在例子12的PriceToken类中，把购物小票中非数字的字符序列都替换成#，然后再分解出数字单词（价格），并计算出这些数字的和。
例子12
Example8_12.java

import java.util.*;
public class Example8_12 {
public static void main(String args[]) {
String shoppingReceipt = “牛奶:8.5圆,香蕉3.6圆，酱油:2.8圆”;
PriceToken lookPriceMess = new PriceToken();
System.out.println(shoppingReceipt);
double sum =lookPriceMess.getPriceSum(shoppingReceipt);
System.out.printf(“购物总价格%-7.2f”,sum);
int amount = lookPriceMess.getGoodsAmount(shoppingReceipt);
double aver = lookPriceMess.getAverPrice(shoppingReceipt);
System.out.printf("\n商品数目:%d,平均价格:%-7.2f",amount,aver);
}
}
PriceToken.java

iimport java.util.*;
public class PriceToken {
public double getPriceSum(String shoppingReceipt) {
String regex = “[^0123456789.]+”; //匹配非数字字符序列
shoppingReceipt = shoppingReceipt.replaceAll(regex,"#");
//replaceAll方法见8.1.6节的例子10
StringTokenizer fenxi = new StringTokenizer(shoppingReceipt,"#");
double sum = 0;
while(fenxi.hasMoreTokens()) {
String item = fenxi.nextToken();
double price = Double.parseDouble(item);
sum = sum + price;
}
return sum;
}
public double getAverPrice(String shoppingReceipt){
double priceSum = getPriceSum(shoppingReceipt);
int goodsAmount = getGoodsAmount(shoppingReceipt);
return priceSum/goodsAmount;
}
public int getGoodsAmount(String shoppingReceipt) {
String regex = “[^0123456789.]+”;
shoppingReceipt = shoppingReceipt.replaceAll(regex,"#");
StringTokenizer fenxi = new StringTokenizer(shoppingReceipt,"#");
int amount = fenxi.countTokens();
return amount;
}
}
8.3 Scanner类
本节学习怎样使用Scanner类的对象从字符序列中解析出程序所需要的数据。
1． Scanner对象
Scanner对象可以解析字符序列中的单词
下面的例子13使用正则表达式：
String regex= “[^0123456789.]+” //（匹配所有非数字字符序列）
作为分隔标记，解析"市话76.8元,长途:167.38元,短信12.68元"，以及"牛奶:8.5圆,香蕉3.6圆，酱油:2.8圆"中的价格，并计算价格之和。
例子13
Example8_13.java

public class Example8_13 {
public static void main(String args[]) {
String cost = “市话76.8元,长途:167.38元,短信12.68元”;
double priceSum = GetPrice.givePriceSum(cost);
System.out.printf("%s\n总价:%.2f圆\n",cost,priceSum);
cost = “牛奶:8.5圆,香蕉3.6圆，酱油:2.8圆”;
priceSum = GetPrice.givePriceSum(cost);
System.out.printf("%s\n总价:%.2f圆\n",cost,priceSum);
}
}
GetPrice.java

import java.util.*;
public class GetPrice {
public static double givePriceSum(String cost){//static方法，类名可调用
Scanner scanner = new Scanner(cost);
scanner.useDelimiter("[^0123456789.]+"); //scanner设置分隔标记
double sum=0;
while(scanner.hasNext()){
try{ double price = scanner.nextDouble();
sum = sum+price;
}
catch(InputMismatchException exp){
String t = scanner.next();
}
}
return sum;
}
}
2．StringTokenizer和Scanner的区别

本次课总结
熟练掌握String类的常用方法。
掌握String类的和StringBuffer类的不同，以及二者之间的联系。
使用StringTokenizer，Scannner类分析字符串，获取字符串中被分隔符分隔的单词。

8.4 StringBuffer类
8.4.1 StringBuffer对象
与String类不同，StringBuffer类的对象的实体的内存空间可以自动地改变大小，便于存放一个可变的字符序列。
StringBuffer类有三个构造方法：
StringBuffer()
StringBuffer(int size)
StringBuffer(String s)
8.4.2 StringBuffer类的常用方法
1．append方法
2．public char charAt(int n)和public void setCharAt(int n , char ch)
3．StringBuffer insert(int index, String str)
4．public StringBuffer reverse()
5．StringBuffer delete(int startIndex, int endIndex)
6．StringBuffer replace( int startIndex ,int endIndex, String str)
下面的例子14使用StringBuffer类的常用方法，运行效果如图8.18。
例子14
Example8_14.java
public class Example8_14 {
public static void main(String args[]) {
StringBuffer str=new StringBuffer();
str.append(“大家好”);
System.out.println(“str:”+str);
System.out.println(“length:”+str.length());
System.out.println(“capacity:”+str.capacity());
str.setCharAt(0 ,‘w’);
str.setCharAt(1 ,‘e’);
System.out.println(str);
str.insert(2, " are all");
System.out.println(str);
int index=str.indexOf(“好”);
str.replace(index,str.length()," right");
System.out.println(str);
}
}
8.5 Date与Calendar类
程序设计中可能需要日期、时间等数据，本节介绍java.util包中的Date和Calendar类，二者的实例可用于处理和日期、时间相关的数据。
8.4.1 Date类
1．使用无参数构造方法
2．使用带参数的构造方法
8.4.2 Calendar类
Calendar类在java.util包中。使用Calendar类的static方法getInstance()可以初始化一个日历对象。
下面的例子15计算了2012-9-01和2016-07-01之间相隔的天数。
例子15
Example8_15.java
import java.util.;
public class Example8_15 {
public static void main(String args[]) {
Calendar calendar=Calendar.getInstance();
calendar.setTime(new Date());
int year = calendar.get(Calendar.YEAR),
month = calendar.get(Calendar.MONTH)+1,
day = calendar.get(Calendar.DAY_OF_MONTH),
hour = calendar.get(Calendar.HOUR_OF_DAY),
minute = calendar.get(Calendar.MINUTE),
second = calendar.get(Calendar.SECOND);
System.out.print(“现在的时间是：”);
System.out.print(""+year+“年”+month+“月”+day+“日”);
System.out.println(" "+hour+“时”+minute+“分”+second+“秒”);
int y = 2012,m = 9,d = 1;
calendar.set(y,m-1,d); //将日历翻到2012年九月一日,注意8表示九月
long time1 = calendar.getTimeInMillis();
y = 2016;
m = 7;
day = 1;
calendar.set(y,m-1,d); //将日历翻到2016年七月一日
long time2 = calendar.getTimeInMillis();
long subDay = (time2-time1)/(1000606024);
System.out.println(""+new Date(time2));
System.out.println(“与”+new Date(time1));
System.out.println(“相隔”+subDay+“天”);
}
}
下面的例子16输出2022年6月的日历。
例子16
Example8_16.java
public class Example8_16 {
public static void main(String args[]) {
CalendarBean cb = new CalendarBean();
cb.setYear(2022);
cb.setMonth(6);
String [] a = cb.getCalendar(); //返回号码的一维数组
char [] str = “日一二三四五六”.toCharArray();
for(char c:str) {
System.out.printf("%3c",c);
}
for(int i=0;i<a.length;i++) { //输出数组a
if(i%7==0)
System.out.println(""); //换行
System.out.printf("%4s",a[i]);
}
}
}

CalendarBean.java

import java.util.Calendar;
public class CalendarBean {

int year=0,month=0;
public void setYear(int year) {
this.year=year;
}
public void setMonth(int month) {
this.month=month;
}
public String [] getCalendar() {
String [] a=new String[42];
Calendar rili=Calendar.getInstance();
rili.set(year,month-1,1);
int weekDay=rili.get(Calendar.DAY_OF_WEEK)-1; //计算出1号的星期
int day=0;
if(month1||month3||month5||month7| |month8||month10|
|month12)
day=31;
if(month4||month6||month9||month11)
day=30;
if(month2) {
if(((year%40)&&(year%100!=0))||(year%4000))
day=29;
else
day=28;
}
for(int i=0;i<weekDay;i++)
a[i]=" “;
for(int i=weekDay,n=1;i<weekDay+day;i++) {
a[i]=String.valueOf(n) ;
n++;
}
for(int i=weekDay+day;i<a.length;i++)
a[i]=” ";
return a;
}
}
8.6 日期的格式化
程序可能希望按着某种习惯来输出时间，比如时间的顺序：年 月 星期 日或年 月 星期 日 小时 分 秒。可以直接使用String类调用format方法对日期进行格式化。
8.6.1 format方法
format方法：
format(格式化模式,日期列表)
1．格式化模式
2．日期列表
3．格式化同一日期

8.6.2 不同区域的星期格式
不同国家的星期的简称或全称有很大的不同，例如，美国用Thu简称星期四，日本用“木”简称星期四，意大利用gio简称星期四等。如果想用特定地区的星期格式来表示日期中的星期，可以用format的重载方法：
format(Locale locale,格式化模式,日期列表);
其中的参数locale是一个Locale类的实例，用于表示地域。,
8.7 Math、BigInteger和Random类
8.7.1 Math类
在编写程序时，可能需要计算一个数的平方根、绝对值或获取一个随机数等。
以下是Math类的常用类方法。
• public static long abs(double a) 返回a的绝对值。
• public static double max(double a,double b) 返回a、b的最大值。
• public static double min(double a,double b) 返回a、b的最小值。
等
8.7.2 BigInteger类
BigInteger类的常用方法。
• public BigInteger add(BigInteger val) 返回当前对象与val的和。
• public BigInteger subtract(BigInteger val) 返回当前对象与val的差。
• public BigInteger multiply(BigInteger val) 返回当前对象与val的积。
等。
下面的例子17使用Math和BigInteger类。
例子17
Example8_17.java

import java.math.*;
public class Example8_17 {
public static void main(String args[]) {
double a = 5.0;
double st = Math.sqrt(a);
System.out.println(a+“的平方根:”+st);
System.out.printf(“大于等于%f的最小整数%d\n”,5.2,
(int)Math.ceil(5.2));
System.out.printf(“小于等于%f的最大整数%d\n”,-5.2,
(int)Math.floor(-5.2));
System.out.printf("%f四舍五入的整数:%d\n",12.9,Math.round(12.9));
System.out.printf("%f四舍五入的整数:%d\n",-12.6,Math.round(-12.6));
BigInteger result = new BigInteger(“0”),
one = new BigInteger(“123456789”),
two = new BigInteger(“987654321”);
result = one.add(two);
System.out.println(“和:”+result);
result=one.multiply(two);
System.out.println(“积:”+result);
}
}
8.7.3 Random类
使用Random类的如下构造方法
public Random();
public Random(long seed);
创建Random对象。
下面的例子18演示是从1-100之间随机得到6个不同的数。
例子18
Example8_18.java

public class Example8_18 {
public static void main(String args[]) {
int [] a =GetRandomNumber.getRandomNumber(100,6);
System.out.println(java.util.Arrays.toString(a));
}
}
GetRandomNumber

import java.util.*;
public class GetRandomNumber {
public static int [] getRandomNumber(int max,int amount) {
// 1至max之间的amount个不同随机整数（包括1和max）
int [] randomNumber = new int[amount];
int index =0;
randomNumber[0]= -1;
Random random = new Random();
while(index<amount){
int number = random.nextInt(max)+1;
boolean isInArrays=false;
for(int m:randomNumber){//m依次取数组randomNumber元素的值（见3.7）
if(m == number)
isInArrays=true; //number在数组里了
}
if(isInArrays==false){
//如果number不在数组randomNumber中:
randomNumber[index] = number;
index++;
}
}
return randomNumber;
}
}
8.8 数字格式化
程序有时候需要将数字进行格式化，所谓数字格式化，就是按着指定格式得到一个字符序列。
8.8.1 format方法
程序可以使用String类调用format方法对数字进行格式化。
1．格式化模式
2．值列表
3．格式化顺序
8.8.2 格式化整数
1．%d，%o，%x和%X
2．修饰符
3．数据的宽度
8.8.3 格式化浮点数
1．float、Float、double 和Double
%f，%e（%E），%g（%G）和%a（%A）格式符可格式化float、Float、double和Double。
2．修饰符
3．限制小数位数与数据的“宽度”

下面的例子19格式化数字。
例子19
Example8_19.java

import java.text.*;
public class Example8_19 {
public static void main(String args[]){
int n= 12356789;
System.out.println(“整数”+n+“按千分组(带正号):”);
String s=String.format("%,+d",n);
System.out.println(s);
double number = 98765.6789;
System.out.println(number+“格式化为整数7位，小数3位:”);
s=String.format("%011.3f",number);
System.out.println(s);
}
}
8.9 Class类与Console类
8.9.1 Class类
在下面的例子20中，我们使用Class对象得到一个Rect类以及java.util包中Date类的对象。
例子20
Example8_20.java

import java.util.Date;
class Rect {
double width,height,area;
public double getArea() {
area = height*width;
return area;
}
}
public class Example8_20 {
public static void main(String args[]) {
try{ Class cs = Class.forName(“Rect”);
Rect rect = (Rect)cs.newInstance();
rect.width = 100;
rect.height = 200;
System.out.println(“rect的面积”+rect.getArea());
cs = Class.forName(“java.util.Date”);
Date date = (Date)cs.newInstance();
System.out.println(String.format("%tF %<tT %<tA",date));
}
catch(Exception e){
System.out.println(e.toString());
}
}
}
8.9.2 Console类
在下面的例子21中，模拟用户用户输入的密码，如果输入正确（I love this game），那么，程序让用户看到“你好，欢迎你！”。程序允许用户2次输入的密码不正确，一旦超过2次，程序将立刻退出。
例子21
Example8_21.java

import java.io.Console;
public class Example8_21 {
public static void main(String args[]) {
boolean success=false;
int count=0;
Console cons;
char[] passwd;
cons = System.console();
while(true) {
System.out.print(“输入密码:”);
passwd=cons.readPassword();
count++;
String password=new String(passwd);
if (password.equals(“I love this game”)) {
success=true;
System.out.println(“第”+count+“次密码正确!”);
break;
}
else {
System.out.println(“第”+count+“次密码”+password+“不正确”);
}
if(count==3) {
System.out.println(“您”+count+“次输入的密码都不正确”);
System.exit(0);
}
}
if(success) {
System.out.println(“你好，欢迎你!”);
}
}
}
8.10 Pattern与Matcher类
使用Pattern类和Matcher的步骤如下。
1．建立Pattern对象
2．得到Matcher对象

例子22计算了一个账单的总价格。
例子22
Example8_22.java

import java.util.regex.*;
public class Example8_22 {
public static void main(String args[ ]) {
String s = “市话76.8元,长途:167.38元,短信12.68”;
String regex = “[0123456789.]+”; //匹配数字序列
Pattern p =Pattern.compile(regex); //模式对象
Matcher m =p.matcher(s); //匹配对象
double sum =0;
while(m.find()) {
String item = m.group();
System.out.println(item);
sum = sum+Double.parseDouble(item);
}
System.out.println(“账单总价格:”+sum);
}
}
8.11 应 用 举 例

本次课总结
掌握StringBuffer类、Date类和Calendar类获取时间和日期的用法。
如果需要处理特别大的整数，使用BigInteger类。
当需要格式化日期和数字时使用相关的格式化类及方法。