集合類（三）

阿新 • • 發佈：2018-12-25

Map集合

Map集合的基本方法

Map集合沒有繼承Collection介面，其提供的是key到value的對映。
Map集合中一次新增一對元素，Collection一次新增一個元素。Map集合也稱之為雙列集合，Collection集合稱之為單列集合。
實質上Map集合中儲存的就是鍵值對。Map集合中必須保證鍵的唯一性。
Map集合中的常用方法：

1.新增
value put(key,value):返回前一個和key關聯的值，如果沒有，則返回null

2.刪除
void clear():清空map集合
value remove(key):根據指定的key刪除這個鍵值對

3.判斷
boolean containsKey(key)
boolean containsValue(value)
boolean isEmpty()

4.獲取
value get(key):通過鍵獲取值，如果沒有該鍵返回null.
當然可以通過返回null，來判斷是否包含指定鍵。
int size():獲取鍵值對的個數
Map中常見方法的演示：

public class MapDemo {

    public static void main(String[] args) {
        Map<Integer,String> map=new 
 HashMap<Integer,String>();
        method(map);
    }
    public static void method(Map<Integer,String> map){//學號和姓名
        //新增元素
        System.out.println(map.put(8, "ben"));
        System.out.println(map.put(11, "lily"));
        System.out.println(map.put(4, "luna"));
        System.out 
.println(map.put(4, "lucky"));//存相同鍵值會覆蓋

        System.out.println(map);
        //刪除
        System.out.println("remove:"+map.remove(8));
        //判斷
        System.out.println("containskey:"+map.containsKey(7));
        //獲取
        System.out.println("get:"+map.get(6));
        System.out.println("get:"+map.get(4));
    }
}

輸出結果
null
null
null
luna
{4=lucky, 8=ben, 11=lily}
remove:ben
containskey:false
get:null
get:lucky

取出Map集合所有元素的方法：
1，通過KeySet方法獲取map中所有的鍵所在的Set集合，再通過Set的迭代器獲取到每一個鍵，再對每一個鍵獲取其對應的值即可。
方法示例：

public class MapDemo {

    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<Integer,String>();
        method_1(map);
    }
    public static void method_1(Map<Integer,String> map)
    {
        map.put(8, "lily");
        map.put(3, "cindy");
        map.put(9, "ben");
        map.put(7, "alice");

        Set<Integer> KeySet=map.keySet();
        Iterator<Integer> it=KeySet.iterator();
        while(it.hasNext()){
            Integer key=it.next();
            String value=map.get(key);
            System.out.println(key+":"+value);
        }
    }
}

2.通過Map轉成set就可以迭代，找到了另外一個方法：entrySet。該方法將鍵和值的對映關係作為物件儲存到了Set集合中，而這個對映關係的型別就是Map.Entry型別。
Map.Entry是一個巢狀類，Entry是Map的內部介面。因為它儲存的關係依賴於Map集合而存在，所以把它定義為內部介面。其實現原理的虛擬碼如下：

interface MyMap{
    public static interface MyEntry{//內部介面，介面一般不會有靜態註釋，但是它是一個成員（內部介面）
        void get();
    }
}
class MyDemo implements MyMap.MyEntry{

    @Override
    public void get() {
    }   
}

此方法的方法示例：

public class MapDemo {

    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<Integer,String>();
        method_1(map);
    }
    public static void method_1(Map<Integer,String> map)
    {
        map.put(8, "lily");
        map.put(3, "cindy");
        map.put(9, "ben");
        map.put(7, "alice");

        Set<Map.Entry<Integer, String>> entrySet=map.entrySet();
        Iterator<Map.Entry<Integer, String>> it=entrySet.iterator();
        while(it.hasNext()){
            Map.Entry<Integer, String> me=it.next();
            Integer key=me.getKey();
            String value=me.getValue();
            System.out.println(key+":"+value);
        }
    }

直接獲取Map集合的所有value值：values()
方法演示：

