01Map集合概述

A:Map集合概述:
我們通過查看Map接口描述,發(fā)現(xiàn)Map接口下的集合與Collection接口下的集合盖彭，它們存儲數(shù)據(jù)的形式不同
? a:Collection中的集合拦坠，元素是孤立存在的（理解為單身）脖咐，向集合中存儲元素采用一個個元素的方式存儲叽奥。
?
b:Map中的集合，元素是成對存在的(理解為夫妻)。每個元素由鍵與值兩部分組成，通過鍵可以找對所對應(yīng)的值蜜宪。
?
Collection中的集合稱為單列集合，Map中的集合稱為雙列集合祥山。
? 需要注意的是圃验，Map中的集合不能包含重復(fù)的鍵，值可以重復(fù)缝呕；每個鍵只能對應(yīng)一個值澳窑。
Map
|--HashMap
|--LinkedHashMap

02Map接口中的常用方法

A:Map接口中的常用方法
/*
* Map接口中的常用方法
* 使用Map接口的實現(xiàn)類 HashMap
/
public class MapDemo {
public static void main(String[] args) {
function_2();
}
/
* 移除集合中的鍵值對,返回被移除之前的值
* V remove(K)
*/
public static void function_2(){
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "a");
map.put(2, "b");
map.put(3, "c");
System.out.println(map);

        String value = map.remove(33);
        System.out.println(value);
        System.out.println(map);
    }
    
    /*
     * 通過鍵對象,獲取值對象
     * V get(K)
     * 如果集合中沒有這個鍵,返回null
     */
    public static void function_1(){
        //創(chuàng)建集合對象,作為鍵的對象整數(shù),值的對象存儲字符串
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        System.out.println(map);
        
        String value = map.get(4);
        System.out.println(value);
    }
    
    /*
     *  將鍵值對存儲到集合中
     *  V put(K,V) K 作為鍵的對象, V作為值的對象
     *  存儲的是重復(fù)的鍵,將原有的值,覆蓋
     *  返回值一般情況下返回null,
     *  存儲重復(fù)鍵的時候,返回被覆蓋之前的值
     */
    public static void function(){
        //創(chuàng)建集合對象,HashMap,存儲對象,鍵是字符串,值是整數(shù)
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("a", 1);
        
        map.put("b", 2);
        
        map.put("c", 3);
        
        System.out.println(map);
    }
   }

03Map集合遍歷方式keySet方法

A:Map集合遍歷方式keySet方法
1.獲取Map集合中所有的鍵，由于鍵是唯一的供常，所以返回一個Set集合存儲所有的鍵
2.遍歷鍵的Set集合摊聋，得到每一個鍵
3.根據(jù)鍵利用get(key)去Map找所對應(yīng)的值
/*
* Map集合的遍歷
* 利用鍵獲取值
* Map接口中定義方法keySet
* 所有的鍵,存儲到Set集合
/
public class MapDemo1 {
public static void main(String[] args) {
/
* 1. 調(diào)用map集合的方法keySet,所有的鍵存儲到Set集合中
* 2. 遍歷Set集合,獲取出Set集合中的所有元素 (Map中的鍵)
* 3. 調(diào)用map集合方法get,通過鍵獲取到值
*/
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("a", 11);
map.put("b", 12);
map.put("c", 13);
map.put("d", 14);

        //1. 調(diào)用map集合的方法keySet,所有的鍵存儲到Set集合中
        Set<String> set = map.keySet();
        //2. 遍歷Set集合,獲取出Set集合中的所有元素 (Map中的鍵)
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            //it.next返回是Set集合元素,也就是Map中的鍵
            //3. 調(diào)用map集合方法get,通過鍵獲取到值
            String key = it.next();
            Integer value = map.get(key);
            System.out.println(key+"...."+value);
        }
        
        System.out.println("=======================");
        

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

04Map集合Entry對象

A:Map集合Entry對象
interface Map{
interface Entry{//Entry是Map的一個內(nèi)部接口
//由Map的子類的內(nèi)部類實現(xiàn)

    }
 }
 class HashMap{
    static class Entry<K,V> implements Map.Entry<K,V> {//Entry對象指的就是該類的對象
        final K key;
              V value;
    }
 }
 在Map類設(shè)計時，提供了一個嵌套接口：Entry栈暇。
 Entry將鍵值對的對應(yīng)關(guān)系封裝成了對象麻裁。
 即鍵值對對象，這樣我們在遍歷Map集合時源祈，就可以從每一個鍵值對（Entry）對象中獲取對應(yīng)的鍵與對應(yīng)的值煎源。
   a:Entry是Map接口中提供的一個靜態(tài)內(nèi)部嵌套接口。
   b:相關(guān)方法
 ?   getKey()方法：獲取Entry對象中的鍵
 ?  getValue()方法：獲取Entry對象中的值
 ?  entrySet()方法：用于返回Map集合中所有的鍵值對(Entry)對象香缺，以Set集合形式返回手销。

