Framework
集合框架是一個統(tǒng)一的架構(gòu),用來表示和操作集合.
集合框架主要是由接口,抽象類和實現(xiàn)類構(gòu)成.
接口:藍(lán)色；實現(xiàn)類：紅色
Collection
|_____Set(HashSet)
|         |_____SortedSet(TreeSet)
|_____List(LinkedList,ArrayList)

Collection:集合層次中的根接口，JDK沒有提供這個接口的實現(xiàn)類。
Set:不能包含重復(fù)的元素，子接口SortedSet是一個按照升序排列的元素的Set。
List:可以包含重復(fù)的元素，是一個有序的集合，提供了按索引訪問的方式，有次序，位置不改變。

Collection接口常用的方法：

List接口特有方法：

SortedSet接口特有方法：

集合框架中的實現(xiàn)類.

ArrayList:

本質(zhì)：我們可以將其看作是能夠自動增長容量的數(shù)組，實際是采用對象數(shù)組實現(xiàn)的。
自動增長容量就是當(dāng)數(shù)組不夠的時候,再定義更大的數(shù)組，然后將數(shù)組元素拷貝到新的數(shù)組.
例子：import java.util.*;
class ArrayListTest
{
public static void main(String[] args)
{
   ArrayList a1=new ArrayList();
   a1.add("winsun");
   a1.add("weixin");
   a1.add("mybole");

   for(int i=0;i<a1.size();i++)
     {
        System.out.println(a1.get(i));
     }
     System.out.println(a1);
   }
}

結(jié)果：

winsun
weixin
mybole
[winsun, weixin, mybole]

利用ArrayList的toArray()返回一個對象的數(shù)組也可以利用Arrays.asList()方法返回一個列表

返回固定尺寸的列表,當(dāng)返回以后就不能修改列表的大小了，可以修改列表中元素的值，但不能增加容量，可以用set()方法對值進(jìn)行修改：
Object set(int index,Object element)
用element替換指定的index的對象
Arrays.asList()和Collection.toArray()是作為數(shù)組和集合類的一個橋
如果想從集合類中獲得一個數(shù)組可以使用toArray()方法；如果想從數(shù)組中獲得一個列表可以使用asList()方法 ：

import java.util.*;
class Point {
int x, y;
Point(int x, int y) {
   this.x = x;
   this.y = y;
}
public String toString() {
   return "x=" + x + ",y=" + y;
}
}
public class ArrayListToArrayTest {
public static void main(String[] args) {
   ArrayList a1 = new ArrayList();
   a1.add(new Point(3, 3));
   a1.add(new Point(4, 4));
   a1.add(new Point(5, 5));

   for (int i = 0; i < a1.size(); i++) {
    System.out.println(a1.get(i));
   }
   System.out.println(a1);

   Object[] objs = a1.toArray(); // 利用ArrayList的toArray()返回一個對象的數(shù)組.
   for (int i = 0; i < objs.length; i++) {
    System.out.println(objs[i]);
   }
   System.out.println(objs);//
   List l = Arrays.asList(objs);// Arrays.asList()返回一個列表.
   System.out.println(l);

}
}
結(jié)果：

