Java常用类
常用类
Object类
它是Java所有类的根类.所以Java的所有对象都拥有Object类的成员.
1．一般方法
boolean equals(Object obj) //本对象与obj对象相同，返回true
String toString() //返回本对象的字符串表达形式，默认返回类名称和十六进制数的编码，即：getClass().getName+?@?+Integer.toHexString(hashCode());
如果要显示自定义的对象，则需要覆盖这个方法。
protected void finalize() throws Throwable //对象销毁时被自动调用,
native int hashCode()
返回对象的Hash码，Hash码是表示对象的唯一值，故Hash码相同的对象是同一对象。
2．控制线程的方法
final native void wait() //等待对象
final native void notify() //通知等待队列中的对象进入就绪队列
final native void notifyAll()//通知所有处于等待队列中的对象进入就绪队列
3．关于Object类的几点说明：
3.1. native <方法> 是指用C++语言编写的方法。
3.2.“==”运算符一般用于基本数据类型的比较，如果用于两个引用对象的比较，则
只有当两个引用变量引用同一个对象时，才返回true,否则返回false.
String s1=new Strng(“java”);
String s2=new Strng(“java”);
System.out.pritnln(s1==s2); //显示false
但是，假如不使用new 关键字，创建String 型对象s3,s4,则它们引用的是同一个对象。
String s3=“java”;
String s4=“java”;因为没有使用new 关键字，所以s4 引用既存的对象
System.out.pritnln(s3==s4); //显示true,
3.3. 比较对象内容时,使用equals()函数
Object 类的equals()定义
Public boolean equals(Object obj){
return (this==obj);
}
由于String 类覆盖了继承自Object类的equals()方法,它比较的是引用对象的内容.
所以,没有覆盖equals()方法的类的对象使用该方法与另一对象进行比较时,永远返
回false; 只是因为此时进行比较调用的是Object的equals方法.
4. Object引用型变量
Object引用型变量可以用来引用所有的对对象.
Object[] obs=new Object[3];
obs[0]=new Strng(“12345”);//将String对象赋给obs[0]
obs[0]=new Boolean(true);
obs[0]=new Integer(100);
5. toString()方法
该方法返回本对象的字符串表示.当需要显示子类对象时,系统自动调用该对象的toString()方法,如果该对象没有覆盖祖先类的toString()方法,则系统默认调用Object的这个方法,从而显示类的完整路径名称.反之,将按子类的toString()方法显示其内容.
class Student{
Strng name;
Public Student(){
https://www.360docs.net/doc/e212732371.html,=”洋洋”
}
}
public class Test{
public static void main(String[] args){
Student st=new Student();
System.out.println(st);
}
}
//子类覆盖toString()
class Student{
Strng name;
Public Student(){
https://www.360docs.net/doc/e212732371.html,=”洋洋”
}
public String toString(){
retrun “你的姓名:”+https://www.360docs.net/doc/e212732371.html,;
}
}
public class Test{
public static void main(String[] args){
Student st=new Student();
System.out.println(st); //显示
}
}
6. 类的层级图
A : 继承自Object类的成员+
B : 继承自Object类的成员+
C : 继承自Object类的成员+
D : 继承自Object类的成员+
Character类
这是一个字符包装器类，它封装了对字符的操作
一．构造函数
Character(char c)
二．静态方法：
1．检查是否为某类字符
static boolean isLetter(char ch) 返回true ，如果ch是字母字符
static boolean isDigit(char ch) 返回true ，如果ch是数字字符
static boolean isLetterOrDigit(char ch)返回true,如果ch是字母或数字字符
static boolean is LowerCase(char ch) //返回true,表示ch 为小写字母
static boolean is UpperCase(char ch) //返回true,表示ch 为大写字母
static boolean isSpaceChar(char ch) //返回true,表示ch 为空格2．大小写字符转换
static char toLowerCase(char ch) //转换字符c 为小写
static char toUpperCase(char ch) //转换字符c 为大写
String类
String 是一种引用类型。
String 是一种使用频率很高的数据类型.
1．构造函数：
String(String original)
String(char[] cc)
String(char[] chars,int startIndex,int charCount)
String(byte[] chars)//使用平台默认字符编码，用byte[]构造一个String对象
String(byte[] chars,int startIndex,int charCount)
String(StringBuffer sb)
2．静态函数：
String valueOf(object obj) 将任意类型转换为字符串。
3．操作函数：
3.1. 类型转换
char[] toCharArray(); 返回字符串对应的字符数组
3.2. 获得字符
char charAt(int index) 返回索引为index位置的字符
3.3. 删除空白字符
String trim()删除字符串前后空格
3.4. 分裂字符串
String[] splite(String rex)按分隔字符串进行分隔，返回字符串数组
说明: 如果字符串用英文句号”.”分隔，则需要用”\\.”表示,例如：
String s="2007.10.18";
String[] sArray=s.split("\\."); 因为英文句号”.”为正则表达式的特殊字符
3.5. 查找字符串
boolean startsWith(String s)
在本串开始部分查找是否有与s 匹配的串。返回true，表示匹配，boolean endsWith(String s)
在本串末尾部分查找是否有与s 匹配的串。返回true，表示匹配，boolean equals(Object obj) true 表示本串与obj串内容相等
boolean equalsIgnoreCase(String anotherString)
忽略大小写比较，返回true 表示本串与obj串内容相等
int indexOf(String s)
从本串开始部分查找是与s 匹配的串。返回s在本串中的起始位置int lastIndexOf(String s)
从本串末尾查找是与s 匹配的串。返回s在本串中的起始位置
3.6. 字符串比较
int compareTo(String anotherString)
返回负数表示本串< anotherString;
0表示本串等于anotherString;
正数表示本串> anotherString;
int compareToIgnoreCase(String anotherString) 忽略大小写比较
返回负数表示本串< anotherString;
0表示本串= anotherString;
正数表示本串> anotherString;
3.7. 取子字符串
String substring(int startPos,int endPos)
返回startPos――endPos之间的字符串(不含endPos位置的字符)。
String substring(int startPos) 返回从startPos开始直到串尾的全部字符
3.8. 大小写转换
String toLowerCase() 转换为小写字母
String toUpperCase() 转换为大写字母
3.9. 拷贝
getChars(int StartPos,int endPos,char[] c,int startIndex) 拷贝startPos――endPos之间的字符串(不含endPos位置的字符)到字符数组c 中，从索引startIndex开始存放getBytes(int StartPos,int endPos,byte[] b,int startIndex) 拷贝startPos――endPos 之间的字符串(不含endPos位置的字符)到字节数组b 中，从索引startIndex
开始存放byte[] getBytes(); 返回byte数组
bye[] getBytes()使用平台默认字符编码，将当前字符串转换为一个byte数组
3.10. 获得串长度
int length()返回串长度(字符个数)
3.11. 替换子串
String replace(char oldChar,char newChar)
将本串中全部oldChar字符替换为newChar字符,并返回替换后的字符串
3.12. 类型转换
static int Integer.parseInt(String s);//转换为int类型
static long Long.parseInt(String s);//转换为int类型
static double Double.parseInt(String s);//转换为int类型
说明：上述类型的转换如果不成功，将抛出NumberFormatException异常。
3.13. 匹配
boolean matches(String pattern) //pattern为正则表达式。
当字符串与pattern匹配时，返回true
常见的匹配模式：
A.匹配超链接标记
B.匹配e-mail ^[_a-z0-9-]+(.[_a-z0-9-]+)*@[a-z0-9-]+([.][a-z0-9-]+)*$
4. 字符串的连接
用运算符“+”进行两个字符串的连接。如：
String s1=”sun”;
String s2=”company”;
String s=s1+s2; //此时s内容为：sun company
5. 关于String 的几点说明：
5.1. 由于String的特殊性，所以系统处理这种类型时，内部使用了String 池，
用意提高性能；当用赋值号为一个字符串赋值时，系统首先在String 池
中查找，如果找到，则直接将其引用赋值给目标变量，如果没有找到，则
申请一个新的串，并将其引用赋值给目标变量，同时将这个新串放到String
池中。
5.2. 用”+”连接两个字符串，总是产生一个新的串。
5.3. 如果频繁使用”+”运算符进行字符串链接，则使用StringBuffer 或StringBuilder
可以大大提高性能。
思考：
0.设计一个方法，boolean isNumeric(String sNumber)
用以检查输入的字符串是否全由数字字符组成，如是，返回true,否则，返回false.
1. 编写一个方法，使用异或运算，对输入字符串加密，并输出密文。调用同一函数，输入密文，同时输出明文。
2.编写isLike()方法，用以判断字符串是否匹配。
“a*”: 以字符?a?开头的字符串
“*bc*”: 包含字符串?bc?的字符串
“A??”: 以字符?A?开头,且长度为3的字符串
“?A?”: 以字符?A?居其间，且长度为3的字符串
class MyString{
String str;
//其它方法或成员定义
//构造函数
public Boolean isLike(String regex){
……
}
}
new MyString(“abcd”).isLike(“a*”)--→true
new MyString(“ABCD”).isLike(“*C*”)--→true
new MyString(“ABCD”).isLike(“ABC?”)--→true
3. 设计一个静态方法，返回字符c 重复n次的字符串
public static String sameChar(char c,int n)
4. 设计一个方法，将字符串s 左边用字符fillChar填充，使其最终长度为length
public leftPadding(String s,int length, char fillChar)
5. 设计一个方法，将字符串s 右边用字符fillChar填充，使其最终长度为length
public rightPadding(String s,int length, char fillChar)
6. 设计一个方法，实现返回字符串左边n 个字符。
7. 设计一个方法，实现返回字符串右边n 个字符。
8．使用if语句和switch语句判断手机号码的种类.手机号码为11位,各位全部位数字,且前两位为13,第三位数字为5---9时属于移动手机号码,为0,1时属于连通GSM手机号码,为3时属于联通CDMA手机号码,为2,4时无效.
9．设计一方法，输入十进制数，返回12进制字符串。
10. 设计一个类，封装十六进制操作。
11. 编写一方法，输入一个字符串，输出布尔量。当该字符串是回文时，返回true,否则，返回false
12．输入一个英文字符串，统计出其中各字符出现的次数，并以下列样式输出：a=?,b=?,c=?,d=?,e=?
f=?,g=?,h=?,i=?,j=?
13. 输入一个英文字符串，统计出其中各字符出现的次数，并以下列样式输出：
a=?,b=?,c=?,d=?,e=?
f=?,g=?,h=?,i=?,j=?
14．设计一个星座类，并为其添加一个带参数的构造函数，
class Constellation{
private Calendar birthday;
public Constellation(String birthday){
}
String getConstellation(){返回星座
static public String getConstellation(String birthday) //返回星座
}
int getBornYear(){
}
int getBornMonth(){
}
int getBornDay(){
}
}
出生日期与星座关系如下：
1.20---
2.18 水瓶座
2.19----
3.20 双鱼座
3.21----
4.19. 牧羊座
4.20---
5.20 金牛座
5.21-----
6.21双子座
6.22.----
7.22巨蟹座
7.23----8.22 狮子座
8.23----9.22 处女座
9.23.----10.23天秤座
10.24-----11.22天蝎座
11.23---12.21 射手座
12.22.----1.19 山羊座
15. 编写一个计算英文句子中最长单词的长度(字符数)，假设该英文句子中只含有字母和
空格，句子以”.”结尾
StringBuffer类
前已述及，String 类创建的字符串是不可修改的，一般用于固定场合。如果要对字符串进行动态增减，则用StringBuffer类，因此，StringBuffer又称动态字符串。
1．构造函数
StringBuffer()
StringBuffer(int iniCapacity)
StringBuffer(String s)
2．操作函数：
2.1. 获得长度
int length() 返回字符串的个数
2.2. 添加对象
append(object obj)//在尾部添加对象
insert(int StartPos,object obj)在StartPos位置插入对象obj
2.3. 返回字符串
String toString()
2.4. 删除子串
StringBuffer delete(int start,int end)
删除从start开始到end-1之间的字符串,并返回当前对象的引用
StringBuffer deleteCharAt(int index)
删除索引为index位置处的字符,并返回当前对象的引用
2.5. 获得字符
char charAt(int index) 返回索引处的字符
2.6. 修改字符
void setCharAt(int index,char c) 设置索引index处的字符为c
2.7. 获得子串
String substring(int startIndex) 返回从startIndex开始直到最后的全部字符
String substring(int startIndex,int endIndex)返回范围startIndex--endIndex的字符串
2.8. 反转字符串
StringBuffer reverse()将该对象实体中的字符序列反转，并返回当前对象的引用。
2.9. 替换子串
String replace(int startIndex, int endIndex,String newStr)
用newStr替换当前对象从startIndex到endIndex-1 之间的字符序列，并返回对当前对象的引用。
练习：
1. 使用StringBuffer类，构建字符堆栈
public class CharStack{
private StringBuffer stack;
public CharStack(){
statck=new StringBuffer();
}
public CharStack(int capacity){
statck=new StringBuffer(capacity);
}
public void push(char c){
//将字符压入堆栈……
}
public int pop(){
//将字符弹出堆栈……
}
public char[] list(){
//返回堆栈数组……
}
public String toString(){
//将堆栈中的字符转换为字符串…
}
}
2. 编写一个检查java表达式中括号是否成对出现的函数。例如：
String exp1=Math.sqrt(p*(p-a[0])*(p-a[1])*(p-a[2])); 中括号是配对的，而
String exp2=Math.sqrt(p*(p-a[0]*(p-a[1])*(p-a[2])); 中括号是不配对的
StringBuilder类
该类在jdk1.4之后的版本才支持，它实现了与StringBuffer同样的接口，所以它们的操作相同，但是，由于StringBuilder没有实现同步机制，而StringBuffer实现了同步，所以StringBuilder比StringBuffer具有更高的性能。适合于对字符串进行动态增减的情形。
三．StringTokenizer类
该类用于分析字符串，特别适合于一个字符串用若干特殊字符分隔的情况。
1．构造函数：
StringTokenizer(String str)用缺省的分隔符(空格,回车,换行)分隔字符串
StringTokenizer(String str, String delim)用指定的分隔符delim分隔
2．属性函数：
countTokens();返回分隔后的字符串总数
3．操作函数：
boolean hasMoreElements() true 表示还有元素
Object nextElement() 返回下一个元素
boolean hasMoreTokens() true 表示还有元素
String nextTokens () 返回下一个元素
练习：
写一个函数：输入一个字符串(该字符串由若干个特殊字符分隔)，返回一个字符串数组。String[] breakString(String str)
例如：输入：”中国北京美国华盛顿英国伦敦"; 字符串由TAB 键,空格等字符分隔而成。返回: 元素1=中国北京元素2=美国华盛顿元素3=英国伦敦
类型包装器—Wrapper Class
在Java中使用基本数据类型来保存语言支持的基本数据类型,是出于性能方面的考虑，因为，使用对象类型会引起系统较大的开销。但有的时候需要将基本数据类型打包成相应的对象类型。使用类型包装器提供了将基本数据类型封装在一个对象内部的机制。两个术语：装箱(boxing): 将基本数据类型打包成对应的包装器类型的过程。
拆箱(unboxing): 将包装器类型变换为对应的基本数据类型的过程。
类型包装器有：
Double,Float,Long,Integer,Short,Byte,Character,Boolean.它们分别对应基本数据类型
double,float,long,int,short,byte,char,boolean.
一．字符包装器--- Character
构造函数：Character(char c) //ch 用于指定要由创建的Character对象包装字符
操作函数：char char Value(); 获得包装器内的char 的值:
二．布尔量包装器--- Boolean
构造函数：
Boolean (boolean boolValue ) // boolValue 只能取true或false
Boolean (String boolString )
操作函数：boolean boolean Value(); 获得包装器内的boolean 的值
三．数字类型包装器
这是使用最多的包装器，它们是Byte,Short,Integer,Long,Float,Double,所有数字类型的包装器，它们都继承自Number抽象类。
1．构造函数：
Double(double d)
Float(float f)
Long(long l)
Integer(int I)
Short(short s)
Byte(byte b)
2．操作函数：
double doubleValue()
float floatValue()
long longValue()
int intValue()
short shortValue()
byte byteValue();
四．Integer类型包装器
1．构造函数：
Integer(int value)
Integer(String s) throws NumberFormatException //s 为非数字时，抛出异常2．方法：
byte byteValue()
short shortValue();
int intValue()
long longV alue();
//上述函数将当前类型转换为相应的类型
public static int parseInt(String s) throws NumberFormatException
将串s转换为10进值整数, s 为非数字时，抛出异常
public static int parseInt(String s,int radix) throws NumberFormatException
将字符串s 按指定的进制(解释) radix 转换为10 进制整数
s 为非数字时，抛出异常
public static String toBinaryString(int n)
将n 转换为二进值字符串
public static String toHexString(int n)
将n 转换为十六进值字符串
public static String toOctalString(int n)
将n 转换为八进值字符串
public static String toString(int n)
将n 转换为十进值字符串
五．Long类型包装器
与Integer类似
六．自动装箱和拆箱
jdk1.5之后的版本，提供了自动装箱和拆箱的功能。例如：
1. 自动装箱
jdk1.5之前的版本，将int k=88 转换为对应的Wrapper类时，使用下列语法：Integer it=new Integer(k) 或Integer it=Integer.valueOf(k)
jdk1.5之后的版本,实现上述过程，使用下列语法：
Integer it=k;
2.自动拆箱
jdk1.5之前的版本，将Integer it 转换为对应的基本数据类型时，使用下列语法：int m=it.intValue();
jdk1.5之后的版本,实现上述过程，使用下列语法：
Integer myInteger;
int n= myInteger; //完成自动转换
它等价于：
Integer myInteger;
int n= myInteger.intValue();
3.使用自动装箱和拆箱必须注意的问题
3.1.自动拆箱的过程有的时候是不可靠的。建议在拿不准的时候，手动进行装箱
和拆箱。如：
Integer intObj=null;
int a= intObj; 这样的语句在编译时是合法的，但在运行时会产生错误。
3.2. 在自动装箱时，为了提高性能，对于-128----+127之间的值系统将它们
封装为对象後，会保存在内存中被重用。
思考：
1.下列代码输出的结果是什么？
Integer i1=100;
Integer i2=100;
if(i1==i2)
System.out.println(“i1==i2”);
else
System.out.println(“i1!=i2”);
输出结果为：i1==i2
2.下列代码输出的结果是什么？
Integer i1=200;
Integer i2=200;
if(i1==i2)
System.out.println(“i1==i2”);
else
System.out.println(“i1!=i2”);
输出结果为：i1！=i2
Math类
一．常量
final static E=2.72
final static PI=3.14
二．三角函数
static double sin(double arg) //返回arg的正弦值
static double cos(double arg) //返回arg的正弦值
static double tan(double arg) //返回arg的正弦值
static double asin(double arg) //返回arg的正弦值
static double acos(double arg) //返回arg的正弦值
static double atan(double arg) //返回arg的正弦值
三．指数函数
static double log(double arg) //返回arg的正弦值
static double pow(double y,double x) //返回y的x次方
static double sqrt(double arg) //返回arg的平方根
四．取整函数
static int abs(int arg) //返回arg的绝对值
static long abs(long y) //返回y的绝对值
static int max(int x,int y) //返回x,y的最大值
static int min(int x,int y) //返回x,y的最小值
static double ceil(double d) //返回>=d 的最小浮点数(小数位始终为.0)
static double floor(double d) //返回<=d 的最大浮点数(小数位始终为.0)
例如：ceil(123.15) 结果为124.0 floor(123.91) 结果为123.0
static double rint(double arg) //返回对arg四舍五入的浮点数(小数位始终为.0)
static int round(float arg) //返回对arg四舍五入后的最近的整数
static long round(double arg) //返回对arg四舍五入后的最近的长整数
练习：
1．输入出租车公里数，输出应付的车费数：
收费标准如下：3000米以下为8元，每超过500米增加1.2元，不足500米按500米计算。
2．竹竿长10米，每天截取一半，过多少天后，竹竿长度会小于10厘米。
3．写一个实例方法，要求输入一个整数m ，并输出1---m之间满足下列条件的所有整数：这个数+1 是一个完全平方数，他的一半+1也是一个完全平方数。
4．编写一个方法：double round(double m ,int n)将m四舍五入到小数点后第n位。如果对m 进行7舍8入又如何实现呢？
5. 写一函数：实现对任意双精度数，四舍五入到指定的小数位数。
public static double round2(double d,int n){
}
Random类
该类用于产生随机数，在java.util包中
一．构造函数：
Random()
Random(long seed)
二．方法：
int nextInt(int max) 产生一个0~~max-1之间的32位随机数
long nextLong(long max)产生一个0~~max-1之间的64位随机数
float nextFloat() 产生一个0.0---1.0之间的单精度随机数(<1.0)
double nextDouble()产生一个0.0---1.0之间的双精度随机数(<1.0)
boolean nextBoolean() 产生一个布尔随机数(true,false)
void nextBytes(byte[] b) 产生一个随机byte数组, 注意：bye[] 数组必须分配存储空间例如，随机产生一个小写字母
Random rand=new Random();
int n=rand.nextInt(26)+97 //97=?a?
char c=(char)n;//转换为字母
练习：
1.生成0—9之间的随机整数，并统计个数出现的次数
2.设计一个类，并提供一个实例方法nextInteger(int m,int n),用以返回m—n(不含n) 之
间的随机数.
3.从Random 派生一个类RandomExt,该类提供一个实例方法：nextInteger(int m,int n),
用以返回m—n(不含n) 之间的随机数.
4.用Random类产生一个具有n个随机英文字符构成的字符串。
5.编写一个函数，产生n个字符构成的字符串。假设要产生的字符仅有1,5,A,D,P,X,
字符组成。
Date类
表示日期和时间,在java.util包中
一．构造函数：
Date() //用当前时间初始化实例。
Date(long date) // date 为毫秒
Date(int year, int month, int day)
二．方法：
setTime(long date) // date 为毫秒，设置时间
long getTime() //转换为毫秒数
static Date valueOf(String s) //转换字符串格式的日期为Date
三．相关类SimpleDateFormat
用于格式化日期，在java.text包中
1．构造函数：
SimpleDateFormat(String FormatString);
参数FormatString常用样式为
y或yy 表示年份；yyyy 表示世纪和年份
m 或MM表示月份
d 或dd 表示天
H 或HH表示小时
m 或mm 表示分
s 或ss 表示秒
E 表示字符串输出的星期
2．操作方法：
String format(Date d); 根据构造函数中的格式将Date对象输出。
例如：
SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d=new Date();
String DateString=sf.format(d); //返回类似的日期2005-08-07 07:10:24
四．相关类DateFormat
用于格式化日期，在java.text包中
1．静态方法
DateFormat getDateTimeInstance(int dateStyle,int timeStyle,Locale alocal) 该方法用于获得一个DateFormat实例.
dateStyle 日期类型，通常取常数DateFormat.LONG
timeStyle 时间类型，通常取常数DateFormat.LONG
alocal 地区常数，通常取常数Locale.CHINA(中国), https://www.360docs.net/doc/e212732371.html,(美国)
2 . 实例方法
String format(Date d) 用格式去格式化参数Date 对象，并返回字符串.
例如：
DateFormat df=DateFormat.getDateTimeInstance(DateFormat.LONG,
DateFormat.LONG,Locale.CHINA);
System.out.println(df.format(new Date())); //按中国格式显示日期时间
Calendar 类
本类提供了月历功能，但这些功能都是由其子类GregorianCalendar实现的。一．GregorianCalendar类的常用方法：
1．构造函数：
GregorianCalendar();用当前系统日期初始化对象
2．方法：
2.1. 获得日期的各个部分
int get(int field) 返回与field相关的日期，field是Calendar中定义的常数(见静态字段) 例如：get(Calendar.MONTH) 返回月份(1月份，返回0，2月份，返回1，。。。)
2.2. 修改日期的各个部分
void set(int field,int value) 将field表示的日期替换为value值
例set(Calendar.YEAR,2000);将年份设定为2000年
2.3. 重新设置新的日期
final void set(int year,int value) //设置年/月/日的值为value
final void set(int year,int month,int date) //设置年月日
final void set(int year,int month,int date, int hour,int minute) //设置年月日时分秒
final void set(int year,int month,int date, int hour,int minute,int second)
设置年月日时分秒和毫秒
2.4. 获得对象毫秒数
long getTimeInMillis();
例：
GregorianCalendar gre=new GregorianCalendar(); //获得实例
String now=gre.get(Calendar.YEAR)+"-"+gre.get(Calendar.MONTH)+"-"+
gre.get(Calendar.DATE)+""+gre.get(Calendar.HOUR_OF_DAY)+":"+
gre.get(Calendar.MINUTE)+ ":"+gre.get(Calendar.SECOND);
System.out.println(now); //显示当前日期时间
二．Calendar类
1．获得Calendar实例
Calendar Calendar.getInstance(); 返回一个Calendar实例
2．方法：
2.1. 转换为其它类型
Date getTime(); //获得日期
long getTimeMillis() //转换为毫秒
2.2. 增加日期的某个部分
void add(int field,int amount) 将field代表的内容增加amount
2.3. 返回field 表示日期部分的最大值
int getMaximum(int field)返回field的最大值
2.4. 设置日期
setTime(Date date) //设置日期
三．静态字段：
YEAR, MONTH , DATE(DAY_OF_MONTH) 分别表示年月日
HOUR MINUTE SECOND 分别表示时分秒，HOUR 为12小时制
HOUR_OF_DAY表示一天中的第几时(为24小时制)
DAY_OF_YEAR 表示一年中的第几天
WEEK_OF_YEAR表示一年中的第几周
WEEK_OF_MONTH表示一月中的第几周
DAY_OF_WEEK 表示一周中的第几天(1 表示星期日,2 表示星期一，。。。)
例：获得当前日期和时间
Calendar cal=Calendar.getInstance();
int year=cal.get(Calendar.YEAR); //
int month=cal.get(Calendar.MONTH)+1;
int day=cal.get(Calendar.DAY_OF_MONTH);
String sDate=year+"-"+month+"-"+day+" "+cal.get(Calendar.HOUR)+":"+
cal.get(Calendar.MINUTE)+":"+cal.get(Calendar.SECOND);
练习：
1．计算2007.7.10与1971.6.1之间相差的天数。
2．设计一个方法，返回当前时间距离北京奥运会(2008年8月8日)相距的天数。
3．编写一个方法，计算888天之后的日期。
4．编写一个方法，计算你出生的那一天是星期几。并显示你从出生到现在每年过生日那一天的星期数，同时统计出最多的星期几
5．设计一个类，并提供一个静态方法，可以用于计算两个日期之间相差的年、月、季度、天、小时等。
java.util.Arrays类
本类提供了数组整理，比较及检索功能。它的所有方法都是静态的
一．常用静态方法：
1.搜索
public static int binarySerach(byte[] a,int key)
public static int binarySerach(double[] a,double key)
public static int binarySerach(Object[] a, Object key)
在数组a中对key进行二进制搜索，并返回key所在的位置，没有找到，返回负数2．相等比较
public static boolean equals(byte[] a, byte[] b)
public static boolean equals(double[] a, double[] b)
public static boolean equals(Object[] a, Object [] b)
比较两个数组，如果数组元素均相同，返回true，否则，返回false 3．填充
public static void fill(byte[] a, byte val)
public static void fill(double[] a, double val)
public static void fill(Object[] a, Object val)
将数组a中的所有元素填充为val
public static void fill(byte[] a, int fromIndex,int toIndex,byte val)
public static void fill(double[] a, int fromIndex,int toIndex ,double val)
public static void fill(Object[] a, int fromIndex,int toIndex, Object val)
将数组中a中,从索引fromIndex到toIndex的所有元素填充为val 4．排序
public static void sort(byte[] a)
public static void sort(int[] a)
public static void sort(long[] a)
public static void sort (double[] a, byte val)
public static void sort (Object[] a)
将数组中a的所有元素进行升序排序
public static void sort(byte[] a, int fromIndex,int toIndex)
public static void sort(int[] a, int fromIndex,int toIndex)
public static void sort(long[] a, int fromIndex,int toIndex)
public static void sort (double[] a, int fromIndex,int toIndex)
public static void sort (Object[] a, int fromIndex,int toIndex)
将数组a中,从索引fromIndex到toIndex-1的所有元素进行升序排序
System类
System.arraycopy(Object[] src,int srcPos,Object dest,int destPos,int length) 从源对象数组src的srcPos位置开始取长度为length个元素拷贝到目标数组中
dest 中，并从destPost位置开始存放。
System.currentTimeMillis(); 获得当前时间的毫秒数
java.math.BigInteger类
此类用来表示大整型数(即基本数据类型(int,long)无法存储的整数)
一．构造函数
public BigInteger(String val)
public BigInteger(String val,int radix)将字符串转换为radix进制整数，然后再创建对象二．操作方法：
public BigInteger abs(); 返回绝对值
public BigInteger add(BigInteger val); 加
public BigInteger subtract(BigInteger val); 减
public BigInteger multiply(BigInteger val); 乘
public BigInteger divide(BigInteger val); 除
public BigInteger max(BigInteger val); 最大值
public BigInteger min(BigInteger val); 最小值
public BigInteger mod(BigInteger val); 取模
public BigInteger pow(BigInteger val); 幂
public int intValue(); 转换为int 返回
public long longValue();转换为long 返回
Time类和TimerTask类
一．概述：
所在包：java.util
这两个类通常配合完成只执行一次或周期性重复执行的任务。
TimerTask类提供实际要执行的任务。一个实际的任务必须从这个类扩展，并覆盖run 方法(要完成的任务在该方法中实现)；
Timer类通过后台线程调度任务，使任务得以执行。
二．Timer类
常用构造方法：
Timer()
Timer(String name)
常用操作方法：
schedule(TimerTask task,int delayRunTime,int interval)
task 任务类或其子类
delayRunTime 第一次运行时间(相对于方法该方法调用后), ms
interval 任务被重复执行的时间间隔,ms
cancel();//停止时钟
三．TimerTask类
常用构造方法：
TimerTask（int maxCounter,Timer aTimer）
maxCounter任务被执行的总次数
aTimer Timer对象
常用操作方法：
run() 必须被子类覆盖的方法(用于要执行的任务)
cancel();//停止任务
四．程序设计要点：
1.首先从TimerTask扩展一个自己的类
class MyTimerTask extends TimerTask{
private int maxNumberOfTimesToRun=0;//任务被执行的总次数
private Timer myTimer=null;
public MyTimerTask(int maxCounter,Timer aTimer){
super();
maxNumberOfTimesToRun= maxCounter;
myTimer=aTimer
}
//覆盖父类的方法
public void run(){
//要执行的任务代码
}
}
2.启动Timer运行
获得一个Timer实例
获得TimerTask实例
调用schedule()方法使Timer运行。
五．例子：
1.扩展TimerTask
import java.util.*;
class MyTimerTask extends TimerTask{
private int maxNumberOfTimesToRun=0;//任务被执行的总次数
private int runCounter=0;//任务已经被调度的次数
private Timer myTimer=null;
private Random rand=new Random();//用于产生随机数，模拟人物
public MyTimerTask(int maxCounter,Timer aTimer){
super();
maxNumberOfTimesToRun= maxCounter;
myTimer=aTimer;
}
//覆盖父类的方法
public void run(){
//要执行的任务代码
if(runCounter long currentTime=System.currentTimeMillis(); Date dt=new Date(currentTime); System.out.print(dt+"==>"); System.out.println(rand.nextInt(999999));//产生一个随机数 runCounter++; } else{ cancel();//停止任务 myTimer.cancel();//停止时钟 System.out.println("任务已经全部完成！"); } } 2启动调度器 public class RunTask { public static void main(String[] args){ Timer myTimer=new Timer();//实例化Timer //实例化TimerTask,任务被执行5次 MyTimerTask task=new MyTimerTask(5,myTimer); myTimer.schedule(task,0, 3000);//启动时钟 } } 例如求平方根的(n)，求a的b次方(a, b)，求绝对值(n)等很多。下面是一些演示。publicclassMathTest { publicstaticvoidmain(String[]args) { intn=16; ？ 3)); ？ ？ } } publicclassMathDemo{ publicstaticvoidmain(Stringargs[]){ /** *abs求绝对值 */ 的时候会取偶数 */ // // // // // // // // // // /** *round四舍五入，float时返回int值，double时返回long值 */ //10 //11 //11 //11 //-10 //-11 //-11 //-10 } } 函数（方法） 描述 IEEEremainder(double,double) 按照IEEE754标准的规定，对两个参数进行余数运算。 abs(inta) 返回int值的绝对值 abs(longa) 返回long值的绝对值 abs(floata) 返回float值的绝对值 abs(doublea) 返回double值的绝对值 acos(doublea) 返回角的反余弦，范围在到pi之间 asin(doublea) 返回角的反正弦，范围在-pi/2到pi/2之间 atan(doublea) 返回角的反正切，范围在-pi/2到pi/2之间 atan2(doublea,doubleb) 将矩形坐标(x,y)转换成极坐标(r,theta) ceil(doublea) 返回最小的（最接近负无穷大）double值，该值大于或等于参数，并且等于某个整数cos(double) 返回角的三角余弦 exp(doublea) 返回欧拉数e的double次幂的值 floor(doublea) 返回最大的（最接近正无穷大）double值，该值小于或等于参数，并且等于某个整数log(doublea) 返回（底数是e）double值的自然对数 max(inta,intb) 返回两个int值中较大的一个 max(longa,longb) 返回两个long值中较大的一个 max(floata,floatb) 返回两个float值中较大的一个 max(doublea,doubleb) 返回两个double值中较大的一个 min(inta,intb) 返回两个int值中较小的一个 min(longa,longb) 返回两个long值中较小的一个 min(floata,floatb) JAVA中常用类的常用方法 一、类 1、clone()方法 创建并返回此对象的一个副本。要进行“ 克隆” 的对象所属的类必须实现. Cloneable接口。 2、equals(Object obj)方法 功能：比较引用类型数据的等价性。 等价标准：引用类型比较引用，基本类型比较值。 存在特例：对File、String、Date及封装类等类型来说，是比较类型及对象的内 容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法 返回该对象的哈希码值。 5、notify()方法 唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法 唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 String类 charAt(int index) 返回指定索引处的 char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比 较，不考虑大小写。 indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 常用类 （1）字符串相关类（String，StringBuffer） 1）https://www.360docs.net/doc/e212732371.html,ng.String类代表不可变得字符序列； 2）"***"为该类的一个对象； 3）String类的常见构造方法：String（String original）//创建一个String对象为original 的拷贝；String（char[] value）//用一个字符数组创建一个String对象；String（char[] value,int offset,int count）； 4）String 类的常用方法：char charAt（int index）//返回第index个字符、int length()//返回字符串的长度、int indexOf(String str)//返回字符串中出现Str的第一个位置；int indexOf(String str,int fromIndex)//返回字符串中从fromindex开始出现Str的第一个位置；boolean equalsIgnoreCase(string another)//比较是否相等，忽略大小写；String replace(char olochar,char newchar)；boolean startswith(String prefix)//判断字符串是否以prefix字符串开头；boolean endsWith(String suffix);String toUpperCase()//返回一个字符串为该字符串的大写形式；String toLowerCase();String substring(int beginIndex0)//返回该字符串从beginindex开始到结尾的子字符串；String substring(int beginindex,int endindxt);String trim()//返回将该字符串去掉开头和结尾空格后的字符串。静态重载方法：public static String valueOf（。。。）//将基本类型数据转换为字符串。String[] split(String regex)//将一个字符串按照指定的分隔符分隔，返回分隔后的字符串数组。 （2）StringBuffer类:可变的字符串序列； 1）构造方法：StringBuffer();StringBuffer(string str); 2）常用方法：StringBuffer append()；insert();delete();indexOf();rerverse(); （2）基本数据类型包装类:Integer,Double将基本数据类型包装成一个对象； （2）Math类：方法 （3）File类：各类的方法 （4）枚举类Enum：只能够取特定值中的一个，使用enum关键字，是https://www.360docs.net/doc/e212732371.html,ng.Enum类型； JAVA屮常用类的常用方法 一．java?丨ang.Object 类 1、clone()方法 创建丼返M此对象的一个副木。要进行“克隆”的对象所属的类必须实现https://www.360docs.net/doc/e212732371.html,ng. Cloneable 接口。 2、equals(Objectobj)方法 0 功能：比较引用类型数据的等价性。 0 等价标准.?引用类型比较引用，基木类型比较值。 0 存在特例.?对File、String、Date及封装类等类型来说，是比较类型及对象的内稃而+ 考虑引用的是否为同一实例。 3、finalize〇方法 当垃圾丨"丨收器确定>(、存在对该对象的更多引用时，由对象的垃圾丨"丨收器调用此方法。 4、hashCode〇方法返 回该对象的哈希码值。 5、notify〇方法 唤醒在此对象监视器上等待的中?个线祝。 6、notifyAII〇方法 唤醒在此对象监视器上等待的所有线程= 7、toString()方法 返W该对象的字符串表示。在进行String与其它类型数据的连接操作时，&动调用tostringo 方法。可以根据耑要重写toStringO方法。 8、wait()方法 在其他线程调用此对象的n〇tify()方法或notifyAIIO方法前，异致当前线程等待。 二、字符串相关类 I String 类 charAt(int index)返回指定索引处的char值。compareTo{String anotherString)按字 典顺序比较两个字符串。compareTolgnoreCase(Stringstr)按字典顺序比较两个字 符串，不考虑人小写。concat(String str)将指定字符串连接到此字符串的结尾。 endsWith(String suffix)测试此字符串是否以指定的〗?缀结束。equals{Object anObject)将此字符串与指定的对象比较。 equalslgnoreCase(String anotherString)将此String 与另一个String 比较，考虑人小'与’。indexOf(int ch)返H指定字符在此字符串屮第一次出现处的索引。 indexOf(String str)返回第一次出现的指定子字符串在此字符串屮的索引， lastlndexOf(intch)返回指定字符在此字符串中最后??次出现处的索引。 length()返|n丨此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。 split(String regex)根据给定正则表达式的匹配拆分此字符串。startsWith{String prefix)测试此字符 串是否以指定的前缀开始。substring(int beginlndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginlndex, int endlndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginlndex 处开始，一直到索引endlndex-1处的字符。 t〇CharArray()将此字符串转换为一个新的字符数组。 JAVA中常用类的常用方法 一、https://www.360docs.net/doc/e212732371.html,ng.Object类 1、clone()方法 创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现https://www.360docs.net/doc/e212732371.html,ng. Cloneable接口。 2、equals(Object obj)方法 ?功能：比较引用类型数据的等价性。 ?等价标准：引用类型比较引用，基本类型比较值。 ?存在特例：对、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的notify() 方法或notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 l String类 charAt(int index) 返回指定索引处的char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此String 与另一个String 比较，不考虑大小写。indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar 替换此字符串中出现的所有oldChar 得到的。split(String regex) 根据给定正则表达式的匹配拆分此字符串。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginIndex 处开 Abstract class 抽象类:抽象类是不允许实例化的类，因此一般它需要被进行扩展继承。 Abstract method 抽象方法:抽象方法即不包含任何功能代码的方法。 Access modifier 访问控制修饰符:访问控制修饰符用来修饰Java中类、以及类的方法和变量的访问控制属性。 Anonymous class 匿名类:当你需要创建和使用一个类，而又不需要给出它的名字或者再次使用的使用，就可以利用匿名类。 Anonymous inner classes 匿名内部类:匿名内部类是没有类名的局部内部类。 API 应用程序接口:提供特定功能的一组相关的类和方法的集合。 Array 数组:存储一个或者多个相同数据类型的数据结构，使用下标来访问。在Java中作为对象处理。 Automatic variables 自动变量:也称为方法局部变量method local variables，即声明在方法体中的变量。 Base class 基类:即被扩展继承的类。HP0-538 Blocked state 阻塞状态:当一个线程等待资源的时候即处于阻塞状态。阻塞状态不使用处理器资源 Call stack 调用堆栈:调用堆栈是一个方法列表，按调用顺序保存所有在运行期被调用的方法。 Casting 类型转换 :即一个类型到另一个类型的转换，可以是基本数据类型的转换，也可以是对象类型的转换。 char 字符:容纳单字符的一种基本数据类型。 Child class 子类:见继承类Derived class Class 类:面向对象中的最基本、最重要的定义类型。350-018 Class members 类成员:定义在类一级的变量，包括实例变量和静态变量。 Class methods 类方法:类方法通常是指的静态方法，即不需要实例化类就可以直接访问使用的方法。 Class variable 类变量:见静态变量Static variable public static void main(String[] args) { String str1; str1 = "你好"; // 使用字符串常量构造一个字符串 String str2 = new String("你好"); // String类中重写了父类Object类的equals方法 // String类中的equals方法比较的是字符串的内容 // 使用String类中的equals方法时，建议将字符串常量写在前面 String str3 = null; System.out.println("你好".equals(str3));//正确写法 //System.out.println(str3.equals("你好"));//错误写法 // 使用equals方法 System.out.println(str1.equals(str2));//true System.out.println(str1 == str2);//false // 使用char数组构造一个字符串 char [] ch1 = {'a', 'b', 'c'}; String str4 = new String(ch1); System.out.println("str4: " + str4); char [] ch2 = {'a', 'b', 'c', 'd', 'e', 'f'}; String str5 = new String(ch2, 2, 2); System.out.println("str5: " + str5); // 使用byte数组构造一个字符串 //byte [] by1 = {-50, 3, 100}; byte [] by1 = "测试".getBytes(); String str6 = new String(by1); System.out.println("str6: " + str6); // String类中的equals方法和等号String str7 = "西安网星"; String str8 = "西安网星"; System.out.println(str7.equals(str8));//true 教学内容 第七讲Java常用类库介绍 7.1 Java类库的结构 类库就是Java API(Application Programming Interface，应用程序接口)，是系统提供的已实现的标准类的集合。在程序设计中，合理和充分利用类库提供的类和接口，不仅可以完成字符串处理、绘图、网络应用、数学计算等多方面的工作，而且可以大大提高编程效率，使程序简练、易懂。 Java类库中的类和接口大多封装在特定的包里，每个包具有自己的功能。表7．1列出了Java中一些常用的包及其简要的功能。其中，包名后面带“. *”的表示其中包括一些相关的包。有关类的介绍和使用方法，Java中提供了极其完善的技术文档。我们只需了解技术文档的格式就能方便地查阅文档。 表7．1Java提供的部分常用包 注：在使用Java时，除了https://www.360docs.net/doc/e212732371.html,ng外，其他的包都需要import语句引入之后才能使用。 7.2 https://www.360docs.net/doc/e212732371.html,ng包中的常用类 https://www.360docs.net/doc/e212732371.html,ng是Java语言最广泛使用的包。它所包括的类是其他包的基础，由系统自动引入，程序中不必用import语句就可以使用其中的任何一个类。https://www.360docs.net/doc/e212732371.html,ng中所包含的类和接口对所有实际的Java程序都是必要的。下面我们将分别介绍几个常用的类。 7.2.1 String类和StringBuffer类 许多语言中，字符串是语言固有的基本数据类型。但在Java语言中字符串通过String类和StringBuffer类来处理。 1．String类 Java语言中的字符串属于String类。虽然有其它方法表示字符串（如字符数组），但Java使用String 类作为字符串的标准格式。Java编译器把字符串转换成String对象。String对象一旦被创建了，就不能被改变。如果需要进行大量的字符串操作，应该使用StringBuffer类或者字符数组，最终结果可以被转换成String格式。 （1）创建字符串 创建字符串的方法有多种方式，通常我们用String类的构造器来建立字符串。表6．2列出了String 类的构造器及其简要说明。 表7．2 String类构造器概要 【例7．1】使用多种方法创建一个字符串并输出字符串内容。 public class StrOutput { public static void main(Sring[] args) { //将字符串常量作为String对象对待，实际上是将一个String对象赋值给另一个 String s1 = "Hello,java!"; //声明一个字符串，然后为其赋值 String s2; s2 = "Hello,java!"; java常用类知识点总结 Java常用类 要求: 1、掌握String和StringBuffer的区别，可以熟练使用String和StringBuffer的各 种方法进行相关操作。 2、能够自己编写一个得到日期的操作类，并将日期进行格式化操作。 3、掌握比较器及其基本原理，并可以通过比较器进行对象数组的比较操作。 4、掌握对象克隆技术及其实现 5、能够灵活应用正则表达式对字符串的组成进行判断 6、掌握Math、Random、基本数据类型的包装类的使用 7、描述出Object System对垃圾收集的支持 8、使用NumberFormat、DecimalFormat、BigInteger、BigDecimal进行数字的操 作 String和StringBuffer String的内容一旦声明不可改变，如果要改变，改变的是String的引用地址，如果一个字符串要经常改变，必须使用StringBuffer。 在一个字符串内容需要频繁修改时，使用StringBuffer可以提升操作性能，因为StringBuffer内容可以改变，而String内容不可改变。StringBuffer支持的方法大部分与String类似。 StringBuffer常见用法: (1) 字符串的连接操作 String类可以通过“+“进行字符串的连接，而StringBuffer中却只能使用append方法进行字符串的连接，而且此方法返回一个StringBuffer类的实例，这样就可以采用代码链的形式一直调用append方法。 (2) 在任意位置处为StringBuffer添加内容 可以使用insert方法在指定位置上为StringBuffer添加内容 字符串的反转操作(较为常见的操作，使用reverse方法) (3) 替换指定范围的内容 replace方法可对指定范围的内容进行替换。在String中如果要替换，使用的是replaceAll (4) 字符串截取(使用subString方法从指定范围中截取内容) (5) 删除指定范围的字符串(使用delete方法删除指定范围内容) (6) 查找指定内容是否存在(indexOf查找指定内容，查找到返回内容的位置， 没查到返回-1) 问题:(1)String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有, 没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢,答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改， 或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符 实验5 Java类库和常用类（一） 一. 实验目的及实验环境 1理解类库的概念，掌握分析、应用类库中的类的方法。 2熟练掌握Math类的常用方法。熟悉Random类的常用方法。 3理解String类的特性，熟练掌握String类的常用方法。 4能用Date类创建对象，熟练掌握Date类的常用方法。 5熟练掌握SimpleDateFormat解析日期和设置日期输出格式。 6学会查阅Java API在线参考文档和离线文档的方法。 二. 实验内容 1 基本内容（实验前请及时熟悉如下相关内容） 1）练习使用Math类的常用方法。 2）应用String类编程练习。 3）编写程序应用Random类生成随机数。 4）练习使用Date类的常用方法。 5）查阅Java API在线参考文档和下载Java API离线文档。 示例1. 应用SimpleDateFormat类的程序示例如下,共同学们模仿参考。 import java.text.*; import java.util.Date; public class FormatDateTime { public static void main(String[] args) { SimpleDateFormat myFmt = new SimpleDateFormat("yyyy年MM月dd日 HH 时mm分ss秒"); SimpleDateFormat myFmt1 = new SimpleDateFormat("yy/MM/dd HH:mm"); SimpleDateFormat myFmt2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 等价于now.toLocaleString() SimpleDateFormat myFmt3 = new SimpleDateFormat("yyyy年MM月dd日 HH 时mm分ss秒 E "); SimpleDateFormat myFmt4 = new SimpleDateFormat("一年中的第 D 天一年中第w个星期一月中第W个星期在一天中k时 z时区"); Date now = new Date();//当前时间 System.out.println(myFmt.format(now)); System.out.println(myFmt1.format(now)); System.out.println(myFmt2.format(now)); System.out.println(myFmt3.format(now)); System.out.println(myFmt4.format(now)); System.out.println(now.toGMTString());//The method toGMTString() from the type Date is deprecated. System.out.println(now.toLocaleString()); System.out.println(now.toString()); } } 常用类 Object类 它是Java所有类的根类.所以Java的所有对象都拥有Object类的成员. 1．一般方法 boolean equals(Object obj) //本对象与obj对象相同，返回true String toString() //返回本对象的字符串表达形式，默认返回类名称和十六进制数的编码，即：getClass().getName+’@’+Integer.toHexString(hashCode()); 如果要显示自定义的对象，则需要覆盖这个方法。 protected void finalize() throws Throwable //对象销毁时被自动调用, native int hashCode() 返回对象的Hash码，Hash码是表示对象的唯一值，故Hash码相同的对象是同一对象。 2．控制线程的方法 final native void wait() //等待对象 final native void notify() //通知等待队列中的对象进入就绪队列 final native void notifyAll()//通知所有处于等待队列中的对象进入就绪队列 3．关于Object类的几点说明： 3.1. native <方法> 是指用C++语言编写的方法。 3.2.“==”运算符一般用于基本数据类型的比较，如果用于两个引用对象的比较，则 只有当两个引用变量引用同一个对象时，才返回true,否则返回false. String s1=new Strng(“java”); String s2=new Strng(“java”); System.out.pritnln(s1==s2); //显示false 但是，假如不使用new 关键字，创建String 型对象s3,s4,则它们引用的是同一个对象。 String s3=“java”; String s4=“java”;因为没有使用new 关键字，所以s4 引用既存的对象 System.out.pritnln(s3==s4); //显示true, 3.3. 比较对象内容时,使用equals()函数 Object 类的equals()定义 Public boolean equals(Object obj){ return (this==obj); } 由于String 类覆盖了继承自Object类的equals()方法,它比较的是引用对象的内容. 所以,没有覆盖equals()方法的类的对象使用该方法与另一对象进行比较时,永远返 回false; 只是因为此时进行比较调用的是Object的equals方法. 4. Object引用型变量 Object引用型变量可以用来引用所有的对对象. Object[] obs=new Object[3]; obs[0]=new Strng(“12345”);//将String对象赋给obs[0] obs[0]=new Boolean(true); obs[0]=new Integer(100); 5. toString()方法 字符串操作：字符串的比较： boolean equals()比较此字符串与指定的对象。 Int compareTo() 比较源与（）的大小，两串大小相等返回0 加IgnoreCase()不考虑大小写boolean contains(CharSequence s) 当且仅当此字符串包含 char 值的指定序列时，才返回 true。 字符串的长度与组合： char charAt(int index)返回指定索引处的 char 值。 String concat(String str)将指定字符串联到此字符串的结尾。 int length() 返回此字符串的长度。 获取子串： String substring(int beginIndex) 返回一个从beginIndex到末尾的子串 String substring(int beginIndex, int endIndex) 返回一个从beginIndex到endIndex-1的字串 字符串的转换、替换和分隔： char[] toCharArray() 将此字符串转换为一个新的字符数组。 String toString() 返回此对象本身（它已经是一个字符串！）。 String toLowerCase() 变为全小写 String toUpperCase() 变为全大写 String trim() 返回字符串的副本，忽略前导空白和尾部空白。 String replace(char oldChar, char newChar) 用 newChar 替换此字符串中出现的所有 oldChar，返回新字符 String replaceAll(String regex, String replacement) 使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的每个子字符串。 String replaceFirst(String regex, String replacement) 使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的第一个子字符串。 String[] split(String regex) 在给定字符处拆分原字符串为若干字串。 找出相应字符或字串（找不到返回-1） int indexOf() 返回（？）填入的字符（串）在源中的第一个索引；（？,num）从num索引开始查找 int lastIndexOf()返回最后一次出现的指定值索引。 将字符和数值转化为字符串： Static String valueOf() 将（）填入的参数（任意、包括Obj）转化为字符串 StringBuilder类：构建： StringBuilder() 构建一个容量为16的空字符串生成器，（）填入数字构造指定大小，填入String 构造含有指定字符。 int capacity() 返回当前容量。 char charAt(int index) 指定索引处的 char 值。添改： StringBuilder append() 将特定内容由（）传入buffer StringBuilder insert(int offset,？) 将？变量插在此序列的offset 前 void setCharAt(int index, char ch) 改变索引处的字符为ch。 StringBuilder replace(int start, int end, String str) 替换从start至end-1处字符为str StringBuilder reverse() 反转字符序列。删除： StringBuilder delete(int start, int end) 移除从start索引到end-1索引的字符串。 StringBuilder deleteCharAt(int index) 移除此序列指定位置上的 char。查找： int indexOf(String str) 同String用法 int lastIndexOf()同String用法 int length() 返回长度（字符数）。返回值： int capacity() 返回当前容量。 Java常用类习题 一、选择题 1.下列String类的（）方法返回指定字符串的一部分(选择一项) A.extractstring() B.substring() C.Substring() D.Middlestring() 2．下列哪一个是正确的（） A) HashTable的关键字和值都允许为null B) HashTable的关键字和值都不允许为null C) HashTable的关键字允许为null，值不允许为null D) HashTable的关键字不允许为null，值允许为null 3．对于下列代码： String str1="java"; String str2="java"; String str3=new String("java"); StringBuffer str4=new StringBuffer("java"); 以下表达式的值为true的是（） A) str1= =str2; B) str1= =str4; C) str2= =str3; D) str3= =str4; 4．以下程序段输出结果的是（） public class Test { public static void main(String args[]){ String str="ABCDE"; str.substring(3); str.concat("XYZ"); System.out.print(str); } } A) DE B) DEXYZ C) ABCDE D) CDEXYZ 5．对于下列代码: public class Example{ String str=new String("hello"); char ch[]={'d','b','c'}; public static void main(String args[]){ Example ex=new Example(); ex.change(ex.str,ex.ch); System.out.println(ex.str+"and"+ex.ch[0]); } public void change(String str,char ch[]){ str="world";ch[0]= 'a'; } Java中String中类的常用方法 1）public String(char [] value):将字符数组转成字符串； char c[]={…f?,?w?,?s?,?w?,?g?,?a?}; String s=new String(c); System.out.println(s); 结果为：fwswga 2）public String(cahr [] value,开始位置,新字符串的长度):将指定位置长度的字符数组转成字符串； char c[]={…f?,?w?,?s?,?w?,?g?,?a? } String s=new String(c,2,2); System.out.println(c); 结果为：sw 3) public String (byte [ ] value):将字节数组转成字符串； byte b[]={…w?,?o?,?r?,?l?,?d?,?!?}; String s=new String(b); System.out.println(s); 结果为：world! 4) public String (byte [] value, 开始位置，新字符串长度);将指定位置长度的字节数组转成字符串； byte b[]={…w?,?o?,?r?,?l?,?d?,?!?}; String s=new String(b,2,3); System.out.println(s); 结果为：rl 5)public char[] toCharArray();将字符数组转成字符串 String s=”Hello”; Char c[]=s.toCharArray(); for (int i=0;i 仲恺农业工程学院实验报告纸 计算科学与工程（院、系）网络工程专业083 班组Java语言程序设计课学号200810224311 姓名李志冬实验日期2010/11/19 教师评定 实验五：Java语言中的常用类 一、实验目的 1、掌握Java语言中的常用类。 2、学习用Java语言中的常用类编写程序。 二、实验要求 1、字符串调用public String toUpperCase()方法返回一个字符串，该字符串把当前字符串中的小写字母变成大写字母；字符串调用public String toUpperCase()方法返回一个字符串，该字符串把当前字符串的大写字母变成小写字母。String 类的String toUpperCase()方法返回一个字符串，该字符串是把调用该方法的字符串与参数指定的字符串连接。 2、String类的public charAt（int index）方法可以得到当前字符串index 位置上的一个字符。编写程序使用该方法得到一个字符串中的第一个和最后一个字符。 3、输出某年某月的日历页，通过键盘输入年份和月份。 二、实验程序和结果 1、 public class Stg{ public static void main(String args[]){ String s2=new String("LI ZHI DONG"); String s3=s1.concat(s2); System.out.println("连接后的字符："+s3); char a[]=s3.toCharArray(); for(int n=0;n J A V A中常用类的常用方 法 Newly compiled on November 23, 2020 JAVA中常用类的常用方法 一、类 1、clone()方法 创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现. Cloneable接口。 2、equals(Object obj)方法 功能：比较引用类型数据的等价性。 等价标准：引用类型比较引用，基本类型比较值。 存在特例：对File、String、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 l String类 charAt(int index) 返回指定索引处的 char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 split(String regex) 根据给定正则表达式的匹配拆分此字符串。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的 字符，一直到此字符串末尾。 substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，一直到索引 endIndex - 1 处的字符。javamath类常用方法
JAVA中常用类的常用方法
Java常用类
JAVA中常用类的常用方法
JAVA中常用类的常用方法
java常用词汇
JAVA中常用的类
Java常用类库介绍
java常用类知识点总结
实验5Java常用类(一)
(完整版)Java常用类
java常用类及用法
Java常用类习题
Java中String中类的常用方法
java实验Java语言中的常用类
JAVA中常用类的常用方法