JAVA中常用集合

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

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

Collection接口常用的方法：

boolean add(E o)
確保此 collection 包含指定的元素（可選操作）。

boolean contains(Object o)
如果此 collection 包含指定的元素，則返回 true。

boolean remove(Object o)
從此 collection 中移除指定元素的單個實例，如果存在的話（可選操作）。

int size()
返回此 collection 中的元素數。

Object[] toArray()
返回包含此 collection 中所有元素的數組。

Iterator<E>

iterator()
返回在此 collection 的元素上進行迭代的迭代器。

List接口特有方法：

`E`	`get(int index)` 返回列表中指定位置的元素。

SortedSet接口特有方法：

`E`	`first()` 返回此有序集合中當前第一個（最小的）元素。

`E`	`last()` 返回此有序集合中最後一個（最大的）元素。

集合框架中的實現類.

ArrayList:

本質：我們可以將其看作是能夠自動增長容量的數組，實際是採用對象數組實現的。
自動增長容量就是當數組不夠的時候,再定義更大的數組，然後將數組元素拷貝到新的數組.
例子：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);
   }
}

結果：

winsun
weixin
mybole
[winsun, weixin, mybole]

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

返回固定尺寸的列表,當返回以後就不能修改列表的大小了，可以修改列表中元素的值，但不能增加容量，可以用set()方法對值進行修改：
Object set(int index,Object element)
用element替換指定的index的對象
Arrays.asList()和Collection.toArray()是作爲數組和集合類的一個橋
如果想從集合類中獲得一個數組可以使用toArray()方法；如果想從數組中獲得一個列表可以使用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()返回一個對象的數組.
   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);

}
}
結果：

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是採用雙向循環鏈表實現的.
利用LinkedList實現棧(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底層採用數組完成,而LinkedList則是以一般的
雙向鏈表完成,其內每個對象除了數據本身外，還有兩個引用,
分別指向前一個元素和後一個元素.
如果我們經常在List的開始處增加元素,或者在List中進行插入
和刪除操作,我們應該使用LinkedList,否則的話,使用ArrayList
將更加快速.
因爲插入和刪除都要移動數組中的元素.
只是訪問就用ArrayList,提供了按索引訪問的機制.

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

HashSet在java.util包當中.
需要導入.
常用方法
boolean add(Object o)
需要使用迭代器
HashSet類實現了Set接口,所以不能有重複的元素.

要根據散列碼計算存儲位置.
而散列碼是利用Object類當中的HashCode()函數獲得的.
而HashCode()函數是通過一個對象的內存地址來得到散列碼的.
所以要重寫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->對象內存地址

TreeSet：
TreeSet是依靠TreeMap來實現的.
TreeSet是一個有序集合,TreeSet中元素將按照升序排列,
缺省是按照自然排序進行排列,意味着TreeSet中元素要
實現Comparable接口.
我們可以在構造TreeSet對象時,傳遞實現了Comparator接口
的比較器對象.
java.util包當中TreeSet類
import java.util.*;
public class TreeSetTest {
//如果自定義類對象要加入TreeSet要實現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類實現了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算法實現的,其性能通常優於TreeSet.
通常都應該使用HashSet,在需要排序的功能時,才使用
TreeSet.
**

迭代器：

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

3.remove()

hasNext()判斷是否有更多的元素，如果有返回true
remove()方法remove()方法需要刪除上一個返回的元素，需要先調用next()方法後在用remove()，返回的列表有時不一定真正實現remove()方法，根據需要決定是否實現.
如：ArrayList al1=new ArrayList();
Iterator it=al.iterator();
it.next();
while(it.hasNext())
{
System.out.println(it.next());
}
通用方式訪問集合中的元素
另外定義打印函數
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對，不能包含重複的key，可以有重複的value。子接口SortedMap是一個按升序排列key的Map。
在系統區windows目錄下有win.ini
有鍵和對應的值
asf=MPEGVideo
註冊表存儲的也是這種類型.
就是用Map接口所提供的方法來存儲.
SortedMap是一個按照升序排列key的Map.

Map接口實現類：

HashMap：

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

常用的方法
Set keySet()
返回一個鍵的視圖類型是Set.
Collection values()
返回一個值的視圖類型是Collection.
Set entrySet()
返回一個鍵值對視圖類型是Set.
返回的Set集合當中每一個對象都是一個Map.Entry對象.
Map.Entry是一個靜態的接口.
接口中提供了常用方法
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是實現了sorted Map接口的類
TreeMap按照key進行排序.
類似HashMap用法
**********************
HashMap和TreeMap比較
和Set類似,HashMap的速度通常都比TreeMap快,
只有在需要排序的功能的時候,才使用TreeMap.

另外有用的類
Collections類不同於Collection類
Collections.sort()主要是對列表排序.
1.自然排尋natural ordering
2.實現比較器Comparator接口
取最大元素Collections.max().
取最小元素Collections.min().
在已經排序的List中搜索指定的元素.
Collections.binarySearch().
static void sort(List list)方法是按升序對指定列表排序.
自然排序法.
列表中元素必須都實現了comparable接口.與Arrays.sort()是一樣的.
comparable接口在java.lang包當中.
實現comparable接口就要實現compareTo()方法.
compareTo()大於返回正數,等於返回0,小於返回負數.

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包當中.
有兩個方法int compare(Object o1,Object o2)
兩個對象進行比較當對象1大於對象2的時候返回1,
當對象1等於對象2的時候返回一個0,
當對象1小於對象2的時候返回一個負數.
和boolean equals(Object obj)方法.
實現一個比較器.
比較器總是和一個特定的類相關.
爲某一個類指定一個比較器.
利用內部類實現比較器接口.
**內部類
聲明爲靜態方法就不需要產生外部類對象.
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類實現了compareTo()方法.
     result=s1.name.compareTo(s2.name);
    }
    return result;
   }
}
}

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

Vector集合類
Vector:用ArrayList代替Vector.
Vector內所有方法都是同步的,存取元素效率低.
在多線程中可以使用
在Collection類中提供了
static list synchronizedList(List list)
可以返回一個同步列表
可以將列表實參傳遞進去會返回一個安全的線程同步列表
還有
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來自己實現.

Properties屬性類.是從Hashtable繼承而來也是存儲鍵值對的.
表示一個持久的屬性集合.
可以存儲win.ini的鍵值對.
在
java.lang.System類當中
有
static Properties getProperties()
檢測當前系統的屬性
可以使用
void list(PrintStream out)打印系統屬性
還可以讀取一個配置文件:
先建立一個配置文件
winsun.ini
寫入
company=winsun
author=sunxin
corpyright=2003-2004
先實例化一個Property對象
在用
void load(InputStream inStream)方法
可以從一個輸入流中加載一個屬性列表.
輸入流可以用java.io包中的一個類構造.
可用
Enumeration propertyNames()
返回Enumeration對象.返回所有鍵的枚舉.
Enumeration是一個接口
提供了兩個方法
boolean hasMoreElements()
Object nextElement()
需要返回值的時候
String getProperty(String key)
返回鍵對應的值
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();
   }
}