Java集合框架详解

数据结构定义：

是以某种形式将数据组合在一起的集合。数据结构不仅保存数据，还支持访问和处理数据的操作。在面向对象思想里，一种数据结构也被认为是一个容器（container），它是一个能存储其他对象的对象。

Java集合框架：

在Java中，数据结构通常称为Java集合框架（Java Collection Framework）。

Java框架支持的两种容器：

一种是为了存储一个元素集合，一般称为集合（collection）

另一种是为了存储键/值对(key/value),称为图（map）

根接口：Collection

 Collection接口是处理对象集合的根接口。我们知道，接口下面有很多方法，而Collection的派生类既完成这些方法，也相应添加和自己相关操作的方法。Collection接口的方法如下：

boolean add(o:E) //添加元素
boolean addAll(c:Collection<? extends E>) //将集合c中的所有元素添加给这个集合
void clear（）; //删除
boolean contains（o:Object）//若集合包含包含元素o则返回ture
boolean containsAll（c:Collection<?>） //包含c中所有的元素
boolean equals(o:Object)  //集合间是否相等
void hasCode（）//散列码
boolean isEmpty() //集合不包含任何元素
Interator<E> iterator（）//集合中元素迭代器
boolean remove（o:Object）//删除元素o
boolean removeAll（c:Colection<?>）//从集合中删除c中的所有元素
boolean retainAll（c:Colection<?>）//保留c和该集合都有的元素，相当于两个集合求交集
int size() //返回大小
Object[] toArray() //返回该集合的元素构成的数组Object

从图中可以看出，在Collection集合中，有三种不同类型的集合，分别为Set（规则集），List（线性表），Queue（队列）

1 Set（规则集）

大体注意几点：首先，规则集是没有重复的元素的，其次，从Set派生的具体类有：散列类（HasSet），链式散列集（LinkedHashSet）和树形集TreeSet。

其中HasSet（散列集）因其没有特定的顺序，所以其输出时没有固定顺序的，如下程序输出的时候并不按照调用add的顺序输出的。

package gibbon.collection.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class TestHashSet {
	public static void main(String[] args){
		Set<String> set = new HashSet<String>();
		set.add("Beijing");
		set.add("Shanghai");
		set.add("Guangzhou");
		set.add("Shenzhen");
		set.add("Beijing");
		
		System.out.println(set);
		
		Iterator<String> iterator = set.iterator();
		
		while(iterator.hasNext()){
			System.out.println(iterator.next().toUpperCase() + " ");
		}
	}
}

输出如下：

[Shenzhen, Guangzhou, Shanghai, Beijing]
SHENZHEN 
GUANGZHOU 
SHANGHAI 
BEIJING 

而链式散列集（LinkedHashSet）像个锁链一样把加进来的元素链接起来，所以在输出（像解开锁链），得一个个按顺序进行，所以其输出是按照插入的顺序进行的。

package gibbon.collection.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class TestLinkedHashSet {
	public static void main(String[] args){
		Set<String> set = new LinkedHashSet<String>();
		set.add("Beijing");
		set.add("Shanghai");
		set.add("Guangzhou");
		set.add("Shenzhen");
		set.add("Beijing");
		
		System.out.println(set);
		
		Iterator<String> iterator = set.iterator();
		
		while(iterator.hasNext()){
			System.out.println(iterator.next().toUpperCase() + " ");
		}
	}
}

输出：

[Beijing, Shanghai, Guangzhou, Shenzhen]
BEIJING 
SHANGHAI 
GUANGZHOU 
SHENZHEN 

最后关于树形集（TreeSet），其可以确保规则集中的元素是有序的，如插入字符串的话，将按照字符串的首字母顺序显示。

package gibbon.collection.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class TestTreeSet {
	public static void main(String[] args){
		Set<String> set = new HashSet<String>();
		set.add("Beijing");
		set.add("Shanghai");
		set.add("Guangzhou");
		set.add("Shenzhen");
		set.add("Beijing");
		
		TreeSet<String> treeSet = new TreeSet<String>(set);
		System.out.println("TreeSet is sorted: " + treeSet);
		
	}
}

输出：

TreeSet is sorted: [Beijing, Guangzhou, Shanghai, Shenzhen]

2 List(线性表)

大体注意几点：首先，线性表具体操作时有顺序的，和规则集不同，其次，从List派生的具体类有：数组线性表（ArrayList）和链表类（LinkedList）

其中，ArrayList大小是固定的，当数组大小确定之后就不能更改，而LinkedList则可以。另外，考虑操作高效问题，若通过下标随机访问元素，但是除了在末尾处之外，不能在其他位置插入或删除元素，则ArrayList提供了高效的集合。而若需要在线性表的任意位置插入或删除元素，当然还是LickedList高效。因为我们知道，链表只需改变其指向数据的改变，而操作数组的话需要移动空间，操作起来就比较耗时。

3 Queue(队列)

大体注意几点：首先，队列是一种先进先出的队列，其次，如果不设置优先级，则元素被追加到队列末尾，然后从队列头中删除。若设置优先级了，则优先级最高的元素首先别删除。

图（Map）

图的类型三种：散裂图（HashMap），链式散列图（LinkedHashMap）和树形图（TreeMap）。Map是一个根接口，其定义的方法如下：

void clear（） //删除图中所有的条目
boolean containsKey（Key：Object）//如果图包含指定键值对对应的条目则返回true
boolean containsValue（value：Object） //图将一个或多个键值对映射到特定值则返回true
set<Map.Entry<K,V>> entrySet() //返回一个包含图中条目的散列集
V get(key:Object) //返回图中指定条目的值
boolean isEmpty() //不包含任何东西就返回true
Set<K> keySet()   //返回包含图中键值对的一个规则集
V put（K,V）      //将一个映射放入图中
void putAll(Map<? extends K,?extends V>) //将所有来自m的条目添加到图中
V remove（key：Obeject） //删除指定键值对对应的条目
int size()         //返回图中的条目个数
Collection《。

一道例题来实践下图：

题意：统计一个文本中单词出现的次数，如文本text为：Good morning,eveyone,Hava a good class and have a better day, Looking forward to watch a movie called 《easy lover》. "You" is not that you. 

实现如下：

package gibbon.collection.map;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class CounterOccurrentOfWords {
	public static void main(String[] args){
		String text = "Good morning,eveyone,Hava a good class and have a better day, Looking forward to watch a movie called 《easy lover》."
				+"\"You\" is not that you. ";
		
		String[] words = text.split("[\r\n\t\"\'.,;:：《》，”’；，。、？|/?(){ }<>]");//以这些值为分隔符
		int length = words.length;
		
		Map<String, Integer> wordMap = new TreeMap<String, Integer>();
		for(int i=0;i<length;i++){
			String key = words[i].toLowerCase();
			if(key.length()> 0){
				if(wordMap.get(key) == null){
					wordMap.put(key, 1); //若之前以key为键无对应的值，则计数为1
				}else{
					int value = wordMap.get(key).intValue(); //否则将之前的值提取并加1，将添加进map中
					value++;
					wordMap.put(key, value);
				}
			}
		}
		
		Set<Map.Entry<String, Integer>> wordEntries = wordMap.entrySet();
		for(Map.Entry<String, Integer> entry:wordEntries){
			System.out.println(entry.getValue() + "\t" + entry.getKey());
		}
	}
}