public class MapDemo {

    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<Integer,String>();
        method_1(map);
    }
    public static void method_1(Map<Integer,String> map)
    {
        map.put(8, "lily");
        map.put(3, "cindy");
        map.put(9, "ben");
        map.put(7, "alice");

        Collection<String> values=map.values();
        Iterator<String> it=values.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

Map集合的常用子類

Map常用子類：

Hashtable:內部結構是雜湊表，是同步的。不允許null作為鍵，null作為值。Hashtable類下還有一個子類Properties:用來儲存鍵值對型的配置檔案的資訊，可以和IO技術相結合。
HashMap：內部結構是雜湊表，是不同步的。允許null作為鍵和值。
TreeMap：內部結構是二叉樹，不是同步的。可以對Map集合的鍵進行排序。

jdk1.0的時候沒有集合框架，單列的只有vector，雙列的只有Hashtable。
HashSet實際上是由一個HashMap例項支援。Set集合的底層程式碼其實就是由Map集合來實現的。

HashMap集合使用示例：

public class HashMapDemo {

    public static void main(String[] args) {
        /*
         * 將學生物件和學生的歸屬地通過鍵和值儲存到map集合中。
         * */
        HashMap<Student,String> hm=new HashMap<Student,String>();
        hm.put(new Student("lily",22),"beijing");
        hm.put(new Student("baby",12),"shanghai");
        hm.put(new Student("ben",20),"chengdu");
        hm.put(new Student("alice",13),"wuhan");
        hm.put(new Student("alice",13),"hangzhou");

//      Set<Student> keySet=hm.keySet();
//      Iterator<Student> it=keySet.iterator();
        Iterator<Student> it=hm.keySet().iterator();
        while(it.hasNext()){
            Student key=it.next();
            String value=hm.get(key);
            System.out.println(key.getName()+":"+key.getAge()+":"+value);
        }   
    }
}

輸出：
alice:13:hangzhou
baby:12:shanghai
ben:20:chengdu
lily:22:beijing
這裡，Student類見上一篇部落格《泛型》裡面的程式碼，Student類繼承自Person類。從輸出結果可以看到，Student(“alice”,13)被認定為一個人（鍵相同），所以後面的value為”wuhan”被”hangzhou”覆蓋，要實現這種認定，就必須有比較方法，而這裡的自定義類本身不具備比較性，所以必須在Person類（或者Student類）重寫equals方法和hasCode方法。

TreeMap集合使用示例：

public class TreeMapDemo {

    public static void main(String[] args) {

        //TreeMap<Student,String> tm=new TreeMap<Student,String>();//Ctrl+f:查詢  替換
        TreeMap<Student,String> tm=new TreeMap<Student,String>(new ComparatorByName());//Ctrl+f:查詢  替換
        tm.put(new Student("lily",22),"beijing");
        tm.put(new Student("baby",12),"shanghai");
        tm.put(new Student("ben",20),"chengdu");
        tm.put(new Student("alice",13),"wuhan");
        tm.put(new Student("alice",13),"hangzhou");


        Iterator<Map.Entry<Student, String>> it=tm.entrySet().iterator();

        while(it.hasNext()){
            Map.Entry<Student, String> me=it.next();
            Student key=me.getKey();
            String value=me.getValue();
            System.out.println(key.getName()+":"+key.getAge()+":"+value);
        }

    }

}

初始化不帶引數的時候輸出結果為：
baby:12:shanghai
alice:13:hangzhou
ben:20:chengdu
lily:22:beijing
這個結果是按照年齡來排序的，這是因為在Person類中實現了Comparable介面，並複寫了compareTo()方法，方法中是按照年齡排序的。

初始化帶引數的時候輸出結果為：
alice:13:hangzhou
baby:12:shanghai
ben:20:chengdu
lily:22:beijing

這個結果是按照姓名來排序的，引數裡面傳了一個ComparatorByName()比較器（這個比較器的程式碼見上篇部落格《泛型》）。

LinkedHashMap集合使用示例：

public class LinkedHashMapDemo {

    public static void main(String[] args) {
        HashMap<Integer,String> hm=new LinkedHashMap<Integer,String>();
        hm.put(7,"sunny");
        hm.put(17,"snow");
        hm.put(3,"rain");
        hm.put(24,"wind");

        Iterator<Map.Entry<Integer,String>> it=hm.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry<Integer,String> me=it.next();
            Integer key=me.getKey();
            String value=me.getValue();
            System.out.println(key+":"+value);
        }
    }
}

