java常用实用类详解
1. String类（字符串检测）
| 返回值类型 |
常用方法 |
说明 |
| int |
length() |
获取字符串的长度大小 |
| boolean |
equals(String s) |
比较对象的实体是否相同。 |
| boolean |
startsWith(String s) |
判断当前字符串前后缀是否是参数字符串s |
| endsWith(String s) |
||
| boolean |
regionMatches(x, String s, y, length) |
取字符串a中参数x指定位置开始，长度为length的一个子串，将这个子串与字符串s从参数y指定位置开始，长度为length的子串进行比较，相同则true，否则false。 |
| int |
compareTo(String s) |
按字典序与参数s指定的字符串比较大小， |
| boolean |
contain(String s) |
判断字符串a是否含有参数字符串s |
| int |
indexOf(String s，x) |
从字符串a的参数x指定位置开始检索字符串s，并返回首次出现的位置，没有检索到就返回-1。 |
| String |
subString(start，end) |
截取字符串a中从参数start指定位置开始到end处的子串。 |
| String |
trim() |
去掉字符串a前后的空格 |
1) String中的构造方法
String（char a[]，x，y）:截取字符数组中的元素，将字符创建为字符串。从下标为x开始，截取y个元素。
例：char a [] = {‘s’,‘o’，‘k’，‘a’，‘b’}；
String s = new String（a，1,2）；
相当于
Strings = new String(“ok”)；
运行结果：s = ok
引用字符串常量对象：
例：String s1,s2；
s1 = “how are you”；
s2 = “how are you”；
这样s1,s2具有相同的引用，因而具有相同的实体。
2) String常用方法
(1) int length()方法，获取字符串的长度大小。
例:String num = “我爱学习”；
intn1,n2；
n1= num.length()；
n2= “你好吗”.length()；
运行结果：n1=4；n2=3；
(2) boolean equals(String s)方法，比较对象的实体是否相同。
例： Strings1 = {“we are students”}；
Strings2 = {“you are students”}；
Strings3 = {“we are students”}；
String n,m；
n = “how are you”；
m = “how are you”；
那么: s1.equals(s2)的值是false，
s1.equals(s3)的值是true
n.equals(m)的值是true
s1==s3的值是false
n==m的值是true
“==”比较的是两个字符串对象在内存中的地址，就是判断是否是同一个字符串对象。
“equals()”比较的是两个字符串对象的值。
(3) boolean startsWith(Strings)、boolean endsWith(String s)方法。判断当前字符串前后缀是否是参数字符串s
例：String num1 = “2837485826495”；
那么： num1. startsWith(“283”)的值是true
num1. startsWith(“282”)的值是false
num1. endsWith(“6495”)的值是true
num1. endsWith(“6652”)的值是false
(4) boolean regionMatches(x, Strings, y, length)方法。取字符串a中参数x指定位置开始，长度为length的一个子串，将这个子串与字符串s从参数y指定位置开始，长度为length的子串进行比较，相同则true，否则false。
例：String a = “we arefamily,are student.”
那么：a.regionMatches(0,“we”,0,2)；的值为true。
(5) int compareTo(String s)方法。按字典序与参数s指定的字符串比较大小，如果字符串a与s相同，返回值0，如果字符串a大于s，返回值为正值，反正如果字符串a小于s，返回值为负值。
例：String a = “abcde”；
那么：a.compareTo(“boy”)为负值
a.compareTo(“aba”)为正值
a.compareTo(“abcde”)为0
(6) boolean contain(String s)方法。判断字符串a是否含有参数字符串s，含有值就为true，否则值为false。
例：Stringa = “student”；
那么：a.contain(“stu”)的值为true
a.contain(“std”)的值为false
(7) int indexOf(String s，x)方法。从字符串a的参数x指定位置开始检索字符串s，并返回首次出现的位置，没有检索到就返回的值为-1。
int lastIndexOf(String s,x) 从字符串a的参数x指定位置开始检索字符串s，并返回最后出现的位置，没有检索到就返回的值为-1。
例：String a = “I01A2M3 4A56G7O8O9D10 11C12A13T14”；
那么： a.indexOf(“A”)；//值是2
a.indexOf(“GOOD”,2)；//值是7
a.indexOf(“a”,7)；//值是13
a.indexOf(“w”,2)；//值是-1
(8) String subString(start，end)方法。截取字符串a中从参数start指定位置开始到end处的子串。
例：String a = “I loveyou”；
String s = a.substring(2,5)；
那么：s = “lov”
(9) String trim()方法。去掉字符串a前后的空格。
2. BigDecimal类（实现浮点型数据精确计算）
(1) add(BigDeciml n)方法。加法。将BigDecimal类创建的数据与n相加。
(2) subtract(BigDecimal n)方法。减法。将BigDecimal类创建的数据与n相减。
(3) multiply(BigDecimal n)方法。乘法。将BigDecimal类创建的数据与n相乘。
(4) divide(BigDecimal n)方法。除法。将BigDecimal类创建的数据与n相除。
.....比较大小，余数，绝对值，次幂，进制等方法与BigInteger类中的方法相同，
例：BigDecimal t1 =new BigDecimal(“2”);
BigDecimal t2 =new BigDecimal(“1.2”);
BigDecimal result= t1.add(t2);//result值为3.2
注意：在商业程序中，货币等需要精确计算的，需要使用BigDecimal类。
3. BigInteger类（实现整数型数据精确计算）
Ø 构造方法：BigInteger(String s);
字符串参数s必须是数字字符，如果含有非数字字符就会发生NumberFormatException异常。
例：BigInteger sum =new BigInteger(“12”);//初始化sum=12
Ø 常用方法
Int compareTo(BigIntegers):比大小，返回当前整数对象与参数s 的比较结果，返回值1(大于)，-1(小于)，0(等于)。
BigInteger ads(BigIntegers):绝对值，返回当前整数对象与参数s的绝对值。
BigInteger pow(inta):a次幂，返回当前整数对象的a次幂。
String toString():十进制，返回当前整数对象十进制的字符串表示。
String toString(intp):p进制，返回当前整数对象p进制的字符串表示。
例：BigIntegersum = newBigInteger("23");
BigInteger one = new BigInteger("55");//初始化两个数
BigInteger he = one.add(sum);//求和
BigInteger cha = one.subtract(sum);//求差
int bijiao= one.compareTo(sum);//比较大小，sum>one,故返回值1
String s = sum.toString(2);//sum的二进制表示
运行结果：he= 78，cha=32，bijiao=1，s=10111
4. 字符串与基本数据相互转化
（1）用Integer类中的parseInt(String s)、parseByte(String s)、parseShort(String s)、parseLong(String s)、 parseFloat(String s)、parseDouble(String s)等等。
例：Strings = “2654”；
Int x = Integer.parseInt(s)：//x=2654
（2）用String类中String valueOf(数据类型 n)方法
例：int x = 12；
String s = String.valueOf(x)；//s=“12”
（3）用Long类中以下方法得到各进制的字符串
String toBinaryString(long i)//返回整数i的二进制表示
String toOctalString(long i)//返回整数i的八进制表示
String toHexString(long i)//返回整数i的十六进制表示
String toString(long i,int p)//返回整数i的p进制表示
5. 正则表达式及字符串替换分解
(1) 正则表达式
定义：正则表达式就是含有一些特殊意义的字符串（元字符）。
例：“\\dhello”.“\\d”就是具有特殊意义的字符串，代表0～9数字中任意一个，及1hello，4hello..等等都是和正则表达式\\dhello匹配的字符串。
元字符及其意义：
| 元字符 |
正则表达式写法 |
意义 |
| . |
“.” |
代表任何一个字符 |
| \d |
“\\d” |
代表数字0～9 |
| \D |
“\\D” |
代表任何非数字字符 |
| \s |
“\\s” |
代表空格类字符 |
| \S |
“\\S” |
代表非空格类字符 |
| \w |
“\\w” |
代表可用的标识符(不包括$) |
| \W |
“\\W” |
代表不能用的标识符 |
*********************************************************************************
方括号括起来的若干字符表示一个元字符。
« 例：[abc]:代表a,b,c中任何一个
[^abc]:代表a,b,c除外的任何一个字符
[a-zA-Z]:代表英文字母中任何一个
*********************************************************************************
限制修饰符：(X代表正则表达式中任意一个元字符或普通字符)
| 带限定符号的模式 |
意义 |
| X? |
X出现0次或1次 |
| X* |
X出现0次或多次 |
| X+ |
X出现1次或多次 |
| X{4} |
X恰好出现n次 |
| X{n,} |
X至少出现n次 |
| X{n,m} |
X至少出现n至m次 |
例：c = “t\\w{4}”,\\w恰好出现四次，那么“tabcd”、“tdbhd”、“td37v”…任何一个四位标识符。
s = “[1-9][0-9]*[.]?[0-9]*”。代表任意一个浮点型数据，因为第一位不能为0，所以为1-9中任何一个，第2.3.4…位可以为0-9中任何一个或多个，小数点出现一次或者0次，小数部分0-9任意一个或多个。例：12534.5562,45256,12.021等等都可以与正则表达式匹配。
(2) 字符串的替换
replaceAll()方法。
例：String b ="12hello345".replaceAll("\\d+","你好");
运行结果b就是“你好hello你好”。
(3) 字符串的分解
split(String s)方法。字符串s代表正则表达式
例：Stringstr = “1931年09月18日，日本发动侵华战争”；
Strings = “\\D+”；
Stringd[] = str.split(s);
运行结果：d[0],d[1],d[3]分别是：“1931”、“09”、“18”。
6. StringBuffer类(字符串处理)
作用：StringBuffer类创建一个可修改的字符串序列。
| 返回值类型 |
常用方法 |
说明 |
| StringBuffer |
append(String s) |
在字符串后追加一个字符串。 |
| char |
charAt(int n) |
获取下标为n处的单个字符 |
| void |
setCharAt(int n,char ch) |
将当前StringBuffer对象中的字符串位置n处的字符替换为指定参数ch。 |
| StringBuffer |
insert(int n,String s) |
将指定字符串s插入到下标n处，并返回当前对象的引用。 |
| StringBuffer |
reverse() |
将当前对象实体中的字符翻转，并返回当前对象的引用。 |
| StringBuffer |
delete(int start,int end) |
删除当前字符串从下标start处到下标end-1处的子字符串。 |
| StringBuffer |
replace(int start,int end,String s) |
将当前字符串从下标start处到下标end-1处的子字符串替换为指定参数字符串s |
1) StringBuffer类中构造方法
StringBuffer()、StringBuffer(intsize)和StringBuffer(Strings)三个构造方法。
2) StringBuffer类常见方法
(1) append()方法。追加字符串。在字符串后追加一个字符串。
StringBuffer append(Strings) 在字符串后追加一个字符串s
StringBuffer append(inti)将int型数据i转化为字符串，再追加。
例：StringBuffer ds = newStringBuffer("我爱学习java");
ds.append("生活");//在字符串后追加
运行结果：字符串ds为“我爱学习java生活”。
(2) char charAt(int n)方法。获取某单个字符。获取下标为n处的单个字符。
例：StringBufferds = new StringBuffer(“我爱学习java”)；
char ch = ds.charAt(2)；//获取下标为2的字符
运行结果：ch为‘学’。
(3) setCharAt(int n,char ch)方法。替换某个字符。将当前StringBuffer对象中的字符串位置n处的字符替换为指定参数ch。
例：StringBufferds = new StringBuffer(“我爱学习java”)；
ds.setCharAt(0,‘你’)；//替换下标为0的字符
运行结果：ds为“你爱学习java”。
(4) StringBuffer insert(intn,String s)方法。插入字符串。将指定字符串s插入到下标n处，并返回当前对象的引用。
例：StringBufferds = new StringBuffer(“我爱学习java”)；
ds.insert(1,“很爱很”)；//在下标1处插入字符串
运行结果：ds为“我很爱很爱学习java”。
(5) StringBuffer reverse()方法。翻转字符串。将当前对象实体中的字符翻转，并返回当前对象的引用。
例：StringBufferds = new StringBuffer(“我爱学习java”)；
ds.reverse()；
运行结果：ds为 “avaj习学爱我”。
(6) StringBuffer delete(intstart,int end)方法。删除部分字符串。删除当前字符串从下标start处到下标end-1处的子字符串。
例：StringBufferds = StringBuffer(“我爱学习java”)；
ds.delete(1,4)；//删除下标1到下标3所有的字符
运行结果：ds为“我java”。
(7) StringBuffer replace(intstart,int end,String s)方法。替换字符串。将当前字符串从下标start处到下标end-1处的子字符串替换为指定参数字符串s。
例：StringBufferds = new StringBuffer(“我爱学习java”)；
ds.replace(1,4,“喜欢”)；//替换从下标1到下标3处的字符串
运行结果：ds为“我喜欢java”。
7. StringTokenizer类（字符串解析分离）
java.util.*;包中
Ø 两个常用构造方法：
l StringTokenizer(String s)方法:为字符串s构造一个分析器。使用默认的分隔符标记，即空格符、换行符、回车符、Tab符、进纸符。
l StringTokenizer(Strings,String dilim)方法：为字符串s构造一个分析器。使用参数dilim中的字符的任意组合作为分隔标记。
Ø 使用nextToken()方法。通常在while语句中逐个获取分隔开后的字符串（单词）。
Ø 在while语句条件中使用hasMoreTokens()方法控制循环。
Ø 使用countTokens()方法得到分析器计数的次数。（分离出单词的次数）。
例：StringTokenizer b = new StringTokenizer(“we,are,students”，“,”);
int num = b.countTokens();//获得分析器计数的次数
while(b.hasMoreTokens()){ //调用hasMoreTokenizer()方法控制循环
s =b.nextToken(); //逐个获取分隔后的字符串
System.out.println(“s=”+s);
}
System.out.println(“num=”+num);
运行结果： s=we s=are s=students num=3
8. Scanner类（字符串解析分离提取处理）
java.util.*;包中
作用：Scanner类的对象能够从字符串中解析程序所需要的数据
解析步骤：
u 为了解析字符串s中的数据，首先创建一个Scanner对象：
Scanner ds = new Scanner(String s);//默认空格作为分隔符。
u 调用方法useDelimlter(正则表达式)方法重新设置分隔符。
u ds使用next()方法依次返回被解析的字符串s中的单词数据。
u 利用while循环逐步获取解析后的字符串，利用hasNext()方法作为循环条件。
例：scanner.java
importjava.util.*;
public classscanner {
public static void main(String[] args) {
String s = "telephonecost 876。Computercost 2398.2 ";
Scanner ds = new Scanner(s);//创建一个Scanner对象
ds.useDelimiter("[^0123456789.]+");//设置除0123456789.外的字符作为分隔符
double sum=0;
while(ds.hasNext()){ //使用hasNext()方法作为循环条件
try{double b = ds.nextDouble();//可能返回非数字化单词出现InputMismatchException异常
sum = sum+b;
System.out.println(b);
}
catch(InputMismatchException exp){//处理可能发生的异常
String c= ds.next();
} }
System.out.println(sum);
} }
运行结果：876.0 2398.2 3274.2
9. Date类（时间获取）
java.util.*;包中
ü 构造方法：Date(long time);获取当前时间。
默认顺序为：星期、月、日、小时、分、秒、时区、年。
例：Date date1 = new Date();//当前时间
Date date2 = new Date(1000);//格林威治时间后一秒，（公元后一秒）
运行结果：date1为“Wed May 03 17:58:11 CST2017”。
date2为“Thu Jan 01 08:00:01 CST1970”。//1000代表一秒
====*===*===*===*===*===*===*===*===*===*===*===*===*===*===*===*===*===*==
« System类的静态方法currentTimeMillis()获取系统当前时间与格林威治时间相差的秒数。
例：long ds = System.currentTimeMillis();
====*===*===*===*===*===*===*===*===*===*===*===*===*===*===*===*===*===*==
10. Calendar类（时间日期处理）
java.util.*;包中
1. 初始化：使用Calendar类的static方法getInstance()可以初始化一个Calendar对象。利用Calendar对象设置获取相关信息。
例：Calendar ds = Calendar.getInstance();
int year = calendar.get(YEAR);//获取年份信息
int month = calendar.get(MONTH)+1;//获取月份信息，返回数是月份数-1，所以需要+1；
int day = calendar.get(DAY_OF_MONTH);//获取天数
int week = calendar.get(DAY_OF_WEEK);//获取星期
int hour = calendar.get(HOUR_OF_DAY);//获取小时
int minute = calendar.get(MINUTE);//获取分钟
int second = calendar.get(SECOND);//获取秒数
2. 日期的格式化
l simpleDateFormat类
使用DateFormat的子类SimpleDateFormat实现日期格式化。
常用构造方法：SimpleDateFormat(String s);该构造方法可以用参数s指定的格式创建一个对象，对象调用format(Date date)方法格式化时间对象date。
如果参数s中出现普通ASCII字符，必须用单引号“'”字符括起来。
例：s = “‘time’:yyyy-MM-dd”;
例：Date nowTime = new Date();//nowTime获取当前时间
SimpleDateFormat ds = SimpleDateFormat(“yyyy年M月d日H时m分s秒E”)；创建一个指定的格式对象ds
ds1 = ds.format(nowTime);调用对象ds格式化当前时间nowTime。
运行结果：ds1为2017年5月4日15时36分55秒星期四
日期替换格式如下：
以2017年5月4日15时36分55秒星期四为例：
| 格式符 |
替换结果 |
| G |
公元 |
| y |
两位数字的年：2017 |
| M |
年中的月份：5（2017年的5月） |
| w |
年中的周数：18（2017年的第18周） |
| W |
月份中的周数：1（5月第一周） |
| D |
年中的天数：124（2017年的第124天） |
| d |
月份中的天数：4（5月的第四天） |
| F |
月份中的星期：1（5月的第一个星期） |
| E |
星期的天数：星期四（一星期的第4天） |
| a |
am/pm标记：PM（下午） |
| H |
一天中的小时（0～23）：例如：0 |
| k |
一天中的小时数（1～24）：例如：24 |
| K |
am/pm中的小时数（0～11）：4（下午4点） |
| h |
am/pm中的小时数（1～12）：4（下午4点） |
| m |
小时中的分钟：36 |
| s |
分钟中的秒数：55 |
| S |
毫秒数：627 |
| z |
时区：CST |
l Formatter类
format(“格式化模式”，日期列表)：目前format()方法已经被封装到String类中，因此可以直接用String类调用format()方法。
格式化“日期列表”中同一日期时，可以在“格式化模式”中使用“<”
例如：String s = String.format(“%tY年% 常见日期格式符： “%ty年% 2017年05月04日下午16时50分10秒为例： 分类 格式符 作用 年 %tY 将日期中的年格式化为四位形式：2017 %ty 将日期中的年格式化为两位形式：17 月 %tm 将日期中的月份格式化两位形式（01～13）：05 %tB 将日期中的月份格式化为全称：“January”或 “五月” %tb 将日期中的月份格式化为简称： “Jan”或“五月” am/pm %tp 将日期中的日格式化为上午或下午格式：表示上午下午 日 %td 将日期中的日格式化为本月中的一天（01～31）：04日 %tj 将日期中的日格式化为当年中的一天（001～365）：124 星期 %tA 将日期中的日格式化为星期几的全称：“sunday”或“星期四” %ta 将日期中的日格式化为星期几的简称：“sun”或“星期四” 时 %tH 将日期中的时格式化为24小时制00～23：16 %tI 将日期中的时格式化为12小时制1～12: 4 分 %tM 将日期中的分格式化为两位形式00～60: 50 秒 %tS 将日期中的秒格式化为两位形式00～60:10 毫秒 %tL 将日期中的毫秒格式化为三位形式000～999； 微秒 %tN 将日期中的微秒格式化为9位形式： 偏移量 %tz 将日期与格林威治时间的偏移量格式化为4位形式 时区 %tZ 将日期所在的时区的名称格式化为标准缩写：CST 不同区域的星期格式：format(Locale s（地域），格式化模式，日期列表)； 例：s=String.format(LocaleUS,“%tY年% java.math.*;包中 Math类常用类方法： Random类（随机生成器） java.math.*;包中 构造方法：Random();和Random(longt); 使用nextInt(int n)方法返回一个0～n之间的随机数，包括0，不包括n。 例：Random rand1 = new Random(); int t1 = rand.nextInt(100);//随机产生一个0～100之间的数（不包括100） intt2 = rand.nextInt(100)+1;//随机产生一个1～101之间的数（不包括101） java.util.regec包中 模式对象： 模式匹配第一步就是使用Pattern类创建一个对象p，称为模式对象。 模式对象就是对正则表达式的封装。 然后Pattern类调用类方法compile(String regex);返回一个模式对象。 参数regex是一个正则表达式。或者compile(Stringregex,int n)方法。 例：Pattern p =Pattern.compile(“\\dhello”); 匹配对象： 使用模式对象p调用matcher(s)方法返回一个Matcher对象m，称为 匹配对象。 查找子序列： 一个Matcher对象m可以调用下列3种方法查找参数s指定字符串是否含 有和regex匹配的子序列。 l boolean find()方法：寻找s中和regex匹配的下一子序列，成功返回true，否则返回false。通常在while中做循环条件。 对象m调用group()方法得到匹配的子序列。对象m调用start()方法和end()方法得到匹配子序列时的开始位置和结束位置。 l boolean matches()方法;判断s是否和regex匹配。 l boolean lookingAt()方法：判断第一个。判断s的开始位置是否含有和regex匹配的子序列。 l boolean find(int start)方法，判断所有。判断s从参数start位置开始是否含有和regex匹配的子序列。start=0时与lookingAt功能相同。 l String replaceFirst(String t)方法。替换第一个。对象m调用该方法返回一个字符串。该字符串是通过s中与regex第一个匹配的子字符串替换为参数t指定的字符串。 l String replaceAll(String t)方法，替换全部。对象m调用该方法返回一个字符串。该字符串是通过s中与regex匹配的子字符串全部替换为参数t指定的字符串。 例：pattern.java public classpattern { public static void main(String[] args) { Patternp = Pattern.compile("[1-9][0-9]*[.]?[0-9]*");//创建模式对象 Strings = "price:235.42$,weight:524.21,height:452"; Matcherm = p.matcher(s);//创建匹配对象 while(m.find()){//寻找匹配的子序列 Stringstr = m.group();//返回找到的子序列 System.out.println(+m.start()+"到"+m.end()+"子序列:"+str); } System.out.println(m.lookingAt());//判断s中第一个是否与p匹配 System.out.println(m.find(0));//判断s是否有与p匹配的子序列 Stringt = m.replaceAll("20.2");//替换所有匹配的子序列 System.out.println(t); Stringg = m.replaceFirst("203.2");//替换第一个匹配的子序列 System.out.println(g); } } 运行结果： 6到12子序列:235.42 21到27子序列:524.21 35到38子序列:452 false true price:20.2$,weight:20.2,height:20.2 price:203.2$,weight:524.21,height:452 1. 使用Class实例化一个对象 (1) 使用Class的forName(String className)方法得到一个和某类相关的Class对象。className为指定的类（如何类在某个包中，className必须带有包名，例：“java.util.Date”）。 例：class ds{…………}//类ds Class cs = Class.forName(“ds”); (2) 使用Class创建的对象cs调用newInstance()方法得到一个className类的对象。 例：ds s = (ds)cs.newInstance(); 注意：使用Class对象调用newInstance()实例化一个className类的对象时，className类必须有无参的构造方法。 2. 获取类的有关信息 当一个类被加载且创建对象时，创建的任何对象调用Class中的getClass()方法返回一个Class对象，可以获取对象的相关信息。 Class对象经常调用以下方法： String getName();返回类的名字。 Constructor[]getConstructors();返回类的全部构造方法。 Field[]getDeclaredFields():返回类的全部成员变量。 Method[]getDeclaredMethods():返回类的全部方法。 例：classlei.java import java.lang.reflect.*; import java.util.*; public class classlei { publicstatic void main(String[] args) { Date f = new Date();//创建一个Date类对象 Class cs =f.getClass();//Date对象调用方法创建一个Class类对象 String name = cs.getName();//Class对象返回类名 Constructor[] con =cs.getDeclaredConstructors();//Class对象返回构造方法（数组） Field[] field = cs.getDeclaredFields();//Class对象返回成员变量（数组） Method[] method =cs.getMethods();//Class对象返回全部方法（数组） System.out.println("类名"+name); System.out.println("成员变量如下："); for(inti=0;i System.out.println(field[i].toString()); } System.out.println("构造方法如下："); for(inti=0;i System.out.println(con[i].toString()); } System.out.println("全部方法如下："); for(inti=0;i System.out.println(method[i].toString()); } } } 如果需要java开发视频教程的加QQ群：814394029，可联系群主获取，非诚勿扰哦！
11. Math类（数据运算处理）
12. Pattern与Match类(检索跟指定模式匹配的字符串)
13. Class类（帮助程序创建类或获取类的内部信息）（搜集信息）