本文主要是介绍黑马程序员-----------------常用类，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
| ------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ---------- |
常用类
常用类 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(){
this.name=”洋洋”
}
}
public class Test{
public static void main(String[] args){
Student st=new Student();
System.out.println(st);
}
}
//子类覆盖toString()
class Student{
Strng name;
Public Student(){
this.name=”洋洋”
}
public String toString(){
retrun “你的姓名:”+this.name;
}
}
public class Test{
public static void main(String[] args){
Student st=new Student();
System.out.println(st); //显示
}
}
6. 类的层级图
A : 继承自Object类的成员+<A类的新成员>
B : 继承自Object类的成员+<A类的新成员>+<B类的新成员>
C : 继承自Object类的成员+<A类的新成员>+<B类的新成员>+<C类的新成员>
D : 继承自Object类的成员+<A类的新成员>+<B类的新成员>+<D类的新成员>
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 isLowerCase(char ch) //返回true,表示ch 为小写字母
static boolean isUpperCase(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. 匹配超链接标记 <a.+href*=*[‘\”]?.*?[‘\”]?.*?>
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 charValue(); 获得包装器内的char 的值:
二．布尔量包装器--- Boolean
构造函数：
Boolean (boolean boolValue ) // boolValue 只能取 true或false
Boolean (String boolString )
操作函数：boolean booleanValue(); 获得包装器内的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 longValue();
//上述函数将当前类型转换为相应的类型
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．操作方法：
2.1. 根据构造函数中的格式将Date对象输出为字符串。
String format(Date d);
例如：
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
2.2.设置解析字符串日期时是否严格检查日期字符串
setLenient(
boolean b);
b=true 接收月份和日的无效数字
b=false 不接收月份和日的无效数字，严格检查
2.3. 根据构造函数中的格式解析字符串日期为
date类型
Date parse(String dateString )throws Exception;
如果dateString不能解析为正确的Date类型，则抛出异常，利用这一
点，可以检查字符串日期的有效性。
四．相关类DateFormat
用于格式化日期，在java.text包中
1． 静态方法
DateFormat getDateTimeInstance(int dateStyle,int timeStyle,Locale alocal)
该方法用于获得一个DateFormat实例.
dateStyle 日期类型，通常取常数DateFormat.LONG
timeStyle 时间类型，通常取常数DateFormat.LONG
alocal 地区常数 ，通常取常数Locale.CHINA(中国), Locale.US(美国)
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，MILLISECOND 分别表示时分秒和毫秒，
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
类
类类
类
static System. arraycopy(Object[] src,int srcPos,Object dest,int destPos,int length)
从源对象数组src的srcPos位置开始取长度为length个元素拷贝到目标数组中
dest 中，并从destPost位置开始存放。
static System.currentTimeMillis(); 获得当前时间的毫秒数
static System.out.print(Object obj); 输出任意对象的字符串表示
static System.out.println(Object obj); 输出任意对象的字符串表示,并换行。
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<maxNumberOfTimesToRun){
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);//启动时钟
}
}
这篇关于黑马程序员-----------------常用类的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