輸出結果：
7:sunny
17:snow
3:rain
24:wind
結果是有序的，輸出的順序即輸入的順序。

Map集合練習

“fdgavcbsacdfs”獲取該字串中，每個字母出現的次數。
要求列印的結果是：a(2)b(1)….;
思路：
1. 字母的個數是有限的，可以將每個字母作為唯一的鍵，出現的次數作為對應的值，用Map集合的鍵值對進行儲存。具體分析如下：
  對於結果的分析發現，字母和次數之間存在著對映關係。而且這種關係很多。很多就需要儲存，能儲存對映關係的容器有陣列和Map集合。
  由於任意的關係一方（字母或者次數）都不是有序編號。那就使用Map集合。又發現可以保證唯一性的一方具備中順序如a b c…所以可以使用TreeMap集合。
2. 這個集合中最終應該儲存的是字母和次數的對應關係。
  2.1 將字串轉換成字元陣列；
  2.2 遍歷字元陣列，用字元陣列中的每一個字母元素作為鍵去Map集合中查詢：若查詢沒有這個字母，則將這個字母作為鍵存入集合中，且值設為一；若查詢有這個字母，則將這個字母鍵對應的值取出，值加一，然後再存入集合當中，這樣新的字母和對應的值就會覆蓋原來的。
  2.3 遍歷結束，map集合就記錄所有字母的出行次數。

程式碼如下：

public class MapTest {

    public static void main(String[] args) {
        String str="Just one Last-dance~";
        String s=getCharCount(str);
        System.out.println(s);

    }
    public static String getCharCount(String str) {
        //將字串變成字元陣列
        char[] chs=Arrays.toArray(str);
        //定義map集合表
        Map<Character,Integer> map=new TreeMap<Character,Integer>;

        for(int i=0;i<chs.length;i++){
            if(!(chs[i]<'a'&&chs[i]>'z'||chs[i]<'A'&&chs[i]>'Z'))
                continue;
            //將陣列中的字母作為鍵去查map表
            Integer value=map.get(chs[i]);
            int count=1;
            //判斷值是否為空
            if(!value==null)
                count=value+1;
            map.put(chs[i],count);

            /*
            if(value==null){
                map.put(chs[i],1);
            }else{
                map.put(chs[i],value+1);
            }
            */
        }

        return mapToString(map);
    }

    private static String mapToString(Map<Character, Integer> map) {
        StringBuilder sb=new StringBuilder();
        Iterator<Character> it=map.keySet().iterator();
        while(it.hasNext()){
            Character key=it.next();
            Integer value=map.get(key);
            sb.append(key+"("+value+")");
        }

        return sb.toString();
    }
}

輸出結果：
J(1)L(1)a(2)c(1)d(1)e(2)n(2)o(1)s(2)t(2)u(1)

2.查表法應用
Map集合在有對映關係時，可以優先考慮。在查表法中的應用較為多見。

public class MapTest2 {

    public static void main(String[] args) {
        /*
         Map集合在有對映關係時，可以優先考慮
         在查表法中的應用較為多見。
         * */
        String week=getWeek(1);
        System.out.println(week);

        System.out.println(getWeekByMap(week));
    }

    public static String getWeekByMap(String week){
        Map<String,String> map=new HashMap<String,String>();
        map.put("星期一","Mon");
        map.put("星期二","Tues");
        map.put("星期三","Wen");
        map.put("星期四","Thur");
        map.put("星期五","Fri");
        map.put("星期六","Sat");
        map.put("星期日","Sun");
        map.put("星期天","Sun");

        return map.get(week);
    }

    public static String getWeek(int week){
        if(week<1||week>7)
            throw new RuntimeException("no such week,please input again");
        String[] weeks={"","星期一","星期二","星期三","星期四","星期五","星期六","星期天"};
        return weeks[week];
    }
}

工具類

Collections

Collections是集合框架的工具類。java.util.Collections工具類提供很多有用的方法這些方法都是靜態的。
1.對list集合進行指定順序的排序

