面试记录（oppo）

最新推荐文章于 2022-07-26 15:18:55 发布

LiquorSea

最新推荐文章于 2022-07-26 15:18:55 发布

阅读量1.5k

点赞数 1

分类专栏：面试总结

本文链接：https://blog.csdn.net/weixin_39506910/article/details/96295417

版权

面试总结专栏收录该内容

8 篇文章 0 订阅

订阅专栏

深圳oppo java一面（目测已挂）

Java集合

说说常见的集合有哪些吧？
Map 和 Collection 接口是所有接口的父接口，其中Collection的子接口有Set、List
Set的实现：HashSet、TreeSet、LinkedHashSet
Map的实现：HashMap、TreeMap、HashTable、CurrentHashMap
List的实现：ArrayList、LinkedList、Stack、Vector
HashMap的key能不能存自定义的对象？
可以存但是要重写hashCode和equals方法
BlockingQueue是什么？
Java.util.concurrent.BlockingQueue是一个队列。在检索或者移除一个元素的时候，它会等待队列变为非空；在添加一个元素的时候，他会等待队列中的可用空间。
主要用于生产者和消费者模型，我们不用等生产者有可用的空间，或者消费者有可用的对象，因为他都在BlockingQueue中处理了。
其实现类有ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue、SynchronousQuueue。
HashSet是如何保证数据不重复的?

public boolean add(E e) {
   return map.put(e, PRESENT)==null;// 调用HashMap的put方法,PRESENT是一个至始至终都相同的虚值
}

HashSet是用HashMap的key存储值，因为HashMap的key是不允许重复的，如果重复则会覆盖原有的key值。另外HashSet如果add相同的值，会返回false。

ArrayList和LinkedList的区别？
1、ArrayList动态数组，初试数组值为10，每次扩充1.5倍，采用重新申请空间然后再拷贝的方式进行扩充。适合随机访问，不适合插入和删除。
2、LinkedList采用双向链表的形式存储。不能随机访问，适合添加和删除操作。
Array 和 ArrayList 有什么区别？什么时候该应 Array 而不是 ArrayList 呢？
Array可以包含基本数据类型和对象类型，ArrayList只能包含对象类型。
ArrayList提供了更加全面的方法，并且支持动态扩展，而Array数组长度固定。
Vector与ArrayList相比，Verctor是线程安全的，并且每次扩充为原来的2倍。
HashMap的put方法流程?

/**
 * 该函数有2中使用情况：1.初始化哈希表；2.当前数组容量过小，需要扩容
 */
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;// 扩容前的数组（当前数组）
    int oldCap = (oldTab == null) ? 0 : oldTab.length;// 扩容前的数组容量（数组长度）
    int oldThr = threshold;// 扩容前数组的阈值
    int newCap, newThr = 0;

    if (oldCap > 0) {
        // 针对情况2：若扩容前的数组容量超过最大值，则不再扩容
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 针对情况2：若没有超过最大值，就扩容为原来的2倍（左移1位）
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }

    // 针对情况1：初始化哈希表（采用指定或者使用默认值的方式）
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }

    // 计算新的resize上限
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        // 把每一个bucket都移动到新的bucket中去
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}