(完整版)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/683608919.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/683608919.html,=”洋洋”
}
public String toString(){
retrun “你的姓名:”+https://www.360docs.net/doc/683608919.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．操作方法：
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(中国), https://www.360docs.net/doc/683608919.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，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运行
2.1.获得一个Timer实例
2.2.获得TimerTask实例
2.3.调用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);//启动时钟} } Java集合类 Java集合类 (1) 1.Map (3) 1.1.HashMap (3) 1.1.1.底层实现 (3) 1.1.2.特点 (3) 1.1.3.源码分析 (4) 1.1.4.多线程可能出现的问题 (5) 1.2.ConcurrentHashMap (6) 1.2.1.底层实现 (6) 1.2.2.源码分析 (7) 1.3.HashTable (9) 1.3.1.HashTable是线程安全的，因为所有方法上都加了synchronized关键 字。9 1.3.2.HashTable的key和value都不可以为null。 (9) 1.3.3.扩容时，capacity=2*capacity+1 (9) 1.3.4.数组默认大小为11 (9) 1.3.5.查找下标时，没有使用hash&length-1，而是直接进行计算的 (9) 1.4.TreeMap (9) 1.4.1.底层实现为红黑树 (9) 1.4. 2.TreeMap是一个有序的key-value集合，基于红黑树实现。该映射根据 其键的自然顺序进行排序，或者根据创建时提供的Comparator进行排序 (10) 1.4.3.接口实现 (10) 1.4.4.Entry (11) 1.5.LinkedHashMap (11) 1.5.1.底层是数组+链表+红黑树+双向链表 (11) 1.5.2.维护链表顺序和访问顺序 (11) 1.5.3.LinkedHashMap 可以通过构造参数 accessOrder 来指定双向链表是否在 元素被访问后改变其在双向链表中的位置。 (11) 1.5.4.当accessOrder为true时，get方法和put方法都会调用recordAccess 方法使得最近使用的Entry移到双向链表的末尾；当accessOrder为默认值 false时，recordAccess方法什么也不会做。 (11) 1.5.5.LRU实现 (11) 2.Collection (11) 2.1.List (12) 2.1.1.ArrayList (12) 2.1.2.LinkedList (13) 2.1.3.CopyOnWriteArrayList (13) 2.2.Set (14) 2.2.1.HashSet (14) 例如求平方根的(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常用的高级数据类型——集合类型 一、JAVA语言中的集合类型主要有三种形式：Set（集）、List（列表）、Map（映射），每种类型的集合都包括三部分：接口、实现和算法。 a)集合接口实现集合的操作和集合的具体功能实现细节的相互分离—— Set接口、List接口、Map接口 b)集合的具体功能实现类实质上是各种可重用的数据结构的具体表示 List接口的实现类有ArrayList、LinkedList、Stack和Vector等 集合类，Vector 类提供了实现可增长数组的功能，随着更多元素加 入其中，数组变的更大。在删除一些元素之后，数组变小。 Set接口的实现类有HashSet、LinkedHashSet和TreeSet等集合类 Map接口的实现类有HashMap、Hashtable、LinkedHashMap、Properties和TreeMap等集合类。 c)集合的算法指可以对实现集合接口的各个集合的功能实现类提供如排 序、查找、交换和置换等方面的功能实现。 二、List接口 1.List接口代表有序的集合，可以对List接口代表的有序集合中每个元素 的插入位置进行精确地控制，并利用元素的整数索引（代表元素在集合中的位置）访问元素中的各个成员，List接口代表的集合是允许出现重复元素的。 2.List接口主要成员方法： 1）void add（int index,E element）在列表指定位置插入指定元素 2）E get(int index) 返回结合中指定位置的元素 3）E remove(int index) 移除集合中指定位置的元素 4）E set(int index,E elment) 用指定元素替换集合中指定位置的元素 5）boolean add(E o) 向列表的尾部追加指定的元素 6）boolean contains(Object o) 如果列表包含指定的元素，则返回true。 7）boolean isEmpty() 如果列表不包含元素，则返回 true。 8）int size() 返回列表中的元素数 9）Iterator iterator()返回以正确顺序在列表的元素上进行迭代的迭代器。 3.List的实现类 List在数据结构中分别表现为数组（ArrayList）、向量（Vector）、链表（LinkedList）、堆栈（Stack）和队列等形式。 Vector集合和ArrayList集合都是采用数组形式来保存对象，区别在于ArrayList集合本身不具有线程同步的特性，不能用在多线程的环境下，可以使用ArrayList集合能够节省由于同步而产生的系统性能的开销。而Vector集合实现了对线程同步的支持，因此在多线程并发访问的应用环境下，该集合本身能够保证自身具有线程安全性。在多线程的并发访问中，可以将Vector集合的对象实例设计为类中的成员属性，而应该将ArrayList 集合的对象实例设计为局部对象。 public class UserInfo{ List oneVector=new Vector(); public void execute(){ 常用类 （1）字符串相关类（String，StringBuffer） 1）https://www.360docs.net/doc/683608919.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/683608919.html,ng.Enum类型； 1.本讲内容：集合collection （数组和集合90%功能相似，但是最大的区别是，数组在初始化的时候必须确定大小，而集合不用，而且集合是一堆的类，使用起来非常方便。） 讲集合collection之前，我们先分清三个概念： 1colection 集合，可用来存储任何对象的一种数据结构（容器）。 2Collection 集合接口，指的是，是Set、List 和Queue 接口的超类接口 3Collections 集合工具类，指的是类。 SCJP考试要求了解的接口有：Collection , Set , SortedSet , List , Map , SortedMap , Queue , NavigableSet , NavigableMap, 还有一个Iterator 接口也是必须了解的。 SCJP考试要求了解的类有：HashMap , Hashtable ,TreeMap , LinkedHashMap , HashSet , LinkedHashSet ,TreeSet , ArrayList , Vector , LinkedList , PriorityQueuee , Collections , Arrays 下面给出一个集合之间的关系图： 上图中加粗线的ArrayList 和HashMap 是我们重点讲解的对象。下面这张图看起来层级结构更清晰些。 我们这里说的集合指的是小写的collection，集合有4种基本形式，其中前三种的父接口是Collection。 4List 关注事物的索引列表 5Set 关注事物的唯一性 6Queue 关注事物被处理时的顺序 7Map 关注事物的映射和键值的唯一性 一、Collection 接口 Collection接口是Set 、List 和Queue 接口的父接口，提供了多数集合常用的方法声明，包括add()、remove()、contains() 、size() 、iterator() 等。 add(E e) 将指定对象添加到集合中 remove(Object o) 将指定的对象从集合中移除，移除成功返回true,不成功返回false contains(Object o) 查看该集合中是否包含指定的对象，包含返回true,不包含返回flase size() 返回集合中存放的对象的个数。返回值为int clear() 移除该集合中的所有对象，清空该集合。 iterator() 返回一个包含所有对象的iterator对象，用来循环遍历 toArray() 返回一个包含所有对象的数组,类型是Object toArray(T[] t) 返回一个包含所有对象的指定类型的数组 我们在这里只举一个把集合转成数组的例子，因为Collection本身是个接口所以，我们用它的实现类ArrayList做这个例子：例子1： package edu.xjfu; 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) Java中的集合类 (Collection framework)我们在前面学习过java数组，java数组的程度是固定的，在同一个数组中只能存放相同的类型数据。数组可以存放基本类型的数据，也可以存入对象引用的数据。 在创建数组时，必须明确指定数组的长度，数组一旦创建，其长度就不能改变，在许多应用的场合，一组数据的数目不是固定的，比如一个单位的员工数目是变化的，有老的员工跳槽，也有新的员工进来。 为了使程序方便地存储和操纵数目不固定的一组数据，JDK中提供了java集合类，所有java集合类都位于java.util包中，与java数组不同，java集合类不能存放基本数据类型数据，而只能存放对象的引用。 Java集合类分为三种 Set(集合)：集合中对象不按特定的方式排序。并且没有重复对象，但它有些实现类中的对象按特定方式排序。--无序，不能重复 List（列表）：集合中的对象按照检索位置排序，可以有重复对象，允许按照对象在集中的索引位置检索对象，List和数组有些相似。--有序，可以重复 Map（映射）：集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复，它的有些实现类能对集合中的键对象进行排序。 Java的主要集合类的框架图 Collection和Iterator接口 在Collection接口中声明了适用于java集合（只包括Set和List）通用方法。 Collection接口的方法 方法描述 boolean add(Object o) 向集合中加入一个对象的引用 void clear( ) 删除集合中所有对象，即不再对持有对象的引用boolean contains(Object o) 判断在集合中是否含有特定对象的引用 boolean isEmpty() 判断集合是否为空 Iterator iterator( ) 返回一个Iterator对象，可用它来遍历集合中的元素boolean remove(Object o) 从集合中删除一个对象的引用 int size( ) 返回集合中元素的数目 Object [ ] toArray() 返回一个数组，该数组包含集合中的所有元素 Set接口和List即可都继承了Collection接口，而Map接口没有继承Collection接口，因此可以对Set对象和List对象调用以上方法，但是不能对Map对象调用以上方法。Collection接口的iterator()和toArray()方法多用于获得集合中的所有元素，前者返回一个Iterator对象，后者返回一个包含集合中所有元素的数组。 Iterator隐藏底层集合的数据结构，向客户程序提供了遍历各种类型的集合的统一接口。Iterator接口中声明了如下方法： ●hasNext()：判断集合中的元素是否遍历完毕，如果没有，就返回true。 ●next()：返回下一个元素 ●remove()：从集合中删除上一个由next()方法返回的元素。 注意：如果集合中的元素没有排序，Iterator遍历集合中元素的顺序是任意的，并不一定与像集合中加入的元素的顺序一致。 Set（集） Set是最简单的一种集合，集合中的对象不按特定方式排序，并没有重复对象。Set接口主要有两个实现类：HashSet类还有一个子类LinkedHashSet类，它不仅实现了哈希算法，而且实现了链表数据结构，链表数据结构能提高插入核算出元素的性能。TreeSet类实现了SortedSet接口中，具有排序功能。 List(列表) List的主要特征使其元素已先行方式存储，集合中允许存放重复对象。List接口主要的实现类包括： ●ArrayList—ArrayList代表长度可变的数组。允许对元素进行快速的随机访问，但是向 ArrayList中插入与删除元素的速度较慢。 ●LinkedList—在实现中采用链表数据结构。对顺序访问进行了优化，向List中插入和 删除元素的速度较快，随机访问速度则相对较慢，随机访问是指检索位于特定索引位置元素。 Map（映射） Map（映射）是一种吧键对和值对象进行映射的集合。它的每一个元素都包含一对键对象和值对象，而之对象仍可以是Map类型。以此类推，这样就形成了多级映射。向Map集合中加入元素时，必须提供一对键对象和值对象，从Map集合上检索元素只要给出键对象，就会返回值对象。 实例1 CollectionAll.java JAVA屮常用类的常用方法 一．java?丨ang.Object 类 1、clone()方法 创建丼返M此对象的一个副木。要进行“克隆”的对象所属的类必须实现https://www.360docs.net/doc/683608919.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()将此字符串转换为一个新的字符数组。 帮助 | 留言交? | 登录 首页我的图书馆主题阅读精彩目录精品文苑Tags 会员浏览好书推荐 以文找文 如何对文章标记，添加批注？ Java 中集合?用法总结（转载） wade0564 收录于2010-07-08 阅读数：查看 收藏数：7 公众公开 原文来源 tags ： java 集合类 欢迎浏览 wade0564 个人图书馆中收藏的文章，想收藏这篇好文章吗，赶快 吧，1分钟拥有自己的个人图书馆！ 我也要收藏 举报 Java 中集合?用法总结 收藏 Collection ├List │├LinkedList │├ArrayList （异步，线程不安全，空间用完时自动增长原容量一半）│└Vector （同 步，线程安全，空间用完时自动增长原容量一倍）│ └Stack └Set ├HashSet └TreeSet Map ├Hashtable ├HashMap ├WeakHashMap └TreeMap Map 接口： | + -- WeakHashMap: 以弱键 实现的基于哈希表的 Map 。在 WeakHashMap 中，当某个键不再正常使用时，将自动移除其条 | 目。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃，这就使该键成为 可终止的，被终 | 止，然后被回收。丢弃某个键时， 其条目从映射中有效地移除，因此，该类的行为与其他的 Map 实现有所不同。此实现 | 不是同步的。 | + -- TreeMap:该映射根据其键的自然顺序进行 排序，或?根据创建映射时提供的 Comparator 进行 排序，具体取决于使用的 | 构造方法。此实现不是同步的。 | + -- HashMap:基于哈希表的 Map 接?的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了 | 非同步和允许 使用 null 之外，HashMap 类与 Hashtable ?致相同。）此类不保证映射的顺序，特别是它不保证该顺 | 序恒久不变。此实现不是同步的。 | +-- SortedMap: 进一步提供关于键的总体排序 的 Map 。该映射是根据其键的自然顺序进 行排序的，或?根据通常在创建有 序映射时提供的 Comparator 进行排序。对有序映射的 collection 视图（由 entrySet 、keySet 和 values 方法返回 ）进行迭代时，此顺序就会反映 出来。要采用此排序方式，还需要提供一些其他操作（此接?是 SortedSet 的对应映 射）。 Collection 接口： | 热点推荐 中国经典汤品——广东汤常用多音字汇总 如果你失恋。。。这些话...影响世界的100个管理定律汽车发动机?作过程和原理分析温家宝总理答中外记?问女人味，有多少男人可以读懂？珍稀的白头叶猴（组图）三鹿门事件之——中国，...国家公务员职务与级别当代古筝四美 付娜《渔...生活?秘方 真的很实用...哲理?品：守护梦想聚会时可以玩的?游戏依赖型人格障碍的表现和治疗经典妙语，十分精彩江边施救[贴图]李一男2003年在港湾...电脑速度慢的解决方法 ...重装系统后必须做的10件?事 JAVA中常用类的常用方法 一、https://www.360docs.net/doc/683608919.html,ng.Object类 1、clone()方法 创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现https://www.360docs.net/doc/683608919.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 处开 1. 填空 Collection 接口的特点是元素是___无序可重复______； List 接口的特点是元素__有__（有|无）顺序，_可以___（可以|不可以）重复； Set 接口的特点是元素__无___（有|无）顺序，____不可以__（可以|不可以）重复；Map 接口的特点是元素是__key、value映射______，其中__value__可以重复，_key___不可以重复。 2. （List）有如下代码 import java.util.*; public class TestList{ public static void main(String args[]){ List list = new ArrayList(); list.add(“Hello”); list.add(“World”); list.add(1, “Learn”); list.add(1, “Java”); printList(list); } public static void printList(List list){ //1 for(int i = 0; i< list.size();i++){ System.out.println(list.get(i)); } for(Object o : list) { System.out.println(o); } Iterator itor = list.iterator(); while(itor.hasNext()){ System.out.println(itor.next()); } } } 要求： 1) 把//1 处的代码补充完整，要求输出list 中所有元素的内容 2) 写出程序执行的结果Hello Java Learn World 3) 如果要把实现类由ArrayList 换为LinkedList，应该改哪里？ArrayList 和LinkedList 使用上有什么区别？实现上有什么区别？ 4) 如果要把实现类由ArrayList 换为Vector，应该改哪里？ArrayList 和Vector 使 用上有什么区别？实现上有什么区别？ 3. （List）写出下面程序的运行结果 Java集合体系结构分析与比较 1. Java集合框架图 Java平台提供了一个全新的集合框架.“集合框架”主要由一组用来操作对象的接口组成.不同接口描述一组不同数据类型. Java集合框架图如下: 集合接口:6个接口(短虚线表示),表示不同集合类型,是集合框架的基础. 抽象类:5个抽象类(长虚线表示),对集合接口的部分实现.可扩展为自定义集合类. 实现类:8个实现类(实线表示),对接口的具体实现. 在很大程度上,一旦您理解了接口,您就理解了框架.虽然您总要创建接口特定的实现,但访问实际集合的方法应该限制在接口方法的使用上;因此,允许您更改基本的数据结构而不必改变其它代码. Java集合的顶层接口是Collection,Collection 接口是一组允许重复的对象.Java集合框架主要由以下三个接口组成: (1) Set 接口继承Collection,但不允许重复,使用自己内部的一个排列机制. (2) List 接口继承Collection,允许重复,以元素安插的次序来放置元素,不会重新排列. (3) Map接口是一组成对的键-值对象,即所持有的是 key-value pairs.Map中不能有重复的key,拥有自己的内部排列机制. 容器中的元素类型都为Object,从容器取得元素时,必须把它转换成原来的类型.简化后的集合框架图如下: 2. 接口Collection 用于表示任何对象或元素组,想要尽可能以常规方式处理一组元素时,就使用这一接口. (1) 单元素添加、删除操作: boolean add(Object o):将对象添加给集合 boolean remove(Object o): 如果集合中有与o相匹配的对象,则删除对象o (2) 查询操作: int size():返回当前集合中元素的数量 boolean isEmpty():判断集合中是否有任何元素 boolean contains(Object o):查找集合中是否含有对象o Iterator iterator():返回一个迭代器,用来访问集合中的各个元素 (3) 组操作:作用于元素组或整个集合 boolean containsAll(Collection c): 查找集合中是否含有集合c 中所有元素 boolean addAll(Collection c) : 将集合c 中所有元素添 教学内容 第七讲Java常用类库介绍 7.1 Java类库的结构 类库就是Java API(Application Programming Interface，应用程序接口)，是系统提供的已实现的标准类的集合。在程序设计中，合理和充分利用类库提供的类和接口，不仅可以完成字符串处理、绘图、网络应用、数学计算等多方面的工作，而且可以大大提高编程效率，使程序简练、易懂。 Java类库中的类和接口大多封装在特定的包里，每个包具有自己的功能。表7．1列出了Java中一些常用的包及其简要的功能。其中，包名后面带“. *”的表示其中包括一些相关的包。有关类的介绍和使用方法，Java中提供了极其完善的技术文档。我们只需了解技术文档的格式就能方便地查阅文档。 表7．1Java提供的部分常用包 注：在使用Java时，除了https://www.360docs.net/doc/683608919.html,ng外，其他的包都需要import语句引入之后才能使用。 7.2 https://www.360docs.net/doc/683608919.html,ng包中的常用类 https://www.360docs.net/doc/683608919.html,ng是Java语言最广泛使用的包。它所包括的类是其他包的基础，由系统自动引入，程序中不必用import语句就可以使用其中的任何一个类。https://www.360docs.net/doc/683608919.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、综述 所有集合类都位于java.util包下。集合中只能保存对象（保存对象的引用变量）。（数组既可以保存基本类型的数据也可以保存对象）。 当我们把一个对象放入集合中后，系统会把所有集合元素都当成Object类的实例进行处理。从JDK1.5以后，这种状态得到了改进：可以使用泛型来限制集合里元素的类型，并让集合记住所有集合元素的类型（参见具体泛型的内容）。 Java的集合类主要由两个接口派生而出：Collection和Map，Col lection和Map是Java集合框架的根接口，这两个接口又包含了一些接口或实现类。 Set和List接口是Collection接口派生的两个子接口，Queue是Java提供的队列实现，类似于List。 Map实现类用于保存具有映射关系的数据（key-value）。 Set、List和Map可以看做集合的三大类。 List集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。 Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是不能集合里元素不允许重复的原因）。 Map集合中保存Key-value对形式的元素，访问时只能根据每项元素的k ey来访问其value。 对于Set、List和Map三种集合，最常用的实现类分别是HashSet、ArrayLi st和HashMap三个实现类。（并发控制的集合类，以后有空研究下）。2、Collection接口 Collection接口是List、Set和Queue接口的父接口，同时可以操作这三个接口。Collection接口定义操作集合元素的具体方法大家可以参考API文档，这里通过一个例子来说明Collection的添加元素、删除元素、返回集合中元素的个数以及清空集合元素的方法。 public class TestCollection { Java集合框架之List详解 ArrayList 首先我们熟悉下ArrayList类中常用方法的使用。 1）添加：public boolean add（Object e)：将指定的元素（对象）添加到此列表的尾部 2）获取：public Object get(int index)：返回此列表中指定位置（索引）上的元素。 3）元素的个数：public int size()：返回此列表中的元素数。 4）清空：public void clear()：移除此列表中的所有元素。此调用返回后，列表将为空。 5）是否为空：public boolean isEmpty()：如果此列表中没有元素，则返回 true 6）移除（删除）：public E remove(int index)：移除此列表中指定位置上的元素。向左移动所有后续元素（将其索引减 1）。 7）移除（重载）：public boolean remove(Object o)：移除此列表中首次出现的指定元素（如果存在）。如果列表不包含此元素，则列表不做改动。更确切地讲，移除满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引的元素（如果存在此类元素）。如果列表中包含指定的元素，则返回 true （或者等同于这种情况：如果列表由于调用而发生更改，则返回 true）。8）获得索引：public int indexOf(Object o): 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。更确切地讲，返回满足(o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i ，如果不存在此类索引，则返回 -1。 如何使用这些方法，代码如下： import java.util.ArrayList; public class ArrayListTest { public static void main(String[] args) { ArrayList list=new ArrayList(); /* * 添加 */ list.add("hello"); list.add(" world"); list. add(" welcome"); /* * 获得 */ String s1=(String)list.get(0); 实验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()); } }Java集合类知识点总结
javamath类常用方法
JAVA中常用的集合类型
Java常用类
java集合类总结
JAVA中常用类的常用方法
Java中的集合类
JAVA中常用类的常用方法
Java中集合类用法总结
JAVA中常用类的常用方法
java集合-练习题解析
Java集合体系结构分析与比较
Java常用类库介绍
Java集合框架的知识总结
Java类集合之List详解
实验5Java常用类(一)