public class CollectonsDemo {

    public static void main(String[] args) {
        /*
         * Collections:是集合框架的工具類
         * 裡面的方法都是靜態的
         */
        demo_1();

    }

    public static void demo_1(){
        List<String> list=new ArrayList<String>();

        list.add("abcdef");
        list.add("no");
        list.add("yes");
        list.add("happy");
        list.add("yeah");

        System.out.println(list);

        //對list集合進行指定順序的排序
        Collections.sort(list);
        //mySort(list);//根據工具類裡sort方法原理自定義的方法
        System.out.println(list);


        //mySort_1(list,new ComparatorByLength());根據工具類裡帶引數的sort方法原理自定義的方法
        //System.out.println(list);
        Collections.sort(list,new ComparatorByLength());
        System.out.println(list);
    }
//Collections工具類中不帶引數的sort方法實現原理：
public static <T extends Comparable<? super T>>void mySort(List<T> list){
    for(int i=0;i<list.size()-1;i++){
        for(int j=i+1;j<list.size();j++){
            if(list.get(i).compareTo(list.get(j))>0){
//              T temp=list.get(i);
//              list.set(i,list.get(j));
//              list.set(j, temp);
                Collections.swap(list, i, j);
            }
        }
    }
}
//Collections工具類中帶引數的sort方法實現原理：
public static <T>void mySort_1(List<T> list,Comparator<? super T> comp){
    for(int i=0;i<list.size()-1;i++){
        for(int j=i+1;j<list.size();j++){
            if(comp.compare(list.get(i),list.get(j))>0){
//              T temp=list.get(i);
//              list.set(i,list.get(j));
//              list.set(j, temp);
                Collections.swap(list, i, j);
            }
        }
    }
}
}

查詢（折半查詢，以及查詢集合中的最大最小值）

public class CollectonsDemo {

    public static void main(String[] args) {

        demo_2();
    }

    public static void demo_2(){
        List<String> list=new ArrayList<String>();

        list.add("abcdef");
        list.add("no");
        list.add("yes");
        list.add("happy");
        list.add("yeah");

        Collections.sort(list);
        System.out.println(list);

        int index=Collections.binarySearch(list, "aca");
        System.out.println(index);//-2  查詢的元素不存在的時候，返回的索引是(-插入點-1)，這樣即使插入點為0的時候也可以知道
        int index1=Collections.binarySearch(list, "yeah");
        System.out.println(index1);

        //獲取最大值
        String max=Collections.max(list);//根據元素的自然順序，返回給定collection的最大元素，同理還有min
        System.out.println("max:"+max);

        String max1=Collections.max(list,new ComparatorByLength());//根據指定比較器產生的順序，返回給定collection的最大元素
        System.out.println("lengthmax:"+max1);
    }
}

逆轉有序集合中元素的順序。

public class CollectonsDemo {

    public static void main(String[] args) {

        demo_3();

    }

    public static void demo_3() {
        /*
        //原理
        TreeSet<String> ts=new TreeSet<String>(new Comparator<String>(){//匿名內部類 定義了一個基於字元字典順序的比較器  實現逆序
            @Override
            public int compare(String o1, String o2) {

                int temp=o2.compareTo(o1);
                return temp;    
            }
        });
        */
        //reverseOrder：返回一個比較器，強行逆轉順序（自然順序或指定比較器順序）
//      TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder());
        TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));
        ts.add("nani");
        ts.add("zzz");
        ts.add("wanna");
        ts.add("pill");
        ts.add("aow");

        System.out.println(ts);
    }       
}

輸出：[wanna, pill, nani, zzz, aow]
這裡定義了一個字串長度的比較器：

public class ComparatorByLength implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {
        int temp=o1.length()-o2.length();

        return temp==0?o1.compareTo(o2):temp;
    }
}

其他：
replaceAll()、shuffle()、fill()等等

public class CollectonsDemo {

    public static void main(String[] args) {

        demo_4();
    }