x=3,y=3
x=4,y=4
x=5,y=5
[x=3,y=3, x=4,y=4, x=5,y=5]
x=3,y=3
x=4,y=4
x=5,y=5
[Ljava.lang.Object;@1fc4bec
[x=3,y=3, x=4,y=4, x=5,y=5]

LinkedList類
LinkedList是采用雙向循環(huán)鏈表實現(xiàn)的.
利用LinkedList實現(xiàn)棧(stack)，隊列(queue)，雙向隊列(double-ended queue)

LinkedList常用方法
void addFirst(Object o)
void addLast(Object o)
Object getFirst()
Object getLast()
Object remove(int index)
boolean remove(Object o)
Object removeFirst()
Object removeLast()
判斷是否為空
LinkedList繼承了一個方法isEmpty()
如果沒有包含任何元素返回true,沒有包含任何元素返回false
ArrayList底層采用數(shù)組完成,而LinkedList則是以一般的
雙向鏈表完成,其內(nèi)每個對象除了數(shù)據(jù)本身外，還有兩個引用,
分別指向前一個元素和后一個元素.
如果我們經(jīng)常在List的開始處增加元素,或者在List中進(jìn)行插入
和刪除操作,我們應(yīng)該使用LinkedList,否則的話,使用ArrayList
將更加快速.
因為插入和刪除都要移動數(shù)組中的元素.
只是訪問就用ArrayList,提供了按索引訪問的機制.

HashSet
HashSet實現(xiàn)了Set接口的hash table(哈希表),依靠HashMap來實現(xiàn).
應(yīng)該為要存放到散列表的各個對象定義hashCode()和equals().
因為實現(xiàn)了set接口所以不能有重復(fù)的元素.
散列表:
散列表又稱為哈希表.
散列表算法的基本思想:
以結(jié)點的關(guān)鍵字為自變量,通過一定的函數(shù)關(guān)系(散列函數(shù))
計算出對應(yīng)的函數(shù)值,以這個值作為該結(jié)點存儲在散列表中的地址.
當(dāng)散列表中的元素存放太滿,就必須進(jìn)行再散列,將產(chǎn)生一個新的散列表,
所有元素存放到新的散列表中,原先的散列表將被刪除.
在java語言中,通過負(fù)載因子(load factor)來決定何時對散列表進(jìn)行再
散列.例如:如果負(fù)載因子是0.75,當(dāng)散列表中已經(jīng)有75%的位置已經(jīng)放滿,
那么將進(jìn)行散列.
負(fù)載因子越高(越接近1.0),內(nèi)存的使用率越高,元素的尋找時間越長.
負(fù)載因子越低(越接近0.0),元素的尋找時間越短,內(nèi)存浪費越多.
HashSet類的缺省負(fù)載因子是0.75.

HashSet在java.util包當(dāng)中.
需要導(dǎo)入.
常用方法
boolean add(Object o)
需要使用迭代器
HashSet類實現(xiàn)了Set接口,所以不能有重復(fù)的元素.

要根據(jù)散列碼計算存儲位置.
而散列碼是利用Object類當(dāng)中的HashCode()函數(shù)獲得的.
而HashCode()函數(shù)是通過一個對象的內(nèi)存地址來得到散列碼的.
所以要重寫public int HashCode()方法.
String類實繼承了HashCode()方法.
import java.util.*;
public class HashSetTest {

public static void main(String []args)
{
   HashSet hs=new HashSet();
/* hs.add("one");
   hs.add("two");
   hs.add("three");
   hs.add("one");
   */
   hs.add(new Student(1,"zhangsan"));
   hs.add(new Student(2,"lisi"));
  
   hs.add(new Student(1,"zhangsan"));
   hs.add(new Student(3,"wangwu"));
  
   Iterator it=hs.iterator();
   while(it.hasNext())
   {
    System.out.println(it.next());
   }
}
}
class Student
{
int num;
String name;
Student(int num,String name)
{
   this.name=name;
   this.num=num;
}
public int HashCode()
{
   return num*name.hashCode();
}
public boolean equals(Object o)
{
   Student s=(Student)o;
   return num==s.num && name.equals(s.name);
}
public String toString()
{
   return "name : ="+name;
}
}
需要覆蓋HashCode()和equals()方法
HashSet->HashCode->對象內(nèi)存地址

TreeSet：
TreeSet是依靠TreeMap來實現(xiàn)的.
TreeSet是一個有序集合,TreeSet中元素將按照升序排列,
缺省是按照自然排序進(jìn)行排列,意味著TreeSet中元素要
實現(xiàn)Comparable接口.
我們可以在構(gòu)造TreeSet對象時,傳遞實現(xiàn)了Comparator接口
的比較器對象.
java.util包當(dāng)中TreeSet類
import java.util.*;
public class TreeSetTest {
//如果自定義類對象要加入TreeSet要實現(xiàn)Comparable接口
public static void main(String []args)
{
   TreeSet ts=new TreeSet(new Student.StudentComparator());
/* ts.add("winsun");
   ts.add("weixin");
   ts.add("mybole");
   */
   ts.add(new Student(2,"lisi"));
   ts.add(new Student(1,"wangwu"));
   ts.add(new Student(3,"zhangsan"));
   ts.add(new Student(3,"mybole"));
  
   Iterator it=ts.iterator();
   while(it.hasNext())
   {
    System.out.println(it.next());
   }
}
}
class Student implements Comparable
{
int num;
String name;
static class StudentComparator implements Comparator
{
   public int compare(Object o1,Object o2)
   {
    Student s1=(Student)o1;
    Student s2=(Student)o2;
    int result=s1.num>s2.num ? 1 : (s1.num==s2.num ? 0 : -1);
    if(result==0)
    { //String類實現(xiàn)了compareTo()方法.
     result=s1.name.compareTo(s2.name);
    }
    return result;
   
   }
}
public static void printElements(Collection c)
{
   Iterator it=c.iterator();
   while(it.hasNext())
   {
    System.out.println(it.next());
   }
}
Student(int num,String name)
{
   this.name=name;
   this.num=num;
}
public int HashCode()
{
   return num*name.hashCode();
}
public boolean equals(Object o)
{
   Student s=(Student)o;
   return num==s.num && name.equals(s.name);
}
public int compareTo(Object o)
{
   Student s=(Student)o;
   return num>s.num?1:(num==s.num?0:-1);
}
public String toString()
{
   return num+":"+name;
}
}
**
HashSet是基于Hash算法實現(xiàn)的,其性能通常優(yōu)于TreeSet.
通常都應(yīng)該使用HashSet,在需要排序的功能時,才使用
TreeSet.
**

迭代器：

Collection提供了一個iterator()方法,可以返回一個迭代器，迭代器是指向兩個元素之間的指針。凡是繼承自Collection的接口或間接的實現(xiàn)類都有這個方法.
其中有3個方法
1.hasNext()
2.next()

3.remove()

hasNext()判斷是否有更多的元素，如果有返回true
remove()方法remove()方法需要刪除上一個返回的元素，需要先調(diào)用next()方法后在用remove()，返回的列表有時不一定真正實現(xiàn)remove()方法，根據(jù)需要決定是否實現(xiàn).
如：ArrayList al1=new ArrayList();
Iterator it=al.iterator();
it.next();
while(it.hasNext())
{
System.out.println(it.next());
}
通用方式訪問集合中的元素
另外定義打印函數(shù)
public static void printElements(Collection c)
{
Iterator it=c.iterator();
while(it.hasNext())
{
   System.out.println(it.next());
}
}

Map(HashMap)
|_____SortedMap(TreeMap)

Map:存儲的是key-value對，不能包含重復(fù)的key，可以有重復(fù)的value。子接口SortedMap是一個按升序排列key的Map。
在系統(tǒng)區(qū)windows目錄下有win.ini
有鍵和對應(yīng)的值
asf=MPEGVideo
注冊表存儲的也是這種類型.
就是用Map接口所提供的方法來存儲.
SortedMap是一個按照升序排列key的Map.

Map接口實現(xiàn)類：

HashMap：

對key進(jìn)行散列.
keySet()..values()..entrySet()..
HashMap是實現(xiàn)了Map接口的Hash表.
實現(xiàn)了所有hashmap操作,允許空值和空鍵.
HashSet底層就是hashmap的實現(xiàn).
map接口沒有add()方法.
要放置元素通過put()方法.
Object put(Object key,Object value)
獲取元素的時候
Object get(Object key)
通過鍵獲取值
Hash表,通過鍵計算出相對應(yīng)的存儲位置的值,并輸出.

常用的方法
Set keySet()
返回一個鍵的視圖類型是Set.
Collection values()
返回一個值的視圖類型是Collection.
Set entrySet()
返回一個鍵值對視圖類型是Set.
返回的Set集合當(dāng)中每一個對象都是一個Map.Entry對象.
Map.Entry是一個靜態(tài)的接口.
接口中提供了常用方法
Object getKey()
Object getValue()
*****************************
import java.util.*;
public class HashMapTest
{

public static void printElements(Collection c)
{
   Iterator it=c.iterator();
   while(it.hasNext())
   {
    System.out.println(it.next());
   }
}
public static void main(String []args)
{
   HashMap hm=new HashMap();
   hm.put("1", "zhang3");
   hm.put("2", "li4");
   hm.put("3", "wang5");
  
   System.out.println(hm.get("1"));
   System.out.println(hm.get("2"));
   System.out.println(hm.get("3"));
  
   Set keys=hm.keySet();
   System.out.println("-----------keys---------");
   printElements(keys);

   Collection values=hm.values();
   System.out.println("-----------values---------");
   printElements(values);
  
   Set entrySets =hm.entrySet();
   System.out.println("------------entrySets-----------");
   printElements(entrySets);
   Iterator it=entrySets.iterator();
   while(it.hasNext())
   {
    Map.Entry me=(Map.Entry)it.next();
    System.out.println(me.getKey()+" = "+me.getValue());
   }
  
}
}

**
TreeMap是實現(xiàn)了sorted Map接口的類
TreeMap按照key進(jìn)行排序.
類似HashMap用法
**********************
HashMap和TreeMap比較
和Set類似,HashMap的速度通常都比TreeMap快,
只有在需要排序的功能的時候,才使用TreeMap.

另外有用的類
Collections類不同于Collection類
Collections.sort()主要是對列表排序.
1.自然排尋natural ordering
2.實現(xiàn)比較器Comparator接口
取最大元素Collections.max().
取最小元素Collections.min().
在已經(jīng)排序的List中搜索指定的元素.
Collections.binarySearch().
static void sort(List list)方法是按升序?qū)χ付斜砼判?
自然排序法.
列表中元素必須都實現(xiàn)了comparable接口.與Arrays.sort()是一樣的.
comparable接口在java.lang包當(dāng)中.
實現(xiàn)comparable接口就要實現(xiàn)compareTo()方法.
compareTo()大于返回正數(shù),等于返回0,小于返回負(fù)數(shù).