05Map集合遍歷方式entrySet方法

A:Map集合遍歷方式entrySet方法
*
* Map集合獲取方式
* entrySet方法,鍵值對映射關(guān)系(結(jié)婚證)獲取
* 實現(xiàn)步驟:
* 1. 調(diào)用map集合方法entrySet()將集合中的映射關(guān)系對象,存儲到Set集合
* Set<Entry <K,V> >
* 2. 迭代Set集合
* 3. 獲取出的Set集合的元素,是映射關(guān)系對象
* 4. 通過映射關(guān)系對象方法 getKet, getValue獲取鍵值對
*
* 創(chuàng)建內(nèi)部類對象 外部類.內(nèi)部類 = new
*/
public class MapDemo2 {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "abc");
map.put(2, "bcd");
map.put(3, "cde");
//1. 調(diào)用map集合方法entrySet()將集合中的映射關(guān)系對象,存儲到Set集合
Set<Map.Entry <Integer,String> > set = map.entrySet();
//2. 迭代Set集合
Iterator<Map.Entry <Integer,String> > it = set.iterator();
while(it.hasNext()){
// 3. 獲取出的Set集合的元素,是映射關(guān)系對象
// it.next 獲取的是什么對象,也是Map.Entry對象
Map.Entry<Integer, String> entry = it.next();
//4. 通過映射關(guān)系對象方法 getKet, getValue獲取鍵值對
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"...."+value);
}

    }
}

=======================第二節(jié)課開始============================================

06Map集合遍歷方式增強for循環(huán)

A:Map集合遍歷方式增強for循環(huán)
A:Map集合遍歷方式entrySet方法
*
* Map集合獲取方式
* entrySet方法,鍵值對映射關(guān)系(結(jié)婚證)獲取
* 實現(xiàn)步驟:
* 1. 調(diào)用map集合方法entrySet()將集合中的映射關(guān)系對象,存儲到Set集合
* Set<Entry <K,V> >
* 2. 迭代Set集合
* 3. 獲取出的Set集合的元素,是映射關(guān)系對象
* 4. 通過映射關(guān)系對象方法 getKet, getValue獲取鍵值對
*
* 創(chuàng)建內(nèi)部類對象 外部類.內(nèi)部類 = new
*/
public class MapDemo2 {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "abc");
map.put(2, "bcd");
map.put(3, "cde");
//1. 調(diào)用map集合方法entrySet()將集合中的映射關(guān)系對象,存儲到Set集合
Set<Map.Entry <Integer,String> > set = map.entrySet();
//2. 迭代Set集合
Iterator<Map.Entry <Integer,String> > it = set.iterator();
while(it.hasNext()){
// 3. 獲取出的Set集合的元素,是映射關(guān)系對象
// it.next 獲取的是什么對象,也是Map.Entry對象
Map.Entry<Integer, String> entry = it.next();
//4. 通過映射關(guān)系對象方法 getKet, getValue獲取鍵值對
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"...."+value);
}

        System.out.println("=========================");
        for(Map.Entry<Integer, String> entry : map.entrySet()){
            System.out.println(entry.getKey()+"..."+entry.getValue());
        }
    }
  }
  
  注意：Map集合不能直接使用迭代器或者foreach進(jìn)行遍歷。但是轉(zhuǎn)成Set之后就可以使用了图张。

07HashMap集合存儲和遍歷