    private static void demo_4() {
        List<String> list=new ArrayList<String>();

        list.add("abcdef");
        list.add("no");
        list.add("yes");
        list.add("happy");
        list.add("yeah");

        System.out.println(list);
        Collections.replaceAll(list,"happy","crazy");//實現原理：先找到happy元素的索引，然後再用set方法替換
        // 使用另一值替換列表中出現的所有某一指定值            set(indexOf("happy"),"crazy");
        System.out.println(list);

        //shuffle(List<?> list)    shuffle(List<?> list,Random rnd)  使用預設（指定）隨機源對指定列表進行置換
        Collections.shuffle(list);
        System.out.println("shuffle:"+list);

        Collections.fill(list,"hahaha");//使用指定元素替換指定列表中的所有元素fill(List<? super T> list, T obj)
        System.out.println(list);
    }

給非同步的集合加鎖

Collections工具類裡有方法：

synchronizedCollection(Collection<T> c)
synchronizedList(List<T> list)
synchronizedMap(Map<K,V> m)
synchronizedSet(Set<T> s)   
synchronizedSortedMap(SortedMap<K,V> m)
synchronizedSortedSet(SortedSet<T> s)

給非同步集合加鎖原理：

class MyCollections{
    public List synList(List list){

        return new MyList(list);

    }
}

class MyList implements List{
    private List list;
    private static final Object lock=new Object();

    MyList(List list){
        this.list=list;

    }

    public boolean add(Object obj){

        synchronized(lock){
            return list.add(obj);
        }
    }

