容器--------HashMap

自定义HashMap，体会底层原理

基础结构

public class JtHashMap01 {
    Node1[] node1s; //位桶数组。buket array
    int size; //存放键值对的个数
    public JtHashMap01(){
        node1s = new Node1[16]; //长度一般定义为2的整数倍
    }
    public void put(Object key,Object value){
        Node1 newNode = new Node1();
        newNode.hash = myHash(key.hashCode(),node1s.length);
        newNode.key = key;
        newNode.value = value;
        newNode.next = null;
        Node1 temp = node1s[newNode.hash];
        if (temp == null){
            //此处数组元素为空，则直接将新节点放进去。
            node1s[newNode.hash] = newNode;
        }else {
            //此处数组元素不为空，则遍历对应链表。
        }
    }
    public int myHash(int v,int length){
        System.out.println(v&(length-1)); //直接位运算,效率较高
        System.out.println((v%(length-1)));//取模运算，效率较低
        return v&(length-1);
    }

    public static void main(String[] args) {
        JtHashMap01 jtHashMap01 = new JtHashMap01();
        jtHashMap01.put(10,"aa");
        jtHashMap01.put(20,"bb");
        jtHashMap01.put(30,"cc");
        System.out.println(jtHashMap01);
    }
}

实现了put方法增加键值对，并且解决了键重复的时候覆盖相应的节点

public class JtHashMap02 {
    Node1[] node1s; //位桶数组。buket array
    int size; //存放键值对的个数
    public JtHashMap02(){
        node1s = new Node1[16]; //长度一般定义为2的整数倍
    }
    public void put(Object key,Object value){
        Node1 newNode = new Node1();
        newNode.hash = myHash(key.hashCode(),node1s.length);
        newNode.key = key;
        newNode.value = value;
        newNode.next = null;
        Node1 temp = node1s[newNode.hash];
        Node1 iterLast = null; //正在遍历的最后一个元素
        boolean keyRepeat = false;
        if (temp == null){
            //此处数组元素为空，则直接将新节点放进去。
            node1s[newNode.hash] = newNode;
            size++;
        }else {
            //此处数组元素不为空，则遍历对应链表。
            while (temp != null){
                //判断key如果重复则覆盖
                if (temp.key.equals(key)){
                    keyRepeat = true;
                    System.out.println("key重复了！！！");
                    temp.value = value; //只是覆盖value，其他的值保持不变
                    break;
                }else {
                    //key不重复,则遍历下一个
                    iterLast = temp;
                    temp = temp.next;
                }
            }
            if (!keyRepeat){//如果没有发生key重复的情况，则添加到链表最后。
                iterLast.next = newNode;
                size++;
            }
        }
    }
    public static int myHash(int v,int length){
        System.out.println(v&(length-1)); //直接位运算,效率较高
        System.out.println((v%(length-1)));//取模运算，效率较低
        return v&(length-1);
    }
    public static void main(String[] args) {
        JtHashMap02 jtHashMap02 = new JtHashMap02();
        jtHashMap02.put(10,"aa");
        jtHashMap02.put(20,"bb");
        jtHashMap02.put(30,"cc");
        jtHashMap02.put(20,"ssss");
        jtHashMap02.put(12,"jj");
        jtHashMap02.put(28,"ll");
        jtHashMap02.put(44,"kk");
        System.out.println(jtHashMap02);
        for (int i= 10;i<100;i++){
            System.out.println(i+"......"+myHash(i,16)); //12,28,44
        }
    }
}

实现toString方法，方便查看Map中的键值对

public class JtHashMap03 {
    Node1[] node1s; //位桶数组。buket array
    int size; //存放键值对的个数

    public JtHashMap03() {
        node1s = new Node1[16]; //长度一般定义为2的整数倍
    }

    public void put(Object key, Object value) {
        Node1 newNode = new Node1();
        newNode.hash = myHash(key.hashCode(), node1s.length);
        newNode.key = key;
        newNode.value = value;
        newNode.next = null;
        Node1 temp = node1s[newNode.hash];
        Node1 iterLast = null; //正在遍历的最后一个元素
        boolean keyRepeat = false;
        if (temp == null) {
            //此处数组元素为空，则直接将新节点放进去。
            node1s[newNode.hash] = newNode;
        } else {
            //此处数组元素不为空，则遍历对应链表。
            while (temp != null) {
                //判断key如果重复则覆盖
                if (temp.key.equals(key)) {
                    keyRepeat = true;
                    System.out.println("key重复了！！！");
                    temp.value = value; //只是覆盖value，其他的值保持不变
                    break;
                } else {
                    //key不重复,则遍历下一个
                    iterLast = temp;
                    temp = temp.next;
                }
            }
            if (!keyRepeat) {//如果没有发生key重复的情况，则添加到链表最后。
                iterLast.next = newNode;
            }
        }
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder("[");
        //遍历数组
        for (int i= 0;i<node1s.length;i++){
            Node1 temp = node1s[i];
            //遍历链表
            while(temp!=null){
                stringBuilder.append(temp.key+":"+temp.value+",");
                temp = temp.next;
            }
        }
        stringBuilder.setCharAt(stringBuilder.length()-1,']');
        return stringBuilder.toString();
    }

