1万的空间和100万差别很大

16和100万差别也很大，

在100万数据面前，16383的空间和16的并没有什么差别。

再加上重复运行相同代码，Java会对优化，可能会更快。

所以会造成16的比16384快的可能。

new Integer(value:1)

你反馈的这个其实是IDE下的显示，实际代码是new Integer(1)。

你好的

你的代码发了看看呗，我这边刚刚试是没问题的

LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。 

      按照语义来说，既然是最近最少使用的，肯定是最近最少使用的排在前面，最近最多使用的放在后面，所以使用过的放在后面。

    还有，链表的话，删除头部也要比删除尾部效率更高，因为删除尾部需要链表从头部遍历到要删除的节点。

    个人理解，如果错了，不要笑话哈。?

结点产生的链表长度超过8时， 就会自动转为红黑树。

这样做的目的是减少get查找的时间复杂度， 链表的查找时间复杂度为O(n), 红黑树的查找时间复杂度为O(logN)

那个是idea自动缩写了吧，你如果把鼠标移到~上面去，是可以展开的。展开的就是正常的泛型

可能是因为linkedHashMap输出时是按照输入的key顺序输出的，进行排序的这个过程在存入时进行，所以会比较慢吧。

实体类不适合作为key，实体类他存储的是引用地址，比较的时候也是引用地址，而不是对象的值，两次new出来的实体，虽然内容一样，但是地址不一样，会作为两个key来存储

创建hashmap对象时如果是无参创建，默认负载因子就是0.75。如果是有参的话，可以自定义大小及负载因子的配置。但是负载因子设置0.75为性能最优。如果要计算负载因子：存储数据的长度/创建hashmap的长度。

你要问的是计算实际使用长度吧？

如果使用默认长度是16，负载因子默认是0.75.那个可使用长度实际上为16*0.75的长度为12.

如果超过长度12就会自动扩容为原长度的2倍为长度32，给之前赋的值再进行hash计算，重新定位。

他实例化的时候是封装的 Integer，你说的 120 需要自动装箱。直接 new integer 省了一步直接实例化

你的理解有偏差, 跟是否产生hash碰撞没关系!! 

new HashMap(10000, 0.75f)这里的10000指的是map里存的key的数量, map里有个成员变量size来记录的, 不是代表数组大小! 

可以看HashMap的put方法的源码, 如果key已存在, 会替换对应的value, 否则size就会自增1. 

当size>容量*0.75时, 会进行扩容.

可以做个试验论证下:

HashMap<Integer, String> map = new HashMap<Integer, String>(8, 0.75f);
for (int i = 1; i <= 8; i++) {
    map.put(8 * i, "test");
}

设置容量为8, 每次put的都是8的倍数, 所以每次put都会产生hash碰撞, 但是仍然在put6次(8*0.75)之后进行了扩容!

HashMap的put源码:

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue; // 只有key存在的情况下, size才不会自增
        }
    }
    ++modCount;
    if (++size > threshold)// key不存在, size自增
        resize();
    afterNodeInsertion(evict);
    return null;
}

不会，老师讲的很明白了，如果不发生碰撞的话，是会扩容，照你的比如，key通过hash取址后只有10000（超过12288才会扩容），未达到16384*0.75=12288，所以是不会扩容的，这是我的理解，如果回答错误还望指正。

我是HashMap和LinkedHashMap分开写的，HashMap的赋值取值完毕了再去运行LinkedHashMap的，但是我的赋值是LinkedHashMap快，取值反而LinkedHashMap慢了