java 容器

1.集合和数组的区别

• 数组是固定长度的；集合可变长度的。

• 数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。

• 数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。

2.分类：

2：ArrayList 与LinkedList的区别：

1.底层数据结构不同，Arraylist底层数据结构是数组，而LinkedList底层数据结构是链表；

2.他们的底层数据结构不同，所以适用的场景也不同，ArrayList适合查找数据，而LinkList适合插入，删除数据等，但是具体情况也要具体对待；

3.他们都是继承list，但是LinkedList还继承了Qeque接口，所以还可以当做队列使用；

3：线程安全：

• Vector：就比Arraylist多了个 synchronized （线程安全），因为效率较低，现在已经不太建议使用。
• hashTable：就比hashMap多了个synchronized (线程安全)，

4： HashMap 的put方法（java1.8前后区别）

1.根据key判断是否为空

2.如果key为空，将key和value，封装为Entry放入该位置

3.如果不为空，就要分情况

a 如果是1.7，遍历，hash和key值是否相等，是更新原来的value值，不相等，先判断是否需要扩容，如果不需要就封装成Entry，使用头插法添加到当前位置的链表中 

1.7源码：

   public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);  //如果数组下标为空，将key和value，封装为Entry放入该位置
    int hash = hash(key);  
    int i = indexFor(hash, table.length);    //得到hashcode，也就是位置
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;  //存在只是更新原来的值
        }
    }
    modCount++;
    addEntry(hash, key, value, i); //不存在，先判断是否需要扩容，如果不需要就封装成Entry，使用头插法添加到当前位置的链表中
    return null;
}   
 

void addEntry(int hash, K key, V value, int bucketIndex) {
    // 判断是否需要扩容，条件是全部元素是否大于阀值，并且 table下标bucketIndex 不等于null
    if ((size >= threshold) && (null != table[bucketIndex])) {
        // 扩容大小是 2倍
        resize(2 * table.length);  //调用扩容方法
        // 扩容完成，当前插入元素的hash值以及对应的table下标都需要重新计算
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }
    // 采用头插法，插入元素
    createEntry(hash, key, value, bucketIndex);
}

b 如果是1.8，key计算数组索引值是否存在，空直接插入，不是，判断key是否为空，是更新原来的值，不存在则先判断该位置是红黑树类型还是链表类型，红黑树就直接插入，如果是链表，遍历链表，进行尾部插入，如果节点个数大于8，则将链表转换成红黑树结构最后 在判断是否需要扩容

1.8源码

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;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

5.迭代器 Iterator 是什么？

collection实现了Iterable接口，这个接口中有iterator方法，返回值是一个iterator接口

• Iterator 接口提供遍历任何 Collection 的接口。我们可以从一个 Collection 中使用迭代器方法来获取迭代器实例.
• 因为所有Collection接继承了Iterator迭代器

List<String> list = new ArrayList<>();

Iterator<String> it = list. iterator();

while(it. hasNext())

{

        String obj = it. next();

        System. out. println(obj);

}

• Iterator 可以遍历 Set 和 List 集合，而 ListIterator 只能遍历 List。
• Iterator 只能单向遍历，而 ListIterator 可以双向遍历（向前/后遍历）。
• ListIterator 实现 Iterator 接口，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。

6.如何边遍历边移除 Collection 中的元素？

• 边遍历边修改 Collection 的唯一正确方式是使用 Iterator.remove() 方法，如下：

  Iterator<Integer> it = list.iterator();
  while(it.hasNext()){
     *// do something*
     it.remove();
  }
  复制代码

一种最常见的错误代码如下：

for(Integer i : list){
   list.remove(i)
}
复制代码

• 运行以上错误代码会报 ConcurrentModificationException 异常。这是因为当使用 foreach(for(Integer i : list)) 语句时，会自动生成一个iterator 来遍历该 list，但同时该 list 正在被 Iterator.remove() 修改。Java 一般不允许一个线程在遍历 Collection 时另一个线程修改它。
• 可以在.next()方法之后删除；

7.hashCode（）与equals（）的相关规定：

1. 如果两个对象相等，则hashcode一定也是相同的
2. 两个对象有相同的hashcode值，它们也不一定是相等的
3. 综上，equals方法被覆盖过，则hashCode方法也必须被覆盖
4. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）。

==与equals的区别

1. ==是判断两个变量或实例是不是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是不是相同
2. ==是指对内存地址进行比较 equals()是对字符串的内容进行比较

8为什么重写 equals 方法一定要重写 hashCode 方法？官方说法是：对象的equals方法被重写，那么对象的hashCode()也尽量重写；（主要看应用场景）

1. equals 方法 和 hashCode 方法本身并没有紧密的联系，只是应用场景（如HashMap、HashSet等集合类的存取）使它们出现在了一起，才有了这句话；
2. 哈希集合（如HashMap）要保证元素唯一性。key对象放入集合，先经过hash运算，得到index，找到数组对应位置，还要和此位置的对象进行比较（先用hash比较，后用equals方法），不一样就插入到后面形成链表，一样的话就不用插入了。重写了equals()方法，但不重写hashcode()方法，那可能两个相同的对象放入到了不同的位置，元素的唯一性就不存在了。（HashMap存入键值对的方式要复杂的多，这里只是简要说下）