- 技术人生
- java容器类
Collection
├
List
│├
LinkedList
│├
ArrayList
│└
Vector
│ └
Stack
└
Set
Map
├
Hashtable(
同步
)
├
HashMap
└
WeakHashMap
//*******************************************************
ArrayList, HashMap,Vector,Stack support null
Hashtable not support null
//***********************************************
一些
Collection
允许相同的元素而另一些不行。
list(
允许相同的元素
):LinkedList
，
ArrayList
，
Vector
和
Stack
map(
允许相同的元素
)
set(
不允许相同的元素
)
一些能排序而另一些不行。
一般采取
Collection.sort(list)
Collection.sort(list,comparable)
来排序
也可以让某个类
implaments comparable
Java SDK
不提供直接继承自
Collection
的类，
Java SDK
提供的类都是继承自
Collection
的“子接口”如
List
和
Set
。
所有实现
Collection
接口的类都必须提供两个标准的构造函数：
无参数的构造函数用于创建一个空的
Collection
，
有一个
Collection
参数的构造函数用于创建一个新的
Collection
，
这个新的
Collection
与传入的
Collection
有相同的元素。
后一个构造函数允许用户复制一个
Collection
。
arraylist--Vector
1,
同步
2,
增加的幅度
3,
进行平移的时间
Hashtable--Hashmap
1,
同步
2,Enumeration;
迭代
3,null
Java.util.Vector
提供了向量
(Vector)
类以实现类似动态数组的功能。在
Java
语言中。正如在一开始就提到过，是没有指针概念的，但如果能正确灵活地使用指针又确实可以大大提高程序的质量，比如在
C
、
C++
中所谓“动态数组”一般都由指针来实现。为了弥补这点缺陷，
Java
提供了丰富的类库来方便编程者使用，
Vector
类便是其中之一。事实上，灵活使用数组也可完成向量类的功能，但向量类中提供的大量方法大大方便了用户的使用。
创建了一个向量类的对象后，可以往其中随意地插入不同的类的对象，既不需顾及类型也不需预先选定向量的容量，并可方便地进行查找。对于预先不知或不愿预先定义数组大小，并需频繁进行查找、插入和删除工作的情况，可以考虑使用向量类。
向量类提供了三种构造方法：
public vector()
public vector(int initialcapacity,int capacityIncrement)
public vector(int initialcapacity)
使用第一种方法，系统会自动对向量对象进行管理。若使用后两种方法，则系统将根据参数
initialcapacity
设定向量对象的容量
(
即向量对象可存储数据的大小
)
，当真正存放的数据个数超过容量时，系统会扩充向量对象的存储容量。参数
capacityIncrement
给定了每次扩充的扩充值。当
capacityIncrement
为
0
时，则每次扩充一倍。利用这个功能可以优化存储。
在
Vector
类中提供了各种方法方便用户使用：
■插入功能
(1)public final synchronized void addElement(Object obj)
将
obj
插入向量的尾部。
obj
可以是任何类的对象。对同一个向量对象，可在其中插入不同类的对象。但插入的应是对象而不是数值，所以插入数值时要注意将数值转换成相应的对象。
例
要插入一个整数
1
时，不要直接调用
v1.addElement(1)
，正确的方法为：
Vector v1=new Vector();
Integer integer1=new Integer(1);
v1.addElement(integer1);
(2)public final synchronized void setElementAt(object obj,int index)
将
index
处的对象设成
obj
，原来的对象将被覆盖。
(3)public final synchronized void insertElementAt(Object obj,int index)
在
index
指定的位置插入
obj
，原来对象以及此后的对象依次往后顺延。
■删除功能
(1)public final synchronized void removeElement(Object obj)
从向量中删除
obj
。若有多个存在，则从向量头开始试，删除找到的第一个与
obj
相同的向量成员。
(2)public final synchronized void removeAllElement()
删除向量中所有的对象。
(3)public final synchronized void removeElementlAt(int index)
删除
index
所指的地方的对象。
■查询搜索功能
(1)public final int indexOf(Object obj)
从向量头开始搜索
obj ,
返回所遇到的第一个
obj
对应的下标，若不存在此
obj
，返回
-1
。
(2)public final synchronized int indexOf(Object obj,int index)
从
index
所表示的下标处开始搜索
obj
。
(3)public final int lastIndexOf(Object obj)
从向量尾部开始逆向搜索
obj
。
(4)public final synchronized int lastIndexOf(Object obj,int index)
从
index
所表示的下标处由尾至头逆向搜索
obj
。
(5)public final synchronized Object firstElement()
获取向量对象中的首个
obj
。
(6)public final synchronized Object lastelement()
获取向量对象中的最后一个
obj
。
了解了向量的最基本的方法后，我们来看一下例
8.3VectorApp.java
。
例
1.3 VectorApp.java
。
import java.util.Vector;
import java.lang.*;//
这一句不应该要，但原文如此
import java.util.Enumeration;
public class VectorApp{
public static void main(String[] args){
Vector v1=new Vector();
Integer integer1=new Integer(1);
v1.addElement("one");
//
加入的为字符串对象
v1.addElement(integer1);
v1.addElement(integer1);
//
加入的为
Integer
的对象
v1.addElement("two");
v1.addElement(new Integer(2));
v1.addElement(integer1);
v1.addElement(integer1);
System.out.println("The vector v1 is:/n/t"+v1);
//
将
v1
转换成字符串并打印
v1.insertElementAt("three",2);
v1.insertElementAt(new Float(3.9),3);
System.out.println("The vector v1(used method insertElementAt()) is:/n/t "+v1);
//
往指定位置插入新的对象，指定位置后的对象依次往后顺延
v1.setElementAt("four",2);
System.out.println("The vector v1(used method setElementAt()) is:/n/t "+v1);
//
将指定位置的对象设置为新的对象
v1.removeElement(integer1);
//
从向量对象
v1
中删除对象
integer1
由于存在多个
integer1
所以从头开始
//
找，删除找到的第一个
integer1
Enumeration enum=v1.elements();
System.out.print("The vector v1(used method removeElement())is:");
while(enum.hasMoreElements())
System.out.print(enum.nextElement()+" ");
System.out.println();
//
使用枚举类
(Enumeration)
的方法来获取向量对象的每个元素
System.out.println("The position of object 1(top-to-bottom):"
+ v1.indexOf(integer1));
System.out.println("The position of object 1(tottom-to-top):"
+v1.lastIndexOf(integer1));
//
按不同的方向查找对象
integer1
所处的位置
v1.setSize(4);
System.out.println("The new vector(resized the vector)is:"+v1);
//
重新设置
v1
的大小，多余的元素被行弃
}
}
运行结果：
E:/java01>java VectorApp
The vector v1 is:
[one, 1, 1, two, 2, 1, 1]
The vector v1(used method insertElementAt()) is:
[one, 1, three, 3.9, 1, two, 2, 1, 1]
The vector v1(used method setElementAt()) is:
[one, 1, four, 3.9, 1, two, 2, 1, 1]
The vector v1(used method removeElement())is:one four 3.9 1 two 2 1 1
The position of object 1(top-to-bottom):3
The position of object 1(tottom-to-top):7
The new vector(resized the vector)is:[one, four, 3.9, 1]
E:/java01>
从例
1.3
运行的结果中可以清楚地了解上面各种方法的作用，另外还有几点需解释。
(1)
类
Vector
定义了方法
public final int size()
此方法用于获取向量元素的个数。它的返回值是向是中实际存在的元素个数，而非向量容量。可以调用方法
capactly()
来获取容量值。
方法：
public final synchronized void setsize(int newsize)
此方法用来定义向量大小。若向量对象现有成员个数已超过了
newsize
的值，则超过部分的多余元素会丢失。
(2)
程序中定义了
Enumeration
类的一个对象
Enumeration
是
java.util
中的一个接口类，在
Enumeration
中封装了有关枚举数据集合的方法。
在
Enumeration
中提供了方法
hawMoreElement()
来判断集合中是束还有其它元素和方法
nextElement()
来获取下一个元素。利用这两个方法可以依次获得集合中元素。
Vector
中提供方法：
public final synchronized Enumeration elements()
此方法将向量对象对应到一个枚举类型。
java.util
包中的其它类中也大都有这类方法，以便于用户获取对应的枚举类型。
栈类
Stack
Stack
类是
Vector
类的子类。它向用户提供了堆栈这种高级的数据结构。栈的基本特性就是先进后出。即先放入栈中的元素将后被推出。
Stack
类中提供了相应方法完成栈的有关操作。
基本方法：
public Object push(Object Hem)
将
Hem
压入栈中，
Hem
可以是任何类的对象。
public Object pop()
弹出一个对象。
public Object peek()
返回栈顶元素，但不弹出此元素。
public int search(Object obj)
搜索对象
obj,
返回它所处的位置。
public boolean empty()
判别栈是否为空。
例
1.4 StackApp.java
使用了上面的各种方法。
例
1.4 StackApp.java
。
import java.lang.*;
import java.util.*;
public class StackApp{
public static void main(String args[]){
Stack sta=new Stack();
sta.push("Apple");
sta.push("banana");
sta.push("Cherry");
//
压入的为字符串对象
sta.push(new Integer(2));
//
压入的为
Integer
的对象，值为
2
sta.push(new Float(3.5));
//
压入的为
Float
的对象，值为
3.5
System.out.println("The stack is,"+sta);
//
对应栈
sta
System.out.println("The top of stack is:"+sta.peek());
//
对应栈顶元素，但不将此元素弹出
System.out.println("The position of object Cherry is:"
+sta.search("cherry"));
//
打印对象
Cherry
所处的位置
System.out.print("Pop the element of the stack:");
while(!sta.empty())
System.out.print(sta.pop()+" ");
System.out.println();
//
将栈中的元素依次弹出并打印。与第一次打印的
sta
的结果比较，可看出栈
//
先进后出的特点
}
}
运行结果
(
略
)1.7
哈希表类
Hashtable
哈希表是一种重要的存储方式，也是一种常见的检索方法。其基本思想是将关系码的值作为自变量，通过一定的函数关系计算出对应的函数值，把这个数值解释为结点的存储地址，将结点存入计算得到存储地址所对应的存储单元。检索时采用检索关键码的方法。现在哈希表有一套完整的算法来进行插入、删除和解决冲突。在
Java
中哈希表用于存储对象，实现快速检索。
Java.util.Hashtable
提供了种方法让用户使用哈希表，而不需要考虑其哈希表真正如何工作。
哈希表类中提供了三种构造方法，分别是：
public Hashtable()
public Hashtable(int initialcapacity)
public Hashtable(int initialCapacity,float loadFactor)
参数
initialCapacity
是
Hashtable
的初始容量，它的值应大于
0
。
loadFactor
又称装载因子，是一个
0.0
到
0.1
之间的
float
型的浮点数。它是一个百分比，表明了哈希表何时需要扩充，例如，有一哈希表，容量为
100
，而装载因子为
0.9
，那么当哈希表
90%
的容量已被使用时，此哈希表会自动扩充成一个更大的哈希表。如果用户不赋这些参数，系统会自动进行处理，而不需要用户操心。
Hashtable
提供了基本的插入、检索等方法。
■插入
public synchronized void put(Object key,Object value)
给对象
value
设定一关键字
key,
并将其加到
Hashtable
中。若此关键字已经存在，则将此关键字对应的旧对象更新为新的对象
Value
。这表明在哈希表中相同的关键字不可能对应不同的对象
(
从哈希表的基本思想来看，这也是显而易见的
)
。
■检索
public synchronized Object get(Object key)
根据给定关键字
key
获取相对应的对象。
public synchronized boolean containsKey(Object key)
判断哈希表中是否包含关键字
key
。
public synchronized boolean contains(Object value)
判断
value
是否是哈希表中的一个元素。
■删除
public synchronized object remove(object key)
从哈希表中删除关键字
key
所对应的对象。
public synchronized void clear()
清除哈希表
另外，
Hashtalbe
还提供方法获取相对应的枚举集合：
public synchronized Enumeration keys()
返回关键字对应的枚举对象。
public synchronized Enumeration elements()
返回元素对应的枚举对象。
例
1.5 Hashtable.java
给出了使用
Hashtable
的例子。
例
1.5 Hashtalbe.java
。
//import java.lang.*;
import java.util.Hashtable;
import java.util.Enumeration;
public class HashApp{
public static void main(String args[]){
Hashtable hash=new Hashtable(2,(float)0.8);
//
创建了一个哈希表的对象
hash
，初始容量为
2
，装载因子为
0.8
hash.put("Jiangsu","Nanjing");
//
将字符串对象“
Jiangsu
”给定一关键字“
Nanjing
”
,
并将它加入
hash
hash.put("Beijing","Beijing");
hash.put("Zhejiang","Hangzhou");
System.out.println("The hashtable hash1 is: "+hash);
System.out.println("The size of this hash table is "+hash.size());
//
打印
hash
的内容和大小
Enumeration enum1=hash.elements();
System.out.print("The element of hash is: ");
while(enum1.hasMoreElements())
System.out.print(enum1.nextElement()+" ");
System.out.println();
//
依次打印
hash
中的内容
if(hash.containsKey("Jiangsu"))
System.out.println("The capatial of Jiangsu is "+hash.get("Jiangsu"));
hash.remove("Beijing");
//
删除关键字
Beijing
对应对象
System.out.println("The hashtable hash2 is: "+hash);
System.out.println("The size of this hash table is "+hash.size());
}
}
运行结果：
The hashtable hash1 is: {Beijing=Beijing, Zhejiang=Hangzhou, Jiangsu=Nanjing}
The size of this hash table is 3
The element of hash is: Beijing Hangzhou Nanjing
The capatial of Jiangsu is Nanjing
The hashtable hash2 is: {Zhejiang=Hangzhou, Jiangsu=Nanjing}
The size of this hash table is 2
Hashtable
是
Dictionary(
字典
)
类的子类。在字典类中就把关键字对应到数据值。字典类是一个抽象类。在
java.util
中还有一个类
Properties
，它是
Hashtable
的子类。用它可以进行与对象属性相关的操作。
日期类
Date
Java
在日期类中封装了有关日期和时间的信息，用户可以通过调用相应的方法来获取系统时间或设置日期和时间。
Date
类中有很多方法在
JDK1.0
公布后已经过时了，在
8.3
中我们将介绍
JDK1.0
中新加的用于替代
Date
的功能的其它类。
在日期类中共定义了六种构造函数。
(1)public Date()
创建的日期类对象的日期时间被设置成创建时刻相对应的日期时间。
例
Date today=new Date()
；
//today
被设置成创建时刻相对应的日期时间。
(2)public Date (long date)
long
型的参数
date
可以通过调用
Date
类中的
static
方法
parse(String s)
来获得。
例
long l=Date.parse("Mon 6 Jan 1997 13:3:00");
Date day=new Date(l);
//day
中时间为
1997
年
1
月
6
号星期一，
13:3:00
。
(3)public Date(String s)
按字符串
s
产生一日期对象。
s
的格式与方法
parse
中字符串参数的模式相同。
例
Date day=new Date("Mon 6 Jan 1997 13:3:00");
//day
中时间为
1997
年
1
月
6
号星期一，
13:3:00.
(4)public Date(int year,int month,int date)
(5)public Date(int year,int month,int date,int hrs,int min)
(6)public Date(int year,int month,int date,int hrs,int min,int sec)
按给定的参数创建一日期对象。
参数说明：
year
的值为：需设定的年份
-1900
。例如需设定的年份是
1997
则
year
的值应为
97
，即
1997-1900
的结果。所以
Date
中可设定的年份最小为
1900
；
month
的值域为
0
～
11
，
0
代表
1
月，
11
表代表
12
月；
date
的值域在
1
～
31
之间；
hrs
的值域在
0
～
23
之间。从午夜到次日凌晨
1
点间
hrs=0
，从中午到下午
1
点间
hrs=12
；
min
和
sec
的值域在
0
～
59
之间。
例
Date day=new Date(11,3,4);
//day
中的时间为：
04-Apr-11 12:00:00 AM
另外，还可以给出不正确的参数。
例 设定时间为
1910
年
2
月
30
日，它将被解释成
3
月
2
日。
Date day=new Date(10,1,30,10,12,34);
System.out.println("Day's date is:"+day);
//
打印结果为：
Day's date is:Web Mar 02 10:13:34 GMT+08:00 1910
下面我们给出一些
Date
类中常用方法。
(1)public static long UTC(int year,int month,int date,int hrs. int min,int sec)
该方法将利用给定参数计算
UTC
值。
UTC
是一种计时体制，与
GMT(
格林威治时间
)
的计时体系略有差别。
UTC
计时体系是基于原子时钟的，而
GTMT
计时体系是基于天文学观测的。计算中使用的一般为
GMT
计时体系。
(2)public static long parse(String s)
该方法将字符串
s
转换成一个
long
型的日期。在介绍构造方法
Date(long date)
时曾使用过这个方法。
字符串
s
有一定的格式，一般为：
(
星期
日
年
时间
GMT+
时区
)
若不注明时区，则为本地时区。
(3)public void setMonth(int month)
(4)public int getMonth()
这两个方法分别为设定和获取月份值。
获取的月份的值域为
0
～
11
，
0
代表
1
月，
11
代表
12
月。
(5)public String toString()
(6)public String toLocalString()
(7)public String toGMTString()
将给定日期对象转换成不同格式的字符串。它们对应的具体的格式可参看例子
8.1
。
(8)public int getTimezoneOffset()
该方法用于获取日期对象的时区偏移量。
例
8.1
中对上面介绍的
Date
类中的基本方法进行了具体的应用，并打印了相应的结果。由于使用了一些过时的方法，所以编译时会有警告信息。另外，由于本例中的时间表示与平台有关，不同的
JDK
版本对此处理不完全相同，因此不同版本的
JDK
执行本例的结果可能有细微差异。
例
1.1 DateApp.java
import java.lang.System;
import java.util.Date;
public class DateApp{
public static void main(String args[]){
Date today=new Date();
//today
中的日期被设成创建时刻的日期和时间，假设创建时刻为
1997
年
3
月
//23
日
17
时
51
分
54
秒。
System.out.println("Today's date is "+today);
//
返回一般的时间表示法，本例中结果为
//Today's date is Fri May 23 17:51:54 1997
System.out.println("Today's date(Internet GMT)is:"
+today.toGMTString());
//
返回结果为
GMT
时间表示法，本例中结果为
//Today's date(Internet GMT)is: 23 May 1997 09:51:54:GMT
System.out.println("Today's date(Locale) is:"
+today.toLocaleString());
//
返回结果为本地习惯的时间表示法，结果为
//Today's date(Locale)is:05/23/97 17:51:54
System.out.println("Today's year is: "+today.getYear());
System.out.println("Today's month is: "+(today.getMonth()+1));
System.out.println("Today's date is: "+today.getDate());
//
调用
Date
类中方法，获取年月日的值。
//
下面调用了不同的构造方法来创建
Date
类的对象。
Date day1=new Date(100,1,23,10,12,34);
System.out.println("Day1's date is: "+day1);
Date day2=new Date("Sat 12 Aug 1996 13:3:00");
System.out.println("Day2's date is: "+day2);
long l= Date.parse("Sat 5 Aug 1996 13:3:00 GMT+0800");
Date day3= new Date(l);
System.out.println("Day3's date(GMT)is: "+day3.toGMTString());
System.out.println("Day3's date(Locale)is: "
+day3.toLocaleString());
System.out.println("Day3's time zone offset is:"
+day3.getTimezoneOffset());
}
}
运行结果
(JDK1.3
版，与原文不同，原文是
JDK1.0
版
)
：
E:/java/tutorial/java01>java DateApp
Today's date is Thu Dec 27 17:58:16 CST 2001
Today's date(Internet GMT)is:27 Dec 2001 09:58:16 GMT
Today's date(Locale) is:2001-12-27 17:58:16
Today's year is: 101
Today's month is: 12
Today's date is: 27
Day1's date is: Wed Feb 23 10:12:34 CST 2000
Day2's date is: Fri Aug 12 13:03:00 CST 1996
Day3's date(GMT)is: 5 Aug 1996 05:03:00 GMT
Day3's date(Locale)is: 1996-8-5 13:03:00
Day3's time zone offset is:-480
E:/java/tutorial/java01>
