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>