Map集合
Map是java雙列集合的頂層接口，Map集合中存儲鍵值對，且鍵值唯一，雙列集合中存儲的也是對象的引用。
當數據之間存在着映射關係時，優先考慮使用Map集合。
Map接口常用方法
1. 添加
V put(K key, V value), 原集合中沒有key值時，插入鍵值對(key,value), 返回null, 原集合中有key值時，新value值覆蓋舊值，並返回舊值。
void put(Map<? extends K, ? extends V>), 將整個指定集合插入到當前集合。
2. 刪除
void clear(), 清空集合
V remove(Object key), 原集合中有key值時，刪除並返回該key對應的value值，原集合中沒有key值時，返回null.
3. 判斷
boolean containsKey(Object key), 判斷集合中是否包含鍵值key.
boolean containsValue(Object value), 判斷集合中是否包含指定value值
boolean isEmpty(), 判斷集合是否爲空。
4. 獲取
V get(Object key), 如果集合中沒有key鍵，返回null.
int size(), 返回集合長度
Collection<V> values(), 獲取映射中值的Collection視圖。
Set<K> keySet(), 返回映射中鍵的set視圖。
Set<May.Entry<K,V>> entrySet, 返回映射中映射關係的Set視圖。
Map集合3個常用子類：Hashtable, HashMap, TreeMap.
Hashtable: 底層是哈希表數據結構，鍵和值都不能是null, 線程同步，從jdk1.0開始就有；作爲鍵的對象必須實現hashCode()和equals()方法。
HashMap: 底層是哈希表數據結構，允許使用null值和null鍵， 線程不同步，從jdk1.2開始有，效率高，優先使用。
LinkedHashMap：HashMap的子類，鍵值是有順序的，取出順序與存入順序相同。
TreeMap: 底層是二叉樹結構，線程不同步，可以對鍵排序，對鍵的排序方法與TreeSet基本一樣，可以使用鍵對象的自然排序，也可以讓TreeMap自身具備比較性（例子？）。
Map和Set很像，其實Set底層就是使用了Map(不太明白，先記錄在這)。
Map集合的2種取出方式
Map集合沒有迭代器，而Collection集合中有迭代器，所以只要將Map集合轉成Set集合，就可以使用迭代器了。
1. keySet(), 將map中所有的鍵存入到Set集合中，而Set具備迭代器，所以可以通過迭代方式取出所有的鍵，再根據get(key)方法獲取每個鍵對應的值。
2. entrySet(), 返回映射關係的Set集合，返回值類型是Set<Map.Entry<K,V>>，映射關係的數據類型是Map.Entry,帶泛型。
Map.Entry<K,V>是Map接口的嵌套內部static接口，該接口中有方法getKey()和getValue()可以取出鍵和值。
自己寫了個程序統計一段字符串中各個單詞出現的次數。
/*
統計一段英文文本中單詞出現的次數
打印結果格式：word(1)you(2)...
*/
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class TreeMapDemo1 {
public static void main(String[] args) {
String s="i am a student, i have no money!";
System.out.println(countWord(s));
}
public static String countWord(String str){
String regex="[A-Za-z0-9]+";//正則表達式，用字符串str去匹配regex，就得到所有單詞
Pattern p=Pattern.compile(regex);//將正則表達式封裝成對象
Matcher m=p.matcher(str);//將正則對象與要作用的字符串相關聯，獲取匹配器對象
TreeMap<String,Integer> tm=new TreeMap<String,Integer>();//定義TreeMap，存放各個單詞及出現的次數
int count=0;//count最好是定義在while循環外面。
while(m.find()){//字符串是否還有匹配regex的下一個子串
Integer value=tm.get(m.group());//m.group()就是匹配得到的子串
if(value!=null)
count=value;
count++;//count自增1是必須要執行的
tm.put(m.group(),count);
count=0;//
}
//下面讓tm按打印要求輸出。
StringBuffer sb=new StringBuffer();
Set<Map.Entry<String,Integer>> entryS=tm.entrySet();
Iterator<Map.Entry<String,Integer>> it=entryS.iterator();
while(it.hasNext()){
Map.Entry<String, Integer> me=it.next();
String ss=me.getKey();
Integer value=me.getValue();
sb.append(ss+"("+value+")");
}
return sb.toString();
}
}
運行結果：
a(1)am(1)have(1)i(2)money(1)no(1)student(1)Map擴展：Map被使用是因爲具有映射關係，映射關係中的值也可以是一個集合，如List集合、HashMap集合。
集合框架的工具類-Collections和Arrays
Collections類
該類的方法都是靜態的，專門用於對集合對象的操作。
1. 對List集合排序
public staic <T extends Comparable<? super T>> void sort(List<T> list), 按List集合元素自然順序排序。
public static <T> void sort(Litst<T> list, Comparator<T> comp), 按指定的比較器排序。
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class CollectionsDemo {
public static void main(String[] args) {
sortDemo();
}
public static void sortDemo(){
List<String> list=new ArrayList<String>();
list.add("adbd");
list.add("sklg");
list.add("oirbb");
list.add("aaa");
list.add("be");
list.add("aaaa");
sop("原集合："+list);
Collections.sort(list);//按String字符串自然順序排序。
sop("按String字符串自然順序排序："+list);
Collections.sort(list,new StrLenComparator());//按字符串長度排序
sop("按字符串長度排序："+list);
}
public static void sop(Object obj){
System.out.println(obj);
}
}
class StrLenComparator implements Comparator<String>{
public int compare(String s1,String s2){
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}
運行結果：
原集合：[adbd, sklg, oirbb, aaa, be, aaaa]
按String字符串自然順序排序：[aaa, aaaa, adbd, be, oirbb, sklg]
按字符串長度排序：[be, aaa, aaaa, adbd, sklg, oirbb]2. 獲取最值
public static <T extends Object&Comparable<? super T>> T max(Collection<? extends T> coll), 按元素自然順序取最大值。
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp), 按比較器取最大值。
3. 二分法查找
int binarySearch(list,key), 如果搜索鍵包含在列表中，返回搜索鍵的索引，否則返回(-(鍵在列表的插入點)-1)。
int binarySearch(list,key,comp)，同上，是按comp比較器查找和定位元素的插入點。
實際形式上類似於排序與最值方法，也帶泛型，這裏不再寫了。
4. 替換反轉
void fill(list,obj), 將list中全部元素替換成指定元素
boolean replaceAll(list, oldVaule, newValue), 方法裏面實際封裝了List接口的set(index,element)方法。
void reverse(list), 反轉集合。
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class CollectionsDemo1 {
public static void main(String[] args) {
methodDemo();
}
public static void methodDemo(){
List<String> list=new ArrayList<String>();
list.add("adbd");
list.add("sklg");
list.add("oirbb");
list.add("aaa");
list.add("be");
list.add("aaaa");
sop("原集合："+list);
Collections.sort(list);//按String字符串自然順序排序。
sop("按String字符串自然順序排序："+list);
Collections.sort(list,new StrLenComparator());//按字符串長度排序
sop("按字符串長度排序："+list);
sop("按String字符串自然順序最靠後的："+Collections.max(list));//按字符串自然順序取最大值
sop("最長的字符串："+Collections.max(list,new StrLenComparator()));//獲取最長的字符串
sop("按字符串自然順序fefdd的插入點是："+(-Collections.binarySearch(list, "fefdd")-1));
sop("按字符串長度順序fefdd的插入點是："+(-Collections.binarySearch(list, "fefdd",new StrLenComparator())-1));
System.out.println("==================================");
List<String> list2=list;
sop("原集合："+list2);
Collections.reverse(list2);
sop("反轉後的集合："+list2);
Collections.replaceAll(list2, "be", "beb");
sop("替換一個元素後的集合："+list2);
Collections.fill(list2, "abc");
sop("集合中元素全部替換成abc: "+list2);
sop("最初的list對象內容也變了："+list);
}
public static void sop(Object obj){
System.out.println(obj);
}
}
class StrLenComparator implements Comparator<String>{
public int compare(String s1,String s2){
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}
/*運行結果：
原集合：[adbd, sklg, oirbb, aaa, be, aaaa]
按String字符串自然順序排序：[aaa, aaaa, adbd, be, oirbb, sklg]
按字符串長度排序：[be, aaa, aaaa, adbd, sklg, oirbb]
按String字符串自然順序最靠後的：sklg
最長的字符串：oirbb
按字符串自然順序fefdd的插入點是：4
按字符串長度順序fefdd的插入點是：5
==================================
原集合：[be, aaa, aaaa, adbd, sklg, oirbb]
反轉後的集合：[oirbb, sklg, adbd, aaaa, aaa, be]
替換一個元素後的集合：[oirbb, sklg, adbd, aaaa, aaa, beb]
集合中元素全部替換成abc: [abc, abc, abc, abc, abc, abc]
最初的list對象內容也變了：[abc, abc, abc, abc, abc, abc]*/
5. 逆轉比較器
Comparator reverseOrder()
import java.util.Collections;
import java.util.TreeSet;
public class CollectionsDemo2 {
public static void main(String[] args) {
orderDemo();
}
public static void orderDemo(){
//TreeSet<String> ts=new TreeSet<String>();//按字母順序排序,[aaa, abcde, cc, k]
//TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder());//按字母反向順序排序, [k, cc, abcde, aaa]
//TreeSet<String> ts=new TreeSet<String>(new StrLenComparator());//按字符串長度從小到大排序, [k, cc, aaa, abcde]
TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));//按字符串長度從大到小排序, [abcde, aaa, cc, k]
ts.add("abcde");
ts.add("aaa");
ts.add("k");
ts.add("cc");
CollectionsDemo1.sop(ts);
}
}6. 獲取線程安全的集合
List sychronizedList(list), 原理是在List的remove(), add()等方法中加鎖，且是同一個鎖，代碼都放在同步代碼塊中。
7. 置換
void swap(list, index1, index2)
void shuffle(list), 將集合元素隨機排放，相當於洗牌。
Arrays類
用於操作數組的工具類，裏面都是靜態方法。其中大量方法可以直接查閱API文檔，這裏特別介紹下面三個。
1. Arrays.toString()
返回數組的字符串形式，如將整型數組 arr{2，3，4}，打印成[2,3,4].
2. Arrays.asList(), 數組轉成List集合
好處： 可以使用集合的思想和方法來操作數組中的元素，如判斷contain()，獲取(get(), indexOf), subList()等.
注：將數組變成集合，不可以使用集合的增刪方法(會報UnsupportedOperationException)，因爲數組的長度固定。
如果數組中的元素都是對象，那麼變成集合時，數組中的元素就直接轉成集合中的元素。
如果數組中的元素都是基本數據類型，則會將整個數組用爲集合中的元素存在。
3. 集合變數組
使用Collection接口中的toArray()方法：T[] toArray(T[] t)。
當指定類型的數組長度小於了集合的size, toArrays()方法內部創建一個新的數組，長度爲集合的size;
如果數組長度大於集合的size, 就不會再創建新數組, 而是直接使用傳遞進來的數組，多餘的位置上值爲null。
可以創建一個剛剛好的數組，這樣最優。
集合變數組的意義在於，可以限定對元素的操作(防止對數組的增刪)。