A:HashMap集合存儲和遍歷
/*
* 使用HashMap集合,存儲自定義的對象
* 自定義對象,作為鍵,出現(xiàn),作為值出現(xiàn)
/
public class HashMapDemo {
public static void main(String[] args) {
function_1();
}
/
* HashMap 存儲自定義對象Person,作為鍵出現(xiàn)
* 鍵的對象,是Person類型,值是字符串
* 保證鍵的唯一性,存儲到鍵的對象,重寫hashCode equals
*/
public static void function_1(){
HashMap<Person, String> map = new HashMap<Person, String>();
map.put(new Person("a",20), "里約熱內(nèi)盧");
map.put(new Person("b",18), "索馬里");
map.put(new Person("b",18), "索馬里");
map.put(new Person("c",19), "百慕大");
for(Person key : map.keySet()){
String value = map.get(key);
System.out.println(key+"..."+value);
}
System.out.println("===================");
for(Map.Entry<Person, String> entry : map.entrySet()){
System.out.println(entry.getKey()+"..."+entry.getValue());
}
}

    /*
     * HashMap 存儲自定義的對象Person,作為值出現(xiàn)
     * 鍵的對象,是字符串,可以保證唯一性
     */
    public static void function(){
        HashMap<String, Person> map = new HashMap<String, Person>();
        map.put("beijing", new Person("a",20));
        map.put("tianjin", new Person("b",18));
        map.put("shanghai", new Person("c",19));
        for(String key : map.keySet()){
            Person value = map.get(key);
            System.out.println(key+"..."+value);
        }
        System.out.println("=================");
        for(Map.Entry<String, Person> entry : map.entrySet()){
            String key = entry.getKey();
            Person value = entry.getValue();
            System.out.println(key+"..."+value);
        }
    }
 }

08LinkedHashMap的特點

*A:LinkedHashMap的特點

  /*
   *  LinkedHashMap繼承HashMap
   *  保證迭代的順序
   */
  public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String, String> link = new LinkedHashMap<String, String>();
        link.put("1", "a");
        link.put("13", "a");
        link.put("15", "a");
        link.put("17", "a");
        System.out.println(link);
    }
  }

09Hashtable的特點

A:Hashtable的特點
/
* Map接口實現(xiàn)類 Hashtable
* 底層數(shù)據(jù)結(jié)果哈希表,特點和HashMap是一樣的
* Hashtable 線程安全集合,運行速度慢
* HashMap 線程不安全的集合,運行速度快
*
* Hashtable命運和Vector是一樣的,從JDK1.2開始,被更先進(jìn)的HashMap取代
*
* HashMap 允許存儲null值,null鍵
* Hashtable 不允許存儲null值,null鍵
*
* Hashtable他的孩子,子類 Properties 依然活躍在開發(fā)舞臺
*/
public class HashtableDemo {
public static void main(String[] args) {
Map<String,String> map = new Hashtable<String,String>();
map.put(null, null);
System.out.println(map);
}
}

10靜態(tài)導(dǎo)入

A:靜態(tài)導(dǎo)入:如果本類中有和靜態(tài)導(dǎo)入的同名方法會優(yōu)先使用本類的
如果還想使用靜態(tài)導(dǎo)入的,依然需要類名來調(diào)用
/
* JDK1.5新特性,靜態(tài)導(dǎo)入
* 減少開發(fā)的代碼量
* 標(biāo)準(zhǔn)的寫法,導(dǎo)入包的時候才能使用
*
* import static java.lang.System.out;最末尾,必須是一個靜態(tài)成員
*/
import static java.lang.System.out;
import static java.util.Arrays.sort;

   public class StaticImportDemo {
    public static void main(String[] args) {
        out.println("hello");
        
        int[] arr = {1,4,2};
        sort(arr);
    }
   }

11方法的可變參數(shù)

A:方法的可變參數(shù)
/
* JDK1.5新的特性,方法的可變參數(shù)
* 前提: 方法參數(shù)數(shù)據(jù)類型確定,參數(shù)的個數(shù)任意
* 可變參數(shù)語法: 數(shù)據(jù)類型...變量名
* 可變參數(shù),本質(zhì)就是一個數(shù)組
*/
public class VarArgumentsDemo {
public static void main(String[] args) {
//調(diào)用一個帶有可變參數(shù)的方法,傳遞參數(shù),可以任意
// getSum();
int sum = getSum(5,34,3,56,7,8,0);
System.out.println(sum);

    }
 
    /*
     * 定義方法,計算10個整數(shù)和
     * 方法的可變參數(shù)實現(xiàn)
     */
    public static int getSum(int...a){
        int sum = 0 ;
        for(int i : a){
            sum = sum + i;
        }
        return sum;
    }
    
    /*
     * 定義方法,計算3個整數(shù)和
     */
    /*public static int getSum(int a,int b ,int c){
        return a+b+c;
    }*/
    
    /*
     * 定義方法,計算2個整數(shù)和
     */
    /*public static int getSum(int a,int b){
        return a+b;
    }*/
 }

12可變參數(shù)的注意事項

A:可變參數(shù)的注意事項
/
* 可變參數(shù)的注意事項
* 1. 一個方法中,可變參數(shù)只能有一個
* 2. 可變參數(shù),必須寫在參數(shù)列表的最后一位
*/
public static void function(Object...o){

    }