• java集合题库详解

    1. Arraylist与LinkedList区别

    可以从它们的底层数据结构、效率、开销进行阐述哈

    ArrayList是数组的数据结构，LinkedList是链表的数据结构。

    随机访问的时候，ArrayList的效率比较高，因为LinkedList要移动指针，而ArrayList是基于索引(index)的数据结构，可以直接映射到。

    插入、删除数据时，LinkedList的效率比较高（指在插入的时候，不包括检索时间），因为ArrayList要移动数据（要扩容的时候才会）。

    LinkedList比ArrayList开销更大，因为LinkedList的节点除了存储数据，还需要存储引用。

    注意：插入、删除数据时，LinkedList的效率比较高，因为ArrayList要移动数据。这个说法并不是绝对的，因为ArrayList 是固定数组，只有在扩容的时候，才会出现移动数据的情况

    1.1、例子1

    查询因为LinkList 是链表，需要通过遍历找到索引，所以耗时比数组大，但是添加的时候，数组扩容带来的性能大于链表添加，因为添加到位置index 比较小，链表添加的时候

    1. public static long getTime(List<Integer> list) {
    2.         long startTime = System.currentTimeMillis();
    3.         for (int i = 0; i < 10000; i++) {
    4.             int index = Collections.binarySearch(list, list.get(i));
    5.             if (index != i) {
    6.                 System.out.println("ERROR!");
    7.             }
    8.         }
    9.         return System.currentTimeMillis() - startTime;
    10.     }
    11.  
    12.     //插入数据
    13.     public static long insertTime(List<Integer> list) {
    14.         /*
    15.          * 插入的数据量和插入的位置是决定两者性能的主要方面，
    16.          * 我们可以通过修改这两个数据，来测试两者的性能
    17.          */
    18.         long num = 100000; //表示要插入的数据量
    19.         int index = 10; //表示从哪个位置插入
    20.         long startTime = System.currentTimeMillis();
    21.         for (int i = 1; i < num; i++) {
    22.             list.add(index, i);
    23.         }
    24.         return System.currentTimeMillis() - startTime;
    25.  
    26.     }
    27.  
    28.     public static void main(String[] args) {
    29.  
    30.         //首先分别给两者插入10000条数据
    31.         for (int i = 0; i < 10000; i++) {
    32.             array.add(i);
    33.             linked.add(i);
    34.         }
    35.         //获得两者随机访问的时间
    36.         System.out.println("ArrayList查找元素耗时:" + getTime(array));
    37.         System.out.println("LinkedList查找元素耗时:" + getTime(linked));
    38.         //获得两者插入数据的时间
    39.         System.out.println("ArrayList 添加元素耗时:" + insertTime(array));
    40.         System.out.println("LinkedList添加元素耗时::" + insertTime(linked));
    41.  
    42.     }

    ArrayList查找元素耗时:4
    LinkedList查找元素耗时:299
    ArrayList 添加元素耗时:565
    LinkedList添加元素耗时::5

    1.2、例子2

    我们改变一下index为10000，结论链表遍历的损耗大于数组扩容，所以添加的时候，数组效率高于链表，删除也是一样的，如果在头部删除，链表大于数组，反之则数组大于链表

    1. public class Test {
    2.     static List<Integer> array = new ArrayList<Integer>();
    3.     static List<Integer> linked = new LinkedList<Integer>();
    4.  
    5.     public static long getTime(List<Integer> list) {
    6.         long startTime = System.currentTimeMillis();
    7.         for (int i = 0; i < 10000; i++) {
    8.             int index = Collections.binarySearch(list, list.get(i));
    9.             if (index != i) {
    10.                 System.out.println("ERROR!");
    11.             }
    12.         }
    13.         return System.currentTimeMillis() - startTime;
    14.     }
    15.  
    16.     //插入数据
    17.     public static long insertTime(List<Integer> list) {
    18.         /*
    19.          * 插入的数据量和插入的位置是决定两者性能的主要方面，
    20.          * 我们可以通过修改这两个数据，来测试两者的性能
    21.          */
    22.         long num = 100000; //表示要插入的数据量
    23.         int index = 10000; //表示从哪个位置插入
    24.         long startTime = System.currentTimeMillis();
    25.         for (int i = 1; i < num; i++) {
    26.             list.add(index, i);
    27.         }
    28.         return System.currentTimeMillis() - startTime;
    29.  
    30.     }
    31.  
    32.     public static void main(String[] args) {
    33.  
    34.         //首先分别给两者插入10000条数据
    35.         for (int i = 0; i < 10000; i++) {
    36.             array.add(i);
    37.             linked.add(i);
    38.         }
    39.         //获得两者随机访问的时间
    40.         System.out.println("ArrayList查找元素耗时:" + getTime(array));
    41.         System.out.println("LinkedList查找元素耗时:" + getTime(linked));
    42.         //获得两者插入数据的时间
    43.         System.out.println("ArrayList 添加元素耗时:" + insertTime(array));
    44.         System.out.println("LinkedList添加元素耗时::" + insertTime(linked));
    45.  
    46.     }
    47. }

    ArrayList查找元素耗时:5
    LinkedList查找元素耗时:317
    ArrayList 添加元素耗时:482
    LinkedList添加元素耗时::2036

    2. Collections.sort和Arrays.sort的实现原理

    Collection.sort是对list进行排序，Arrays.sort是对数组进行排序。

    2.1、Collections.sort底层实现

    Collections.sort方法调用了list.sort方法

    list.sort方法调用了Arrays.sort的方法

    Arrays.sort的方法，Arrays的sort方法底层就是：
    legacyMergeSort(a)，归并排序

    ComparableTimSort.sort()：即Timsort排序，排序是结合了合并排序（merge.sort）和插入排序（insertion sort）而得出的排序方法；

    3. HashMap原理，java8做了什么改变

    HashMap是以键值对存储数据的集合容器

    HashMap是非线性安全的。

    HashMap底层数据结构：数组+(链表、红黑树)，jdk8之前是用数组+链表的方式实现，jdk8引进了红黑树

    Hashmap数组的默认初始长度是16，key和value都允许null的存在

    HashMap的内部实现数组是Node[]数组，上面存放的是key-value键值对的节点。HashMap通过put和get方法存储和获取。

    HashMap的put方法，首先计算key的hashcode值，定位到对应的数组索引，然后再在该索引的单向链表上进行循环遍历，用equals比较key是否存在，如果存在则用新的value覆盖原值，如果没有则向后追加。

    jdk8中put方法：先判断Hashmap是否为空，为空就扩容，不为空计算出key的hash值i，然后看table[i]是否为空，为空就直接插入，不为空判断当前位置的key和table[i]是否相同，相同就覆盖，不相同就查看table[i]是否是红黑树节点，如果是的话就用红黑树直接插入键值对，如果不是开始遍历链表插入，如果遇到重复值就覆盖，否则直接插入，如果链表长度大于8，转为红黑树结构，执行完成后看size是否大于阈值threshold，大于就扩容，否则直接结束。

    Hashmap解决hash冲突，使用的是链地址法，即数组+链表的形式来解决。put执行首先判断table[i]位置，如果为空就直接插入，不为空判断和当前值是否相等，相等就覆盖，如果不相等的话，判断是否是红黑树节点，如果不是，就从table[i]位置开始遍历链表，相等覆盖，不相等插入。

    HashMap的get方法就是计算出要获取元素的hash值，去对应位置获取即可。

    HashMap的扩容机制，Hashmap的扩容中主要进行两步，第一步把数组长度变为原来的两倍，第二部把旧数组的元素重新计算hash插入到新数组中，jdk8时，不用重新计算hash，只用看看原来的hash值新增的一位是零还是1，如果是1这个元素在新数组中的位置，是原数组的位置加原数组长度，如果是零就插入到原数组中。扩容过程第二部一个非常重要的方法是transfer方法，采用头插法，把旧数组的元素插入到新数组中。

    HashMap大小为什么是2的幂次方？效率高+空间分布均匀

    4. List 和 Set，Map 的区别

    List 以索引来存取元素，有序的，元素是允许重复的，可以插入多个null。

    Set 不能存放重复元素，无序的，只允许一个null

    Map 保存键值对映射，映射关系可以一对一、多对一

    List 有基于数组、链表实现两种方式

    Set、Map 容器有基于哈希存储和红黑树两种方式实现

    Set 基于 Map 实现，Set 里的元素值就是 Map的键值

    5. poll()方法和 remove()方法的区别？

    Queue队列中，poll() 和 remove() 都是从队列中取出一个元素，在队列元素为空的情况下，remove() 方法会抛出异常，poll() 方法只会返回 null 。

    LinkList 实现了Queue 方法，remove代码

    1. public E remove() {
    2.         return removeFirst();
    3.     }
    4.  
    5.     
    6.  
    7. public E removeFirst() {
    8.         final Node f = first;
    9.         if (f == null)
    10.             throw new NoSuchElementException();
    11.         return unlinkFirst(f);
    12.     }

    LinkList 实现了Queue 方法，poll代码

    1. public E poll() {
    2.      final Node<E> f = first;
    3.      return (f == null) ? null : unlinkFirst(f);
    4. }

    6. HashMap，HashTable，ConcurrentHash的共同点和区别

    HashMap

    底层由链表+数组+红黑树实现

    可以存储null键和null值

    线性不安全

    初始容量为16，扩容每次都是2的n次幂

    加载因子为0.75，当Map中元素总数超过Entry数组的0.75，触发扩容操作.

    并发情况下，HashMap进行put操作会引起死循环，导致CPU利用率接近100%

    HashMap是对Map接口的实现

    HashTable

    HashTable的底层也是由链表+数组+红黑树实现。

    无论key还是value都不能为null

    它是线性安全的，使用了synchronized关键字。

    HashTable实现了Map接口和Dictionary抽象类

    Hashtable初始容量为11

    ConcurrentHashMap

    ConcurrentHashMap的底层是数组+链表+红黑树

    不能存储null键和值

    ConcurrentHashMap是线程安全的

    ConcurrentHashMap使用锁分段技术确保线性安全

    JDK8为何又放弃分段锁，是因为多个分段锁浪费内存空间，竞争同一个锁的概率非常小，分段锁反而会造成效率低。

    7. 写一段代码在遍历 ArrayList 时移除一个元素

    因为foreach删除会导致快速失败问题，fori顺序遍历会导致重复元素没删除，所以正确解法如下：

    第一种遍历，倒叙遍历删除

    1. for(int i=list.size()-1; i>-1; i--){ 
    2.  if(list.get(i).equals("jay")){   
    3.     list.remove(list.get(i)); 
    4.  }
    5. }

    第二种，迭代器删除

    1. Iterator itr = list.iterator();
    2. while(itr.hasNext()) {      
    3.     if(itr.next().equals("jay") {      
    4.       itr.remove();      
    5.     }
    6. }

     8. Java中怎么打印数组？

    数组是不能直接打印的哈，如下:

    1. public class Test {    
    2.     public static void main(String[] args) {      
    3.         String[] jayArray = {"jay", "boy"};        
    4.         System.out.println(jayArray);    
    5.     }
    6. }
    7. //output[Ljava.lang.String;@1540e19d

    打印数组可以用流的方式Strem.of().foreach()，如下:

    1. public class Test {    
    2.     public static void main(String[] args) {        
    3.       String[] jayArray = {"jay", "boy"};        
    4.       Stream.of(jayArray).forEach(System.out::println);    
    5.     }
    6. }
    7. //outputjayboy

    打印数组，最优雅的方式可以用这个APi,Arrays.toString()

    1. public class Test {    
    2.      public static void main(String[] args) {        
    3.          String[] jayArray = {"jay", "boy"};        
    4.          System.out.println(Arrays.toString(jayArray));    
    5.     }
    6. }
    7. //output[jay, boy]

    9. TreeMap底层？

    TreeMap实现了SotredMap接口，它是有序的集合。

    TreeMap底层数据结构是一个红黑树，每个key-value都作为一个红黑树的节点。

    如果在调用TreeMap的构造函数时没有指定比较器，则根据key执行自然排序。

    10. HashMap 的扩容过程

    Hashmap的扩容：

    第一步把数组长度变为原来的两倍，

    第二步把旧数组的元素重新计算hash插入到新数组中。

    jdk8时，不用重新计算hash，只用看看原来的hash值新增的一位是零还是1，如果是1这个元素在新数组中的位置，是原数组的位置加原数组长度，如果是零就插入到原数组中。扩容过程第二步一个非常重要的方法是transfer方法，采用头插法，把旧数组的元素插入到新数组中。

    11. HashSet是如何保证不重复的

    可以看一下HashSet的add方法，元素E作为HashMap的key，我们都知道HashMap的可以是不允许重复的，哈哈。

    1.  public boolean add(E e) {    
    2.     return map.put(e, PRESENT)==null;
    3. }

    12. HashMap 是线程安全的吗

    不是线性安全的，并发的情况下，扩容可能导致死循环问题。

    13. LinkedHashMap的应用，底层，原理

    LinkedHashMap维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序（insert-order）或者是访问顺序，其中默认的迭代访问顺序就是插入顺序，即可以按插入的顺序遍历元素，这点和HashMap有很大的不同。

    LRU算法可以用LinkedHashMap实现。

    14 哪些集合类是线程安全的？哪些不安全？

    线性安全的

    Vector：比Arraylist多了个同步化机制。

    Hashtable：比Hashmap多了个线程安全。

    ConcurrentHashMap:是一种高效但是线程安全的集合。

    Stack：栈，也是线程安全的，继承于Vector。

    线性不安全的

    Hashmap

    Arraylist

    LinkedList

    HashSet

    TreeSet

    TreeMap

    15. ArrayList 和 Vector 的区别是什么？

    Vector是线程安全的，ArrayList不是线程安全的。
    ArrayList在底层数组不够用时在原来的基础上扩展0.5倍，Vector是扩展1倍。
    Vector只要是关键性的操作，方法前面都加了synchronized关键字，来保证线程的安全性。

    16 Collection与Collections的区别是什么？

    Collection是Java集合框架中的基本接口，如List接口也是继承于它

    1. public interface List extends Collection {
    2.    Collections是Java集合框架提供的一个工具类，其中包含了大量用于操作或返回集合的静态方法。如下：
    3.  
    4. public static extends Comparablesuper T>> void sort(List list) {    
    5.       list.sort(null);
    6. }

    17. 如何决定使用 HashMap 还是TreeMap？

    这个点，主要考察HashMap和TreeMap的区别。

    TreeMap实现SortMap接口，能够把它保存的记录根据键排序，默认是按key的升序排序，也可以指定排序的比较器。当用Iterator遍历TreeMap时，得到的记录是排过序的。

    18. 如何实现数组和 List之间的转换？

    18.1、List 转 Array

    必须使用集合的 toArray(T[] array)，如下：

    1. List<String> list = new ArrayList<String>();
    2. list.add("jay");
    3. list.add("tianluo");
    4. // 使用泛型，无需显式类型转换
    5. String[] array = list.toArray(new String[list.size()]);
    6. System.out.println(array[0]);

    如果直接使用 toArray 无参方法，返回值只能是 Object[] 类，强转其他类型可能有问题，demo如下：

    1. List<String> list = new ArrayList<String>();
    2. list.add("jay");
    3. list.add("tianluo");
    4. String[] array = (String[]) list.toArray();
    5. System.out.println(array[0]);

    运行结果：

    Exception in thread "main" java.lang.ClassCastException: 
[Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
at Test.main(Test.java:14)

    18.2、Array 转List

    使用Arrays.asList() 把数组转换成集合时，不能使用修改集合相关的方法啦，如下：

    1. String[] str = new String[] { "jay", "tianluo" };
    2. List list = Arrays.asList(str);
    3. list.add("boy");

    运行结果如下：

    1. Exception in thread "main" java.lang.UnsupportedOperationException	
    2. at java.util.AbstractList.add(AbstractList.java:148)	
    3. at java.util.AbstractList.add(AbstractList.java:108)	
    4. at Test.main(Test.java:13)

    因为 Arrays.asList不是返回java.util.ArrayList,而是一个内部类ArrayList。可以这样使用弥补这个缺点：

    1. //方式一：
    2. ArrayList< String> arrayList = new ArrayList<String>(strArray.length);
    3. Collections.addAll(arrayList, strArray);
    4. //方式二：ArrayList<String> list = new ArrayList<String>(Arrays.asList(strArray));

    19、迭代器 Iterator 是什么？

    1. public interface Collection<E> extends Iterable<E> {
    2. ​​​​​​​  Iterator<E> iterator();
    3. }

    方法如下：next() 方法获得集合中的下一个元素hasNext() 检查集合中是否还有元素remove() 方法将迭代器新返回的元素删除forEachRemaining(Consumer action) 方法，遍历所有元素

    Iterator 主要是用来遍历集合用的，它的特点是更加安全，因为它可以确保，在当前遍历的集合元素被更改的时候，就会抛出 ConcurrentModificationException 异常。

    使用demo如下：

    1. List<String> list = new ArrayList<>();
    2. Iterator<String> it = list.iterator();
    3. while(it.hasNext()){  
    4.     String obj = it. next();  
    5.     System. out. println(obj);
    6. }

    20. Iterator 和 ListIterator 有什么区别？

    ListIterator 比 Iterator有更多的方法。

    ListIterator只能用于遍历List及其子类，Iterator可用来遍历所有集合

    ListIterator遍历可以是逆向的，因为有previous()和hasPrevious()方法，而Iterator不可以。

    ListIterator有add()方法，可以向List添加对象，而Iterator却不能。

    ListIterator可以定位当前的索引位置，因为有nextIndex()和previousIndex()方法，而Iterator不可以。

    ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改哦。

    21. 怎么确保一个集合不能被修改？

    很多朋友很可能想到用final关键字进行修饰，final修饰的这个成员变量，如果是基本数据类型，表示这个变量的值是不可改变的，如果是引用类型，则表示这个引用的地址值是不能改变的，但是这个引用所指向的对象里面的内容还是可以改变滴~验证一下，如下：

    1. public class Test {    
    2.    //final 修饰    
    3.   private static final Map<Integer, String> map = new HashMap<Integer, String>(); 
    4.   {       
    5.      map.put(1, "jay");        
    6.      map.put(2, "tianluo");    
    7. }    
    8.  
    9. public static void main(String[] args) {       
    10.     map.put(1, "boy");        
    11.     System.out.println(map.get(1));    
    12. }
    13.  
    14. }

    运行结果可以洗发现，final修饰，集合还是会被修改呢boy，嘻嘻，那么，到底怎么确保一个集合不能被修改呢，看以下这三哥们~

    unmodifiableMap

    unmodifiableList

    unmodifiableSet

    再看一下demo吧

    1. public class Test {   
    2.  
    3.      private static  Map<Integer, String> map = new HashMap<Integer, String>();    
    4.      {        
    5.          map.put(1, "jay");        
    6.          map.put(2, "tianluo");    
    7.       }   
    8.  
    9.       public static void main(String[] args) {       
    10.           map = Collections.unmodifiableMap(map);        
    11.           map.put(1, "boy");        
    12.           System.out.println(map.get(1));    
    13.       }
    14. }

    运行结果：可以发现，unmodifiableMap确保集合不能修改啦，抛异常了

    1. Exception in thread "main" java.lang.UnsupportedOperationException 
    2. at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)
    3. ​​​​​​​at Test.main(Test.java:14)

    22. 快速失败(fail-fast)和安全失败(fail-safe)的区别是什么？

    快速失败

    在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。

    1. public class Test {    
    2.     public static void main(String[] args) {      
    3.         List<Integer> list = new ArrayList<>();        
    4.         list.add(1);        
    5.         list.add(2);        
    6.         Iterator iterator = list.iterator();        
    7.         while (iterator.hasNext()) {            
    8.              System.out.println(iterator.next());            
    9.              list.add(3);            
    10.              System.out.println(list.size());        
    11.        }    
    12.    }
    13. }

    运行结果：

    1. 1Exception in thread "main" java.util.ConcurrentModificationException3	
    2. at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)	
    3. at java.util.ArrayList$Itr.next(ArrayList.java:859)	at Test.main(Test.java:12)

    安全失败

    采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。

    1. public class Test {    
    2.     public static void main(String[] args) {        
    3.         List<Integer> list = new CopyOnWriteArrayList<>();        
    4.         list.add(1);        
    5.         list.add(2);       
    6.         Iterator iterator = list.iterator();       
    7.         while (iterator.hasNext()) {            
    8.               System.out.println(iterator.next());           
    9.               list.add(3);            
    10.               System.out.println("list size:"+list.size());       
    11.        }    
    12.   }
    13. }

    运行结果：

    list size:3

    list size:4

    23. 什么是Java优先级队列(Priority Queue)？

    优先队列PriorityQueue是Queue接口的实现，可以对其中元素进行排序

    • 优先队列中元素默认排列顺序是升序排列

    • 但对于自己定义的类来说，需要自己定义比较器

    public class PriorityQueue extends AbstractQueue    implements java.io.Serializable {    ...     private final Comparator comparator;

    方法：

    peek()//返回队首元素poll()//返回队首元素，队首元素出队列add()//添加元素size()//返回队列元素个数isEmpty()//判断队列是否为空，为空返回true,不空返回false

    特点：

    • 1.基于优先级堆

    • 2.不允许null值

    • 3.线程不安全

    • 4.出入队时间复杂度O(log(n))

    • 5.调用remove()返回堆内最小值

    24. JAVA8的ConcurrentHashMap为什么放弃了分段锁

    jdk8 放弃了分段锁而是用了Node锁，减低锁的粒度，提高性能，并使用CAS操作来确保Node的一些操作的原子性，取代了锁。

    可以跟面试官聊聊悲观锁和CAS乐观锁的区别，优缺点哈~

    25. 阻塞队列的实现，ArrayBlockingQueue的底层实现？

    ArrayBlockingQueue是数组实现的线程安全的有界的阻塞队列，继承自AbstractBlockingQueue,间接的实现了Queue接口和Collection接口。底层以数组的形式保存数据(实际上可看作一个循环数组)。常用的操作包括 add ,offer,put，remove,poll,take,peek。

    可以结合线程池跟面试官讲一下哦~

    26. Java 中的 LinkedList是单向链表还是双向链表？​​​​​​​

    1.    private static class Node<E> {        
    2.        E item;        
    3.        Node<E> next;       
    4.        Node<E> prev;        
    5.        Node(Node<E> prev, E element, Node<E> next) {           
    6.           this.item = element;            
    7.           this.next = next;            
    8.           this.prev = prev;        
    9.       }   
    10.  }

    27. 说一说ArrayList 的扩容机制吧

    ArrayList扩容的本质就是计算出新的扩容数组的size后实例化，并将原有数组内容复制到新数组中去。

    1. public boolean add(E e) {     
    2.     //扩容   
    3.     ensureCapacityInternal(size + 1);  
    4.     // Increments modCount!!    
    5.     elementData[size++] = e;    
    6.     return true;    
    7. }  
    8.  
    9. private void ensureCapacityInternal(int minCapacity) {     
    10.     ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    11. }
    12.  
    13. private static int calculateCapacity(Object[] elementData, int minCapacity) {        
    14.     //如果传入的是个空数组则最小容量取默认容量与minCapacity之间的最大值        
    15.    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {            
    16.        return Math.max(DEFAULT_CAPACITY, minCapacity);        
    17.     }        
    18.     return minCapacity;    
    19. }      
    20.  
    21. private void ensureExplicitCapacity(int minCapacity) {        
    22.      modCount++;        
    23.      // 如果最小需要空间比elementData的内存空间要大，则需要扩容        
    24.     // overflow-conscious code        
    25.     if (minCapacity - elementData.length > 0)            
    26.        grow(minCapacity);   
    27.      }    
    28. }
    29.        
    30. private void grow(int minCapacity) {        
    31.     // 获取elementData数组的内存空间长度        
    32.     int oldCapacity = elementData.length;        
    33.      // 扩容至原来的1.5倍        
    34.      int newCapacity = oldCapacity + (oldCapacity >> 1);        
    35.     //校验容量是否够        
    36.     if (newCapacity - minCapacity < 0)            
    37.     newCapacity = minCapacity;        
    38.     //若预设值大于默认的最大值，检查是否溢出        
    39.     if (newCapacity - MAX_ARRAY_SIZE > 0)            
    40.     newCapacity = hugeCapacity(minCapacity);        
    41.     // 调用Arrays.copyOf方法将elementData数组指向新的内存空间         
    42.     //并将elementData的数据复制到新的内存空间        
    43.     elementData = Arrays.copyOf(elementData, newCapacity);    
    44. }

    28. HashMap 的长度为什么是2的幂次方，以及其他常量定义的含义~

    为了能让HashMap存取高效，数据分配均匀。（如果不是2的幂次方，比如5，就不能运用位运算 比如低位000,001,011,100,101，运用位运算，会导致分布不均匀，只有运用求余数）

    看着呢，以下等式相等，但是位移运算比取余效率高很多呢~

    hash%length=hash&(length-1)

    29. ConcurrenHashMap 原理？1.8 中为什么要用红黑树？

    聊到ConcurrenHashMap，需要跟面试官聊到安全性，分段锁segment，为什么放弃了分段锁，与及选择CAS，其实就是都是从效率和安全性触发，java8不是用红黑树来管理hashmap,而是在hash值相同的情况下(且重复数量大于8),用红黑树来管理数据。红黑树相当于排序数据。可以自动的使用二分法进行定位。性能较高。

    30. ArrayList的默认大小

    ArrayList 的默认大小是 10 个元素

    1. /**  * Default initial capacity.  */
    2. private static final int DEFAULT_CAPACITY = 10;

    31. 为何Collection不从Cloneable和Serializable接口继承？

    Collection表示一个集合，包含了一组对象元素。如何维护它的元素对象是由具体实现来决定的。因为集合的具体形式多种多样，例如list允许重复，set则不允许。而克隆（clone）和序列化（serializable）只对于具体的实体，对象有意义，你不能说去把一个接口，抽象类克隆，序列化甚至反序列化。所以具体的collection实现类是否可以克隆，是否可以序列化应该由其自身决定，而不能由其超类强行赋予。

    如果collection继承了clone和serializable，那么所有的集合实现都会实现这两个接口，而如果某个实现它不需要被克隆，甚至不允许它序列化（序列化有风险），那么就与collection矛盾了。

    32. Enumeration和Iterator接口的区别？

    public interface Enumeration {    boolean hasMoreElements();    E nextElement();}public interface Iterator {    boolean hasNext();    E next();    void remove();}

    • 函数接口不同

    • Enumeration速度快，占用内存少，但是不是快速失败的，线程不安全。

    • Iterator允许删除底层数据，枚举不允许

    • Iterator安全性高，因为其他线程不能够修改正在被Iterator遍历的集合里面的对象。

    33. 我们如何对一组对象进行排序？

    可以用 Collections.sort（）+ Comparator.comparing（），因为对对象排序，实际上是对对象的属性排序哈~

    public class Student {    private String name;    private int score;    public Student(String name, int score){        this.name = name;        this.score = score;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getScore() {        return score;    }    public void setScore(int score) {        this.score = score;    }    @Override    public String toString() {        return "Student: " + this.name + " 分数：" + Integer.toString( this.score );    }}public class Test {    public static void main(String[] args) {        List studentList = new ArrayList<>();        studentList.add(new Student("D", 90));        studentList.add(new Student("C", 100));        studentList.add(new Student("B", 95));        studentList.add(new Student("A", 95));        Collections.sort(studentList, Comparator.comparing(Student::getScore).reversed().thenComparing(Student::getName));        studentList.stream().forEach(p -> System.out.println(p.toString()));    }}

    34. 当一个集合被作为参数传递给一个函数时，如何才可以确保函数不能修改它？

    这个跟之前那个不可变集合一样道理哈~

    在作为参数传递之前，使用Collections.unmodifiableCollection(Collection c)方法创建一个只读集合，这将确保改变集合的任何操作都会抛出UnsupportedOperationException。

    35. 说一下HashSet的实现原理？

    • 不能保证元素的排列顺序，顺序有可能发生变化。

    • 元素可以为null

    • hashset保证元素不重复~ （这个面试官很可能会问什么原理，这个跟HashMap有关的哦）

    • HashSet，需要谈谈它俩hashcode()和equles()哦~

    • 实际是基于HashMap实现的，HashSet 底层使用HashMap来保存所有元素的

    看看它的add方法吧~

        public boolean add(E e) {        return map.put(e, PRESENT)==null;    }

    36. Array 和 ArrayList 有何区别？

    • 定义一个 Array 时，必须指定数组的数据类型及数组长度，即数组中存放的元素个数固定并且类型相同。

    • ArrayList 是动态数组，长度动态可变，会自动扩容。不使用泛型的时候，可以添加不同类型元素。

    37. 为什么HashMap中String、Integer这样的包装类适合作为key？

    String、Integer等包装类的特性能够保证Hash值的不可更改性和计算准确性，能够有效的减少Hash碰撞的几率~

    因为

    • 它们都是final修饰的类，不可变性，保证key的不可更改性，不会存在获取hash值不同的情况~

    • 它们内部已重写了equals()、hashCode()等方法，遵守了HashMap内部的规范

    38. 如果想用Object作为hashMap的Key？

    重写hashCode()和equals()方法啦~ (这个答案来自互联网哈~)

    重写hashCode()是因为需要计算存储数据的存储位置，需要注意不要试图从散列码计算中排除掉一个对象的关键部分来提高性能，这样虽然能更快但可能会导致更多的Hash碰撞；

    重写equals()方法，需要遵守自反性、对称性、传递性、一致性以及对于任何非null的引用值x，x.equals(null)必须返回false的这几个特性，目的是为了保证key在哈希表中的唯一性；

    39. 讲讲红黑树的特点？

    每个节点或者是黑色，或者是红色。

    根节点是黑色。

    每个叶子节点（NIL）是黑色。[注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]

    如果一个节点是红色的，则它的子节点必须是黑色的。

    从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

    40. Java集合类框架的最佳实践有哪些？

    其实这些点，结合平时工作，代码总结讲出来，更容易吸引到面试官呢 (这个答案来自互联网哈~)

    1.根据应用需要正确选择要使用的集合类型对性能非常重要，比如：假如知道元素的大小是固定的，那么选用Array类型而不是ArrayList类型更为合适。

    2.有些集合类型允许指定初始容量。因此，如果我们能估计出存储的元素的数目，我们可以指定初始容量来避免重新计算hash值或者扩容等。

    3.为了类型安全、可读性和健壮性等原因总是要使用泛型。同时，使用泛型还可以避免运行时的ClassCastException。

    4.使用JDK提供的不变类(immutable class)作为Map的键可以避免为我们自己的类实现hashCode()和equals()方法。

    5.编程的时候接口优于实现

    6.底层的集合实际上是空的情况下，返回为长度是0的集合或数组而不是null。

    41.谈谈线程池阻塞队列吧~

    ArrayBlockingQueue

    LinkedBlockingQueue

    DelayQueue

    PriorityBlockingQueue

    SynchronousQueue

    ArrayBlockingQueue： （有界队列）是一个用数组实现的有界阻塞队列，按FIFO排序量。

    LinkedBlockingQueue： （可设置容量队列）基于链表结构的阻塞队列，按FIFO排序任务，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE，吞吐量通常要高于ArrayBlockingQuene；newFixedThreadPool线程池使用了这个队列

    DelayQueue：（延迟队列）是一个任务定时周期的延迟执行的队列。根据指定的执行时间从小到大排序，否则根据插入到队列的先后排序。newScheduledThreadPool线程池使用了这个队列。

    PriorityBlockingQueue：（优先级队列）是具有优先级的无界阻塞队列；

    SynchronousQueue：（同步队列）一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQuene，newCachedThreadPool线程池使用了这个队列。针对面试题：线程池都有哪几种工作队列？

    我觉得，回答以上几种ArrayBlockingQueue，LinkedBlockingQueue，SynchronousQueue等，说出它们的特点，并结合使用到对应队列的常用线程池(如newFixedThreadPool线程池使用LinkedBlockingQueue)，进行展开阐述， 就可以啦。

    42. HashSet和TreeSet有什么区别？

    Hashset 的底层是由哈希表实现的，Treeset 底层是由红黑树实现的。

    HashSet中的元素没有顺序，TreeSet保存的元素有顺序性（实现Comparable接口）

    HashSet的add()，remove()，contains()方法的时间复杂度是O(1);TreeSet中，add()，remove()，contains()方法的时间复杂度是O(logn)

    43. Set里的元素是不能重复的

    那么用什么方法来区分重复与否呢? 是用==还是equals()?

    元素重复与否是使用equals()方法进行判断的，这个可以跟面试官说说==和equals()的区别，hashcode()和equals

    44. 说出ArrayList,LinkedList的存储性能和特性​​​​​​​

    ArrayList,使用数组方式存储数据，查询时，ArrayList是基于索引(index)的数据结构，可以直接映射到，速度较快；但是插入数据需要移动数据，效率就比LinkedList慢一点~ (看插入的位置)

    LinkedList,使用双向链表实现存储,按索引数据需要进行前向或后向遍历，查询相对ArrayList慢一点；但是插入数据速度较快。(看插入的位置)

    LinkedList比ArrayList开销更大，因为LinkedList的节点除了存储数据，还需要存储引用。

    45. HashMap在JDK1.7和JDK1.8中有哪些不同？

    46. ArrayList集合加入1万条数据，应该怎么提高效率

    因为ArrayList的底层是数组实现,并且数组的默认值是10,如果插入10000条要不断的扩容,耗费时间,所以我们调用ArrayList的指定容量的构造器方法ArrayList(int size) 就可以实现不扩容,就提高了性能。

    47. 如何对Object的list排序

    看例子吧，哈哈，这个跟对象排序也是一样的呢~

    1. public class Person {   
    2.     private String name;    
    3.     private Integer age;    
    4.     
    5.     public String getName() {        
    6.         return name;    
    7.     }    
    8.  
    9.     public void setName(String name) {        
    10.         this.name = name;    
    11.     }    
    12.  
    13.     public Integer getAge() {        
    14.         return age;    
    15.     }    
    16.  
    17.     public void setAge(Integer age) {        
    18.         this.age = age;    
    19.     }    
    20.     
    21.     public Person(String name, Integer age) {        
    22.         this.name = name;        
    23.         this.age = age;    
    24.     }
    25. }
    26.  
    27.  
    28. public class Test {    
    29.     public static void main(String[] args) {        
    30.         List<Person> list = new ArrayList<>();        
    31.         list.add(new Person("jay", 18));        
    32.         list.add(new Person("tianLuo", 10));        
    33.         list.stream().forEach(p -> System.out.println(p.getName()+" "+p.getAge()));        
    34.         // 用comparing比较对象属性        
    35.         list.sort(Comparator.comparing(Person::getAge));        
    36.         System.out.println("排序后");        
    37.         list.stream().forEach(p -> System.out.print(p.getName()+" "+p.getAge()+" 
    38.         "));    
    39.     }
    40. }

    48. ArrayList 和 HashMap 的默认大小是多数？

    在 Java 7 中，ArrayList 的默认大小是 10 个元素，HashMap 的默认大小是16个元素（必须是2的幂）。

    49. 有没有有顺序的Map实现类，如果有，他们是怎么保证有序的

    Hashmap和Hashtable 都不是有序的。

    TreeMap和LinkedHashmap都是有序的。（TreeMap默认是key升序，LinkedHashmap默认是数据插入顺序）

    TreeMap是基于比较器Comparator来实现有序的。

    LinkedHashmap是基于链表来实现数据插入有序的

    50. HashMap是怎么解决哈希冲突的

    Hashmap解决hash冲突，使用的是链地址法，即数组+链表的形式来解决。put执行首先判断table[i]位置，如果为空就直接插入，不为空判断和当前值是否相等，相等就覆盖，如果不相等的话，判断是否是红黑树节点，如果不是，就从table[i]位置开始遍历链表，相等覆盖，不相等插入。

  • 相关阅读:
    【LeetCode】813. 最大平均值和的分组
    腾讯云幻兽帕鲁游戏存档迁移教程，本地单人房迁移/四人世界怎么迁移存档？
    浮点型数据在内存中是如何存储的
    如何快速学习AdsPower RPA（2）——中级、高级部分
    title标签和meta标签怎样设置？有什么含义？
    linux如何使 CPU使用率 保持在指定百分比？
    RK3566调试eeprom
    DDD领域驱动设计-实体
    如何获取淘宝/天猫商品历史价格信息的API接口
    c语言字符串函数下：strcmp、strncpy、strncat、strncmp、strstr、strtok、strerror
  • 原文地址：https://blog.csdn.net/chuige2013/article/details/136523967