    public boolean remove(Object obj){

        synchronized(lock){
            return list.remove(obj);
        }
    }
}

其使用如下：

List list=new ArrayLlist();//非同步
list=MyCollections.synLlist(list);

Arrays

Arrays是集合框架的工具類。裡面的方法都是靜態的。
1. binarySearch
通過二分查詢法對有序的陣列進行查詢。適合除了boolean型別的其他所有（byte,char,double,float,int,long,short等）基本型別，還有Object型別和泛型。
2. copyOf以及copyOfRange
複製指定陣列，擷取或填充（長度大於原陣列時），使副本陣列具有相應長度；將指定陣列的一定範圍複製到新陣列。
3. equals和deepEquals
equals：兩個引數均為陣列，判斷兩個陣列的每一個對應的元素是否相等，以此來判斷陣列是否相等。
deepEquals：針對陣列中的元素還是陣列的情況。
4. fill
用指定元素將陣列的元素替換或者部分替換，給陣列賦值。
5. hashCode和deepHashCode
hashCode：計算一個數組的hashCode.
deepHashCode：針對陣列中的元素還是陣列的情況。
6. sort
對陣列或者陣列的一部分進行排序。適合除布林型別的基本型別，還有Object型別（實現了Comparable介面），以及泛型(提供比較器Comparator)。
7. toString和deepToString
toString：返回陣列的字串形式。直接列印陣列會列印陣列的實體（例如[[email protected]這種形式），而不會列印陣列的內容，這個時候就要用toString方法。
deepToString：針對陣列中的元素還是陣列的情況。
toString的實現：

    //toString的經典實現
     public static String myToString(int[] a) {
            if (a == null)
                return "null";
            int iMax = a.length - 1;
            if (iMax == -1)
                return "[]";

            StringBuilder b = new StringBuilder();
            b.append('[');
            for (int i = 0; ; i++) {//中間省略條件判斷，提高了效率
                b.append(a[i]);
                if (i == iMax)
                    return b.append(']').toString();
                b.append(", ");
            }
        }

asList（重點）
返回一個受指定陣列支援的固定大小的列表。（對返回列表的更改會“直接寫”到陣列）
簡單來說，這個方法的用處就是將陣列轉為集合。
優點：可以使用集合的方法運算元組中的元素。
注意：
1. 陣列的長度是固定的，所以對於集合的增刪方法是不可以使用的，否則會發生java.lang.UnsupportedOperationException異常。
2. 如果陣列中的元素是物件，那麼轉成集合的時候，直接將陣列中的元素作為集合中的元素進行集合儲存。如果陣列中的元素是基本型別數值，那麼會將該陣列作為集合中的元素進行儲存。

下面用程式碼來演示以上內容：

public class ArraysDemo {

    public static void main(String[] args) {

        demo_1();
        demo_2();

    }

    private static void demo_2() {

        /*
         * 如果陣列中的元素是物件，那麼轉成集合的時候，直接將陣列中的元素作為集合中的元素進行集合儲存。
         * 如果陣列中的元素是基本型別數值，那麼會將該陣列作為集合中的元素進行儲存。
         * 
         * */

        int[] arr={23,32,12,45,61};
        List<int[]> list=Arrays.asList(arr);
        System.out.println(list);//[[[email protected]]  陣列實體
        System.out.println(list.size());//1  陣列實體存進去了，只有一個元素

    }

    public static void demo_1() {
        /*
         * 重點：List asList(陣列)  陣列->集合
         * 
         * 優勢：可以使用集合的方法運算元組中的元素
         * 注意：陣列的長度是固定的，所以對於集合的增刪方法是不可以使用的，
         *  否則會發生java.lang.UnsupportedOperationException異常
         * */
        String[] arr1={"abc","kkk","zaza","moumou"};
        boolean b=myContains(arr1, "kkk");
        System.out.println(b);

        List<String> list=Arrays.asList(arr1);
        boolean bb=list.contains("kkk");
        System.out.println("list contains:"+bb);

        //list.add("hiahia");//java.lang.UnsupportedOperationException
    }
    //contains方法的實現原理
    public static boolean myContains(String[] arr,String key){

        for(int i=0;i<arr.length;i++){
            if(arr[i].equals(key))
                return true;
        }
        return false;
    }
}

輸出結果為：
true
list contains:true
[[[email protected]]
1

在demo_1方法中，將陣列轉換成了列表，並用列表的方法contains來判斷是否數組裡包含指定元素。

toArray
toArray是Collection介面（注意不是Collections工具類）中功能與Arrays工具類的asList方法相對的一個方法，它的功能是將集合轉為陣列。
將集合轉為陣列，可以對集合中的元素操作的方法進行限定，不允許對其進行增刪。
演示程式碼：

public class ToArray {

    public static void main(String[] args) {
        /*
         * 集合轉陣列
         * 
         * 使用Collection介面中的toArray方法
         * 
         * 集合轉陣列：可以對集合中的元素操作的方法進行限定，不允許對其進行增刪。
         * 
         * */

        List<String> list=new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");

    /*
     toArray方法需要傳入一個指定型別的陣列。
     長度如何定義：
     如果長度小於集合的size，那麼該方法會建立一個同類型並和集合相同size的陣列。
     如果長度大於集合的size，那麼該方法會使用指定的陣列，儲存集合中的元素。其他位置預設為null。

     所以建議長度就指定為集合的size

     * */
        String[] arr1=list.toArray(new String[2]);
        String[] arr2=list.toArray(new String[4]);
        String[] arr3=list.toArray(new String[5]);
        System.out.println(Arrays.toString(arr1));//[abc1, abc2, abc3, abc4]
        System.out.println(Arrays.toString(arr2));//[abc1, abc2, abc3, abc4]
        System.out.println(Arrays.toString(arr3));//[abc1, abc2, abc3, abc4, null]

    }

}

jdk5.0集合框架的新特性

foreach語句

格式：

for（型別 變數：Collection集合|陣列）
            {

            }

傳統for語句和高階for語句的區別：
傳統for可以完成對語句執行很多次，因為可以定義控制迴圈的增量和條件；
高階for是一種簡化形式。它必須有被遍歷的目標，該目標要麼是陣列，要麼是Collection單列集合。
使用情景區別：
對於陣列的變數如果僅僅是獲取陣列中的元素，可以使用高階for語句；
如果要對陣列的角標進行操作建議使用傳統for語句。
不可以直接用高階for語句遍歷map集合，但是可以將map轉成單列的set。
foreach語句程式碼演示：

public class ForEachDemo {

    public static void main(String[] args) {

        List<String> list =new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");

        //遍歷列表
        for(String s:list){//只用於遍歷和迭代     簡化書寫
            System.out.println(s);
        }


//      Iterator<String> it=list.iterator();
//      while(it.hasNext()){
//          System.out.println(it.next());
//      }

        //遍歷陣列
        int[] arr={3,4,6,8,1};
        for(int i:arr){
            System.out.println(i);
        }

        //遍歷Map集合
        //不可以直接用高階for語句遍歷map集合，但是可以將map轉成單列的set。
        Map<Integer,String> map=new HashMap<Integer,String>();

        map.put(2, "lily");
        map.put(14, "ben");
        map.put(6, "juice");
        map.put(72, "milk");

        for(Integer key:map.keySet()){
            String value=map.get(key);
            System.out.println(key+":"+value);
        }

        for(Map.Entry<Integer, String> me:map.entrySet()){
            Integer key=me.getKey();
            String value=me.getValue();
            System.out.println(key+":"+value);
        }
    }
}

可變引數

可變引數適用於引數個數不確定，型別確定的情況，java把可變引數當做陣列處理。
注意：可變引數必須位於引數列表的最後一項。
程式碼演示：

public class ParamterDemo {

    public static void main(String[] args) {
        int[] arr={4,5,6};
        int sum1=add(arr);
        System.out.println("sum1="+sum1);
        int sum2=newAdd(4,5,6);
        System.out.println("sum2="+sum2);
        int sum3=newAdd(4,5,6,7,8);
        System.out.println("sum3="+sum3);

    }
    /*
     函式的可變引數
     其實就是一個數組，但是接收的是陣列的元素。
     自動將這些元素封裝成陣列。簡化了呼叫者的書寫。
     注意：可變引數型別，必須定義在引數列表的結尾。
     * */
    public static int newAdd(int... arr){
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum+=arr[i];
        }
        return sum;
    }
    public static int add(int[] arr){
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum+=arr[i];
        }
        return sum;
    }
}

靜態匯入

要使用靜態成員（方法和變數），必須給出提供這個靜態成員的類。
使用靜態匯入可以使被匯入類的靜態成員在當前類直接可見，因此使用這些靜態成員無需再給出他們的類名。
程式碼示例：

import java.util.ArrayList;
//import java.util.Collections;
import java.util.List;

import static java.util.Collections.*;
//import static java.util.Collections.sort;//靜態匯入，其實匯入的是類中的靜態成員
//import static java.util.Collections.max;

import static java.lang.System.*;

public class StaticImportDemo {

    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();