class Student implements Comparable
{
int num;
String name;
Student(int num,String name)
{
   this.num=num;
   this.name=name;
}
public int compareTo(Object o)
{
   Student s=(Student)o;
   return num>s.num?1:(num==s.num?0:-1);
}
public String toString()
{
   return num+":"+name;
}
}

public static void printElements(Collection c)
{
Iterator it=c.iterator();
while(it.hasNext())
{
   System.out.println(it.next());
}
}
public static void main(String []args)
{
Student s1=new Student(2,"zhangsan");
Student s2=new Student(1,"lisi");
Student s3=new Student(3,"wangwu");
ArrayList a1=new ArryList();
a1.add(s1);
a2.add(s2);
a3.add(s3);
Collections.sort(a1);
printElements(a1);
}
排序的時候可以傳遞一個比較器.
Comparator接口.
java.util包當(dāng)中.
有兩個方法int compare(Object o1,Object o2)
兩個對象進(jìn)行比較當(dāng)對象1大于對象2的時候返回1,
當(dāng)對象1等于對象2的時候返回一個0,
當(dāng)對象1小于對象2的時候返回一個負(fù)數(shù).
和boolean equals(Object obj)方法.
實現(xiàn)一個比較器.
比較器總是和一個特定的類相關(guān).
為某一個類指定一個比較器.
利用內(nèi)部類實現(xiàn)比較器接口.
**內(nèi)部類
聲明為靜態(tài)方法就不需要產(chǎn)生外部類對象.
class Student implements Comparable
{
int num;
String name;
Student(int num,String name)
{
   this.num=num;
   this.name=name;
}
public int compareTo(Object o)
{
   Student s=(Student)o;
   return num>s.num?1:(num==s.num?0:-1);
}
public String toString()
{
   return num+":"+name;
}
static class StudentComparator implements Comparator
{
   public int compare(Object o1,Object o2)
   {
    Student s1=(Student)o1;
    Student s2=(Student)o2;
    int result=s1.num>s2.num ? 1 : (s1.num==s2.num ? 0 : -1);
    if(result==0)
    { //String類實現(xiàn)了compareTo()方法.
     result=s1.name.compareTo(s2.name);
    }
    return result;
   }
}
}

