java学习_5_23

Collection接口中定义的方法如下，所有继承自Collection接口的接口(List,Set)的实现类均实现了这些方法。

List容器是有序、可重复的，常用的实现类：ArrayList,LinkedList,Vector（线程安全的）

带索引的add,remove操作。

---

自己实现的MyArrayList:

package test.stringTest;

public class MyArrayList<E> {
    private Object[] elementData;
    // 元素个数
    private int size;
    // 数组默认长度
    private final static int DEFAULT_CAPACITY = 10;

    public MyArrayList() {
        elementData = new Object[DEFAULT_CAPACITY];
    }

    public MyArrayList(int length) {
        if (length <= 0)
            throw new RuntimeException("容器容量值需为正整数:" + length);
        elementData = new Object[length];
    }

    public void add(E element) {
        if (size == elementData.length)
            grow();
        elementData[size++] = element;
    }

    @SuppressWarnings("unchecked")
    public E get(int index) {
        if (indexInRange(index))
            return (E) elementData[index];
        else
            throw new RuntimeException("索引越界:" + index);
    }

    public void remove(E element) {
        int index = -1;
        for (int i = 0; i < size; i++) {
            if (element.equals(elementData[i])) {
                index = i;
                break;
            }
        }
        if (index != -1) {
            remove(index);
        }
    }

    public void remove(int index) {
        if (!indexInRange(index)) {
            throw new RuntimeException("索引越界:" + index);
        }
        int numMoved = elementData.length - index - 1;
        if (numMoved > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, numMoved);
        } else {
            elementData[index] = null;
        }
        size--;
    }

    private boolean indexInRange(int index) {
        return index < size && index >= 0 ? true : false;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0 ? true : false;
    }

    // 数组扩容
    private void grow() {
        Object[] newArray = new Object[elementData.length + (elementData.length >> 1)];
        System.arraycopy(elementData, 0, newArray, 0, elementData.length);
        elementData = newArray;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < size; i++) {
            sb.append(elementData[i].toString() + ",");
        }
        sb.setCharAt(sb.length() - 1, ']');
        return sb.toString();
    }

    public static void main(String[] args) {
        MyArrayList<String> list = new MyArrayList<>(20);
        int i = 0;
        while (i <= 50) {
            list.add("aaa" + i);
            i++;
        }
        System.out.println(list);
        System.out.println(list.get(31));
        System.out.println(list.size());
        list.remove(21);
        list.remove("aaa4");
        System.out.println(list);
        System.out.println(list.size);
        System.out.println(list.isEmpty());
    }
}

---

HashMap底层实现：数组加链表（JDK8以后当元素个数超过8时，会转变为红黑树结构）。首先根据Key计算出hashcode,然后根据hashcode，利用hash算法计算出数组的下标，然后将值放入该下标数组存储的链表中（有重复（equals比较）的key值则覆盖） 两个相同的对象必须具有相同的hashcode。

    /**
     * The table, initialized on first use, and resized as
     * necessary. When allocated, length is always a power of two.
     * (We also tolerate length zero in some operations to allow
     * bootstrapping mechanics that are currently not needed.)
     */
    transient Node<K,V>[] table;

---

    /**
     * Basic hash bin node, used for most entries.  (See below for
     * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
     */
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
..........

---

自己实现的HashMap:

 package test.stringTest;

 public class MyHashMap<K,V> {
     Node<K,V>[] table; // 位桶数组
     int size;

     public MyHashMap() {
         table = new Node[16];
     }

     public void put(K key, V value) {
         Node<K,V> node = new Node<>();
         node.key = key;
         node.value = value;
         node.next = null;
         node.hash = myHash(key, table.length);
         Node<K,V> temp = table[node.hash];
         Node<K,V> lastNode = temp;
         boolean isOverride = false; // 有没被覆盖
         if (temp == null) {
             table[node.hash] = node;
             size++;
         } else {
             while (temp != null) {
                 // key相同 则覆盖
                 if (temp.key.equals(key)) {
                     temp.value = value;
                     isOverride = true;
                     break;
                 } else {
                     // 不同 则继续向下遍历
                     lastNode = temp;
                     temp = temp.next;
                 }
             }
             // 没有覆盖发生 则将Node添加到后面
             if (!isOverride) {
                 lastNode.next = node;
                 size++;
             }
         }
     }

     public Object get(Object key) {
         int hash = myHash(key, table.length);
         Node<K,V> temp = table[hash];
         if (temp != null) {
             while (temp != null) {
                 if (temp.key.equals(key))
                     return temp.value;
                 else
                     temp = temp.next;
             }
         }
         return null;
     }

     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder("{");
         for (int i = 0; i < table.length; i++) {
             Node<K,V> temp = table[i];
             while (temp != null) {
                 sb.append(temp.key + ":" + temp.value + ",");
                 temp = temp.next;
             }
         }
         sb.setCharAt(sb.length() - 1, '}');
         return sb.toString();
     }

     private int myHash(Object key, int length) {
         return key.hashCode() % length;
     }

     public static void main(String[] args) {
         MyHashMap<String,Integer> map = new MyHashMap<>();
         map.put("aaa", 111);
         map.put("bbb", 222);
         map.put("ccc", 333);
         map.put("ddd", 444);
         map.put("aae", 555);
         map.put("ccc", 666);
         map.put("rre", 777);
         map.put("aaa", 321);
         System.out.println(map.size);
         System.out.println(map.get("ccc"));
     }

 }

 class Node<K,V> {
     int hash;
     K key;
     V value;
     Node<K,V> next;
 }