        list.add("nani");
        list.add("sleepy");
        list.add("haqian");

//      System.out.println(list);
        out.println(list);//靜態匯入了System類

//      Collections.sort(list);

        sort(list);//靜態匯入了Collections介面的所有類的靜態成員
        System.out.println(list);

        String max=max(list);
        System.out.println("max:"+max); 
    }
}

集合類（三）

Map集合

Map集合的基本方法

Map集合的常用子類

Map集合練習

工具類

Collections

Arrays

jdk5.0集合框架的新特性

foreach語句

可變引數

靜態匯入

集合類（三）

黑馬程式設計師——Java集合框架（三）之Map集合、Collections與Arrays工具類

JDK5新特性之線程同步工具類（三）

類（三）

集合框架（三）

Java常用類（三）之StringBuffer與StringBuidler

Java常用的集合類（轉）

JAVA集合類（上）

Java集合Set（三）

java常用工具類（三）—— 檔案讀取的操作類

java常用工具類（三）—— Excel 操作工具

java常用工具類（三）—— 文件讀取的操作類

常用工具類（三）：獲取介面引數與統一返回結果

PHP+MySQL開發小專案的集合筆記（三）關聯資料庫，並限制小數位數

Java--容器/集合類（Collection）理解和使用

定製併發類（三）實現一個基於優先順序的Executor類

併發工具類（三）控制併發執行緒數的Semaphore

面試中常考的幾個集合類（java）

劃分方法聚類（三） Canopy+K-MEANS 演算法解析

使用Python進行層次聚類（三）——層次聚類簇間自然分割方法和評價方法

集合類（三）

Map集合

Map集合的基本方法

Map集合的常用子類

Map集合練習

工具類

Collections

Arrays

jdk5.0集合框架的新特性

foreach語句

可變引數

靜態匯入

相關推薦