public static void printElements(Collection c)
{
Iterator it=c.iterator();
while(it.hasNext())
{
   System.out.println(it.next());
}
}
public static void main(String []args)
{
Student s1=new Student(2,"zhangsan");
Student s2=new Student(1,"lisi");
Student s3=new Student(3,"wangwu");

ArrayList a1=new ArryList();
a1.add(s1);
a2.add(s2);
a3.add(s3);
Collections.sort(a1,Student.StudentComparator());
printElements(a1);
}
Collections類中提供了一種反序排列方式.
本身返回就是一個比較器對象
static Comparator reverseOrder()

Arrays.sort()也可以指定一個比較器對象
static void sort(Object[] a,Comparator c)
Collections類主要對列表操作.
Arrays類主要對數(shù)組操作.

Vector集合類
Vector:用ArrayList代替Vector.
Vector內(nèi)所有方法都是同步的,存取元素效率低.
在多線程中可以使用
在Collection類中提供了
static list synchronizedList(List list)
可以返回一個同步列表
可以將列表實參傳遞進(jìn)去會返回一個安全的線程同步列表
還有
static Collection synchronizedCollection(Collection c)
static Set synchronizedSet(Set s)

Hashtable:用HashMap代替Hashtable
需要同步Map的時候
可以用Collection類的方法
static Map synchronizedMap(Map m)
但是還是Hashtable獲取的同步Map快一些.

