ht-4 hashmap特性

一、hashmap底層原理：

 hashmap調用默認構造方法會產生一個默認底層是長度為16的Entry數組，首先調用key的hasCode()方法來得到一個整數， int hash = hash(key.hashCode());
 這個整數就是哈希碼，然后把哈希碼作為參數傳遞到hash()函數中來進行運算，即散列運算，得到一個int類型的散列值 int i = indexFor(hash, table.length); (transient Entry[] table;) 把散列值和數組的長度來進行運算，最終得到Entry對象要存放到數組的位置(下標)。 hashmap內部的結構是數組加單向鏈表結構，因為不同的key有可能計算出相同的散列值，根據散列值計算出來的存放到數組的下標會沖突（同一個下標值），此時， 如果鍵相同，散列值也一樣，說明是同一個對象，此時會將鍵所對應的舊值用新的鍵值覆蓋掉， 如果散列值一樣，鍵名不一樣，說明是不同的對象，此時會把鍵值對封裝成entry對象放到那個散列值對應的下標位置處， 原來那個entry對象會以鏈表形式鏈接在新創建的entry對象后面

二、hashmap常用方法：

 存值：public V put(K key, V value)

取值：public V get(Object key) 

獲取所有的鍵：public Set<K> keySet()

獲取所有的值： public Collection<V> values()    Returns a {@link Collection} view of the values contained in this map.

取鍵值對的set集合：public Set<Map.Entry<K,V>> entrySet()

 map集合大小：public int size()

 判斷map是否非空：public boolean isEmpty()

 三、示例：

package com.iotek.map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class HashMapDemo1 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>(); // 接口的引用變量指向實現類的對象
        // 創建HashMap對象，也就是創建一個Map容器
        map.put(null, "張三"); // 添加鍵值對元素
        map.put(null, "李四"); // 有相同的鍵時，后面添加的鍵對應的值會覆蓋掉之前鍵對應的值
        map.put("john", "李四");
        map.put("rose", "玫瑰");
        map.put("mary", "小紅");
        System.out.println("1" + map);

        // 獲取map中所有鍵,返回的是一個Set容器，可以用迭代器對象或者foreach來進行輸出
        Set<String> keys = map.keySet();
        System.out.println("******輸出map容器中所有的鍵：");
        for (String key : keys) {
            System.out.print(key + " "); // 用String類型的變量key來遍歷keys容器
        }

        // 獲取map中所有的值：使用map接口中的values方法，返回Collection接口的實現類
        Collection<String> values = map.values();
        System.out.println("\n******輸出map容器中所有的值：");
        for (String value : values) {
            System.out.print(value + " "); // 用String類型的變量value來遍歷values容器
        }

        // 得到key的同時，得到key所對應的值
        System.out.println("\n******用獲取的鍵來得到對應的值並輸出：");
        for (String key : keys) {
            System.out.print(key + "--" + map.get(key)); // 用String類型的變量key來遍歷keys容器
        }
        System.out.println("\nmap容器中鍵值對的個數是：" + map.size());
        System.out.println("判斷map容器中是否為空：" + map.isEmpty());

        // map.entrySet()返回的是一個set容器，其中放的是map.Entry內部接口
        /*
         * 當我們調用put(key，value)方法時，首先會把key和value封裝到Entry這個靜態內部類中，
         * 再把Entry對象添加到數組中（哈希表），所以我們想要獲取map中的所有鍵值對，只需要獲取
         * 數組匯總所有的Entry，接下來調用Entry對象中的getKey 和getValue方法就能獲取鍵值對
         * 以后想輸出HashMap容器中所有的鍵值對，都可以調用HashMap的 entrySet()方法就可以了！！！
         */
        Set<Entry<String, String>> entrys = map.entrySet();
        System.out.println("使用map接口的entrySet()方法獲取map容器中所有的鍵值對：");
        for (Entry<String, String> entry : entrys) {
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }
        map.clear();
        System.out.println("判斷map容器中是否為空：" + map.isEmpty());

    }

}

 

map中鍵是對象時，需要重寫對象的hash和equals方法：

package com.iotek.map;

import java.util.HashMap;
import java.util.Map;

public class HashMapDemo2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Map<Student, String> map = new HashMap<Student, String>();
        map.put(new Student("jay", 20), "張三"); // 1
        map.put(new Student("lisi", 30), "李四");// 2
        map.put(new Student("rose", 20), "玫瑰");// 3
        map.put(new Student("lisi", 30), "陳飛");// 4
        System.out.println(map.size());
        System.out.println(map.toString());

        /*
         * Student類中不重寫hashCode() and
         * equals()方法，此處map.size()值是4，即map中有4個封裝了鍵值對的Entry對象
         * 重寫了hashCode()和equals()方法后，2和4語句里的學生對象將被判斷為同一個鍵名，因此2位置處的鍵值會被替換掉
         * 這正是我們需要的，對象相同，應該判定為是同一個鍵，因此，這就是需要重寫hashCode()和equals()方法的原因
         */
    }
}

class Student {
    private String name;
    private int age;

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    /*
     * 用source中的 Generate hashCode() and equals() 來 生成重寫的hashCode()方法和equals()方法
     * 只要姓名和年齡相同的學生，那么這個學生對象產生的hashCode值和equals方法的值也是一樣的，
     * 此時就可以認為是hashmap里放的是同一個對象，那么這兩個相同的Student對象作為鍵時，
     * 后面添加的Student對象對應的鍵值應該要覆蓋掉前面添加的鍵值
     */

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true; // 只有當姓名和年齡都一樣時，才返回一個true，表示是同一個對象
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

}

結果：

使用hashmap判斷數組中字符串出現的次數：

package com.iotek.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
 * 使用hashmap判斷數組中字符串出現的次數
 * @author Administrator
 *
 */
public class AccountStringDemo {

    public static void main(String[] args) {
        String[] strs = {"zhangsan","zhangsan","wangwu","chenliu","chenliu","lilei","lilei"};
        Map<String,Integer> data = AccountUtil.account(strs);
        AccountUtil.printData(data);
    }

}

class AccountUtil {
    public static Map<String,Integer> account(String [] strs) {
        Map<String,Integer> data = new HashMap<String, Integer>();
        for(int i = 0; i < strs.length; i++) {
            String str = strs[i];
            if(data.get(str) == null) { 
                data.put(str, 1);
                //如果第一次統計到該字符串，將該字符串作為鍵名，其出現的次數作為鍵值，保存在map容器中
            } else {
                //如果不是第一次捕獲到該字符串，則data.get(str)！=null，那么將鍵值加1，表示第二次讀取到該字符串
                data.put(str, data.get(str)+1);  
            }
        }
        return  data; //將最終的hashmap容器，也就是data返回
    }
    
    public static void printData(Map<String,Integer> data) {
        //使用HashMap的EntrySet()方法，返回map容器：data中的所有鍵值對(全部封裝在Entry中)，然后進行打印
        Set<Entry<String, Integer>> entrys = data.entrySet();
        for(Entry<String, Integer> entry : entrys) {
            System.out.println("字符串" + entry.getKey() + "出現了" + entry.getValue() + "次");
        }
    }
    
}