    public static int myHash(int v, int length) {
        System.out.println(v & (length - 1)); //直接位运算,效率较高
        System.out.println((v % (length - 1)));//取模运算，效率较低
        return v & (length - 1);
    }

    public static void main(String[] args) {
        JtHashMap03 jtHashMap03 = new JtHashMap03();
        jtHashMap03.put(10, "aa");
        jtHashMap03.put(20, "bb");
        jtHashMap03.put(30, "cc");
        jtHashMap03.put(20, "ssss");
        jtHashMap03.put(12, "jj");
        jtHashMap03.put(28, "ll");
        jtHashMap03.put(44, "kk");
        System.out.println(jtHashMap03);
        for (int i = 10; i < 100; i++) {
            System.out.println(i + "......" + myHash(i, 16)); //12,28,44
        }
    }
}

实现get方法，根据键对象，获得相应的对象

public class JtHashMap04<K,V> {
    Node2[] Node2s; //位桶数组。buket array
    int size; //存放键值对的个数

    public JtHashMap04() {
        Node2s = new Node2[16]; //长度一般定义为2的整数倍
    }
    public V get(K key){
        int hash = myHash(key.hashCode(),Node2s.length);
        V value = null;
        if (Node2s[hash]!=null){
            Node2 temp = Node2s[hash];
            while (temp!= null){
                if (temp.key.equals(key)){  //如果相等，则说明找到了键值对，返回相应的value
                    value = (V) temp.value;
                    break;
                }else {
                    temp = temp.next;
                }
            }
        }
        return value;
    }

    public void put(K key, V value) {
        //如果要完善还需要考虑数组扩容的问题！

        Node2 newNode = new Node2();
        newNode.hash = myHash(key.hashCode(), Node2s.length);
        newNode.key = key;
        newNode.value = value;
        newNode.next = null;
        Node2 temp = Node2s[newNode.hash];
        Node2 iterLast = null; //正在遍历的最后一个元素
        boolean keyRepeat = false;
        if (temp == null) {
            //此处数组元素为空，则直接将新节点放进去。
            Node2s[newNode.hash] = newNode;
            size++;
        } else {
            //此处数组元素不为空，则遍历对应链表。
            while (temp != null) {
                //判断key如果重复则覆盖
                if (temp.key.equals(key)) {
                    keyRepeat = true;
                    System.out.println("key重复了！！！");
                    temp.value = value; //只是覆盖value，其他的值保持不变
                    break;
                } else {
                    //key不重复,则遍历下一个
                    iterLast = temp;
                    temp = temp.next;
                }
            }
            if (!keyRepeat) {//如果没有发生key重复的情况，则添加到链表最后。
                iterLast.next = newNode;
                size++;
            }
        }
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder("[");
        //遍历数组
        for (int i = 0; i < Node2s.length; i++) {
            Node2 temp = Node2s[i];
            //遍历链表
            while (temp != null) {
                stringBuilder.append(temp.key + ":" + temp.value + ",");
                temp = temp.next;
            }
        }
        stringBuilder.setCharAt(stringBuilder.length() - 1, ']');
        return stringBuilder.toString();
    }

    public static int myHash(int v, int length) {
//        System.out.println(v & (length - 1)); //直接位运算,效率较高
//        System.out.println((v % (length - 1)));//取模运算，效率较低
        return v & (length - 1);
    }

    public static void main(String[] args) {
        JtHashMap04<Integer,String> jtHashMap04 = new JtHashMap04();
        jtHashMap04.put(10, "aa");
        jtHashMap04.put(20, "bb");
        jtHashMap04.put(30, "cc");
        jtHashMap04.put(20, "ssss");
        jtHashMap04.put(12, "jj");
        jtHashMap04.put(28, "ll");
        jtHashMap04.put(44, "kk");
        System.out.println(jtHashMap04);
        System.out.println(jtHashMap04.get(20));
        System.out.println(jtHashMap04.size);
//        for (int i = 10; i < 100; i++) {
//            System.out.println(i + "......" + myHash(i, 16)); //12,28,44
//        }
    }
}