Stack集合類：

Stack:用LinkedList代替Stack.
Stack是從java.util.Vector繼承而來.
還從Vector繼承了alementAt()方法.
同時Stack還繼承了不需要的特性.
所以要使用棧的時候要用LinkedList來自己實現(xiàn).

Properties屬性類.是從Hashtable繼承而來也是存儲鍵值對的.
表示一個持久的屬性集合.
可以存儲win.ini的鍵值對.
在
java.lang.System類當(dāng)中
有
static Properties getProperties()
檢測當(dāng)前系統(tǒng)的屬性
可以使用
void list(PrintStream out)打印系統(tǒng)屬性
還可以讀取一個配置文件:
先建立一個配置文件
winsun.ini
寫入
company=winsun
author=sunxin
corpyright=2003-2004
先實例化一個Property對象
在用
void load(InputStream inStream)方法
可以從一個輸入流中加載一個屬性列表.
輸入流可以用java.io包中的一個類構(gòu)造.
可用
Enumeration propertyNames()
返回Enumeration對象.返回所有鍵的枚舉.
Enumeration是一個接口
提供了兩個方法
boolean hasMoreElements()
Object nextElement()
需要返回值的時候
String getProperty(String key)
返回鍵對應(yīng)的值
import java.util.*;
import java.io.FileInputStream;
import java.io.*;
public class ProTest {
public static void main(String []args)
{
/*   Properties pps=System.getProperties();
   pps.list(System.out);
*/

   Properties pps=new Properties();
   try
   {
    pps.load(new FileInputStream("d:/workspace/ProTest/bin/winsun.ini"));
    Enumeration ENUM=pps.propertyNames();
    while(ENUM.hasMoreElements())
    {
     String str=(String)ENUM.nextElement();
     String strValue=pps.getProperty(str);
    
     System.out.println(str+" = "+strValue);
    }

   }
   catch(FileNotFoundException e)
   {
    e.printStackTrace();
   }
   catch(IOException ex)
   {
    ex.printStackTrace();
   }
}

}

static String getProperty(String key)
static String getProperty(String key,String def)