21道Java基础面试题及答案

超、凢脫俗 2022-03-15 01:18 375阅读 0赞

### **1. 八种基本数据类型的大小，以及他们的封装类。** ###

（1）八种基本数据类型和封装类

![v2-3be5a521b36db1f7851dbccefd26fe24_hd.jpg][]

（2）自动装箱和自动拆箱

**什么是自动装箱拆箱**

基本数据类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。

一般我们要创建一个类的对象实例的时候，我们会这样：

Class a = new Class(parameter);

当我们创建一个Integer对象时，却可以这样：

Integer i = 100; (注意：不是 int i = 100; )

实际上，执行上面那句代码的时候，系统为我们执行了：Integer i = Integer.valueOf(100);

此即基本数据类型的自动装箱功能。

**基本数据类型与对象的差别**

基本数据类型不是对象，也就是使用int、double、boolean等定义的变量、常量。

基本数据类型没有可调用的方法。

eg： int t = 1； t. 后面是没有方法滴。

Integer t =1； t. 后面就有很多方法可让你调用了。

**什么时候自动装箱**

例如：Integer i = 100;

相当于编译器自动为您作以下的语法编译：Integer i = Integer.valueOf(100);

**什么时候自动拆箱**

自动拆箱(unboxing)，也就是将对象中的基本数据从对象中自动取出。如下可实现自动拆箱：

Integer i = 10; //装箱 
    int t = i; //拆箱，实际上执行了 int t = i.intValue();

在进行运算时，也可以进行拆箱。

Integer i = 10; 
    System.out.println(i++);

**Integer的自动装箱**

//在-128~127 之外的数
     Integer i1 =200;  
     Integer i2 =200;          
     System.out.println("i1==i2: "+(i1==i2));                   
     // 在-128~127 之内的数
     Integer i3 =100;  
     Integer i4 =100;  
     System.out.println("i3==i4: "+(i3==i4));

**输出的结果是：**

i1==i2: false  
i3==i4: true

说明：

equals() 比较的是两个对象的值（内容）是否相同。

"==" 比较的是两个对象的引用（内存地址）是否相同，也用来比较两个基本数据类型的变量值是否相等。

前面说过，int 的自动装箱，是系统执行了 Integer.valueOf(int i)，先看看Integer.java的源码：

public static Integer valueOf(int i) {
       if(i >= -128 && i <= IntegerCache.high) // 没有设置的话，IngegerCache.high 默认是127
           return IntegerCache.cache[i + 128];
       else
           return new Integer(i);
    }

对于–128到127（默认是127）之间的值，Integer.valueOf(int i) 返回的是**缓存的Integer对象！！！**（并不是新建对象）

**所以范例中，i3 与 i4实际上是指向同一个对象。**

而其他值，执行Integer.valueOf(int i) 返回的是一个新建的 Integer对象，所以范例中，i1与i2 指向的是不同的对象。

当然，当不使用自动装箱功能的时候，情况与普通类对象一样，请看下例：

Integer i3 =new Integer(100); 
    Integer i4 =new Integer(100); 
    System.out.println("i3==i4: "+(i3==i4));//显示false

### **2. Switch能否用string做参数？** ###

答案：在 [Java][] 7之前，switch 只能支持 byte、short、char、int或者其对应的封装类以及 Enum 类型。在 [Java][] 7中，String支持被加上了。

### **3. equals与==的区别。** ###

答案：equals是逻辑相等，==完全是对象是否是同一个（地址相等）。

### **4. Object有哪些公用方法？** ###

**（1）clone**

保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常

**（2）equals**

在Object中与==是一样的，子类一般需要重写该方法

**（3）hashCode**

该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到

**（4）getClass**

final方法，获得运行时类型

**（5）wait**

使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。

调用该方法后当前线程进入睡眠状态，直到以下事件发生：   
1. 其他线程调用了该对象的notify方法   
2. 其他线程调用了该对象的notifyAll方法   
3. 其他线程调用了interrupt中断该线程   
4. 时间间隔到了   
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常

**（6）notify**

唤醒在该对象上等待的某个线程

**（7）notifyAll**

唤醒在该对象上等待的所有线程

**（8）toString**

转换成字符串，一般子类都有重写，否则打印句柄

### **5. Java的四种引用，强弱软虚，用到的场景。** ###

**（1）强引用（StrongReference）**  
强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。

如下：

Object o=new Object();   //  强引用

当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。如果不使用时，要通过如下方式来弱化引用，如下：

o=null;     // 帮助垃圾收集器回收此对象

显式地设置o为null，或超出对象的生命周期范围，则gc认为该对象不存在引用，这时就可以回收这个对象。具体什么时候收集这要取决于gc的算法。

举例：

public void test(){
       Object o=new Object();
       // 省略其他操作
    }

在一个方法的内部有一个强引用，这个引用保存在栈中，而真正的引用内容（Object）保存在堆中。当这个方法运行完成后就会退出方法栈，则引用内容的引用不存在，这个Object会被回收。

但是如果这个o是全局的变量时，就需要在不用这个对象时赋值为null，因为强引用不会被垃圾回收。

强引用在实际中有非常重要的用处，举个ArrayList的实现源代码：

private transient Object[] elementData;
    public void clear() {
           modCount++;
           // Let gc do its work
           for (int i = 0; i < size; i++)
               elementData[i] = null;
           size = 0;
    }

在ArrayList类中定义了一个私有的变量elementData数组，在调用方法清空数组时可以看到为每个数组内容赋值为null。不同于elementData=null，强引用仍然存在，避免在后续调用 add()等方法添加元素时进行重新的内存分配。**使用如clear()方法中释放内存的方法对数组中存放的引用类型特别适用，这样就可以及时释放内存。**

**（2）软引用（SoftReference）**

如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

String str=new String("abc");                                     // 强引用
    SoftReference<String> softRef=new SoftReference<String>(str);     // 软引用

当内存不足时，等价于：

If(JVM.内存不足()) {
      str = null;  // 转换为软引用
      System.gc(); // 垃圾回收器进行回收
    }

软引用在实际中有重要的应用，例如浏览器的后退按钮。按后退时，这个后退时显示的网页内容是重新进行请求还是从缓存中取出呢？这就要看具体的实现策略了。

（1）如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建

（2）如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出

这时候就可以使用软引用

Browser prev = new Browser();               // 获取页面进行浏览
    SoftReference sr = new SoftReference(prev); // 浏览完毕后置为软引用    
    if(sr.get()!=null){ 
       rev = (Browser) sr.get();           // 还没有被回收器回收，直接获取
    }else{
       prev = new Browser();               // 由于内存吃紧，所以对软引用的对象回收了
       sr = new SoftReference(prev);       // 重新构建
    }

这样就很好的解决了实际的问题。

软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

**3、弱引用**

如果一个对象只具有弱引用，那就类似于可有可无的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个**优先级很低的线程**， 因此不一定会很快发现那些只具有弱引用的对象。弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。**当你想引用一个对象，但是这个对象有自己的生命周期，你不想介入这个对象的生命周期，这时候你就是用弱引用。这个引用不会在对象的垃圾回收判断中产生任何附加的影响。比如说Thread中保存的ThreadLocal的全局映射，因为我们的Thread不想在ThreadLocal生命周期结束后还对其造成影响，所以应该使用弱引用，这个和缓存没有关系，只是为了防止内存泄漏所做的特殊操作。**

**4、幽灵引用(虚引用)**

**虚引用主要用来跟踪对象被垃圾回收器回收的活动。**虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存后，把这个虚引用加入到与之关联的引用队列中。**程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存回收后采取必要的行动。**由于Object.finalize()方法的不安全性、低效性，常常**使用虚引用完成对象回收后的资源释放工作**。当你创建一个虚引用时要传入一个引用队列，如果引用队列中出现了你的虚引用，说明它已经被回收，那么你可以在其中做一些相关操作，主要是实现细粒度的内存控制。比如**监视缓存，当缓存被回收后才申请新的缓存区。**

### **6. hashcode的作用。** ###

答案：hashCode用于返回对象的散列值，用于在散列函数中确定放置的桶的位置。

1.  hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的；
2.  如果两个对象相同，就是适用于equals(java.lang.Object) 方法，那么这两个对象的hashCode一定要相同；
3.  如果对象的equals方法被重写，那么对象的hashCode也尽量重写，并且产生hashCode使用的对象，一定要和equals方法中使用的一致，否则就会违反上面提到的第2点；
4.  两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定适用于equals(java.lang.Object) 方法，只能够说明这两个对象在散列存储结构中，如Hashtable，他们**“存放在同一个篮子里”**。

### **7. ArrayList、LinkedList、Vector的区别。** ###

Arraylist和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加插入元素，都允许直接序号索引元素，但是插入数据要涉及到数组元素移动等内存操作，所以插入数据慢，查找有下标，所以查询数据快，**Vector由于使用了synchronized方法-线程安全**，所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项前后项即可，插入数据较快。

### **8. String、StringBuffer与StringBuilder的区别。** ###

答案:

**String 字符串常量  
StringBuffer 字符串变量（线程安全）  
StringBuilder 字符串变量（非线程安全）**

简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。

而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。

String s1 = "aaaaa";  
    String s2 = "bbbbb";  
    String r = null;  
    int i = 3694;  
    r = s1 + i + s2;

通过查看字节码可以发现，JVM内部使用的是创建了一个StringBuilder完成拼接工作

**StringBuffer**  
Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。  
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。  
StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。  
例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。  
在大部分情况下 StringBuilder > StringBuffer

**java.lang.StringBuilder**  
java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

### 9. Map、Set、List、Queue、Stack的特点与用法。 ###

### **10. HashMap和HashTable的区别。** ###

答案：Hashtable和HashMap类有三个重要的不同之处。

1、第一个不同主要是历史原因。**Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的[Map接口][Map]的一个实现。**

2、也许最重要的不同是Hashtable的方法是同步的，**但是这也是HashTable效率低下的原因，任何方法都是同步的**，而HashMap的方法不是。这就意味着，虽然你可以不用采取任何特殊的行为就可以在一个多线程的应用程序中用一个Hashtable，但你必须同样地为一个HashMap提供外同步。一个方便的方法就是利用Collections类的静态的synchronizedMap()方法，它创建一个[线程安全][Link 1]的Map对象，并把它作为一个封装的对象来返回。这个对象的方法可以让你同步访问潜在的HashMap。这么做的结果就是当你不需要同步时，你不能切断Hashtable中的同步（比如在一个单线程的应用程序中），而且同步增加了很多处理费用。

3、第三点不同是，**只有HashMap可以让你将空值作为一个表的条目的key或value。**HashMap中只有一条记录可以是一个空的key，但任意数量的条目可以是空的value。这就是说，如果在表中没有发现搜索键，或者如果发现了搜索键，但它是一个空的值，那么get()将返回null。如果有必要，用containKey()方法来区别这两种情况。

一些资料建议，当需要同步时，用Hashtable，反之用HashMap。但是，因为在需要时，HashMap可以被同步，HashMap的功能比Hashtable的功能更多，而且它不是基于一个陈旧的类的，所以有人认为，在各种情况下，HashMap都优先于Hashtable。

### **11. HashMap和ConcurrentHashMap的区别，HashMap的底层源码。** ###

**（1）HashMap的源码：**

1、HashMap中的hash函数实现：

详见：[https://www.zhihu.com/question/20733617][https_www.zhihu.com_question_20733617]

2、HashMap源码解读

详见：[http://blog.csdn.net/ll530304349/article/details/53056346][http_blog.csdn.net_ll530304349_article_details_53056346]

**（2）ConcurrentHashMap的源码：**

**1、JDK1.7版本的实现**

ConcurrentHashMap的**锁分段技术**：假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效的提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术。首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

ConcurrentHashMap不允许Key或者Value的值为NULL

![v2-451348ba1836dbe9ed7619dfd7e2f4d4_hd.jpg][]

**第一：Segment类**

**Put**

将一个HashEntry放入到该Segment中，**使用自旋机制，减少了加锁的可能性。**

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
       HashEntry<K,V> node = tryLock() ? null :
           scanAndLockForPut(key, hash, value); //如果加锁失败，则调用该方法
       V oldValue;
       try {
           HashEntry<K,V>[] tab = table;
           int index = (tab.length - 1) & hash; //同hashMap相同的哈希定位方式
           HashEntry<K,V> first = entryAt(tab, index);
           for (HashEntry<K,V> e = first;;) {
               if (e != null) {
           //若不为null，则持续查找，知道找到key和hash值相同的节点，将其value更新
                   K k;
                   if ((k = e.key) == key ||
                       (e.hash == hash && key.equals(k))) {
                       oldValue = e.value;
                       if (!onlyIfAbsent) {
                           e.value = value;
                           ++modCount;
                       }
                       break;
                   }
                   e = e.next;
               }
               else { //若头结点为null
                   if (node != null) //在遍历key对应节点链时没有找到相应的节点
                       node.setNext(first);
                       //当前修改并不需要让其他线程知道，在锁退出时修改自然会
                       //更新到内存中,可提升性能
                   else
                       node = new HashEntry<K,V>(hash, key, value, first);
                   int c = count + 1;
                   if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                       rehash(node); //如果超过阈值，则进行rehash操作
                   else
                       setEntryAt(tab, index, node);
                   ++modCount;
                   count = c;
                   oldValue = null;
                   break;
               }
           }
       } finally {
           unlock();
       }
       return oldValue;
    }

**scanAndLockForPut**

该操作持续查找key对应的节点链中是否已存在该节点，如果没有找到已存在的节点，则预创建一个新节点，**并且尝试n次，直到尝试次数超出限制**，才真正进入等待状态，即所谓的 **自旋等待**。

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
       //根据hash值找到segment中的HashEntry节点
       HashEntry<K,V> first = entryForHash(this, hash); //首先获取头结点
       HashEntry<K,V> e = first;
       HashEntry<K,V> node = null;
       int retries = -1; // negative while locating node
       while (!tryLock()) {  //持续遍历该哈希链
           HashEntry<K,V> f; // to recheck first below
           if (retries < 0) {
               if (e == null) {
                   if (node == null) //若不存在要插入的节点，则创建一个新的节点
                       node = new HashEntry<K,V>(hash, key, value, null);
                   retries = 0;
               }
               else if (key.equals(e.key))
                   retries = 0;
               else
                   e = e.next;
           }
           else if (++retries > MAX_SCAN_RETRIES) {
           //尝试次数超出限制，则进行自旋等待
               lock();
               break;
           }
           /*当在自旋过程中发现节点链的链头发生了变化，则更新节点链的链头，
           并重置retries值为－1，重新为尝试获取锁而自旋遍历*/
           else if ((retries & 1) == 0 &&
                    (f = entryForHash(this, hash)) != first) {
               e = first = f; // re-traverse if entry changed
               retries = -1;
           }
       }
       return node;
    }

**remove**

用于移除某个节点，返回移除的节点值。

final V remove(Object key, int hash, Object value) {
       if (!tryLock())
           scanAndLock(key, hash);
       V oldValue = null;
       try {
           HashEntry<K,V>[] tab = table;
           int index = (tab.length - 1) & hash;
           //根据这种哈希定位方式来定位对应的HashEntry
           HashEntry<K,V> e = entryAt(tab, index);
           HashEntry<K,V> pred = null;
           while (e != null) {
               K k;
               HashEntry<K,V> next = e.next;
               if ((k = e.key) == key ||
                   (e.hash == hash && key.equals(k))) {
                   V v = e.value;
                   if (value == null || value == v || value.equals(v)) {
                       if (pred == null)
                           setEntryAt(tab, index, next);
                       else
                           pred.setNext(next);
                       ++modCount;
                       --count;
                       oldValue = v;
                   }
                   break;
               }
               pred = e;
               e = next;
           }
       } finally {
           unlock();
       }
       return oldValue;
    }

**Clear**

要首先对整个segment加锁，然后将每一个HashEntry都设置为null。

final void clear() {
       lock();
       try {
           HashEntry<K,V>[] tab = table;
           for (int i = 0; i < tab.length ; i++)
               setEntryAt(tab, i, null);
           ++modCount;
           count = 0;
       } finally {
           unlock();
       }
    }

**Put**

public V put(K key, V value) {
       Segment<K,V> s;
       if (value == null)
           throw new NullPointerException();
       int hash = hash(key); //求出key的hash值
       int j = (hash >>> segmentShift) & segmentMask;
       //求出key在segments数组中的哪一个segment中
       if ((s = (Segment<K,V>)UNSAFE.getObject           
            (segments, (j << SSHIFT) + SBASE)) == null)  
           s = ensureSegment(j); //使用unsafe操作取出该segment
       return s.put(key, hash, value, false); //向segment中put元素
    }

**Get**

public V get(Object key) {
       Segment<K,V> s;
       HashEntry<K,V>[] tab;
       int h = hash(key); //找出对应的segment的位置
       long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
       if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
           (tab = s.table) != null) {  //使用Unsafe获取对应的Segmen
           for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                    (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
                e != null; e = e.next) { //找出对应的HashEntry，从头开始遍历
               K k;
               if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                   return e.value;
           }
       }
       return null;
    }

**Size**

求出所有的HashEntry的数目，**先尝试的遍历查找、计算2遍**，如果两遍遍历过程中整个Map没有发生修改（即两次所有Segment实例中modCount值的和一致），则可以认为整个查找、计算过程中Map没有发生改变。否则,需要对所有segment实例进行加锁、计算、解锁，然后返回。

public int size() {
    
      final Segment<K,V>[] segments = this.segments;
      int size;
      boolean overflow; // true if size overflows 32 bits
      long sum;         // sum of modCounts
      long last = 0L;   // previous sum
      int retries = -1; // first iteration isn't retry
      try {
          for (;;) {
              if (retries++ == RETRIES_BEFORE_LOCK) {
                  for (int j = 0; j < segments.length; ++j)
                      ensureSegment(j).lock(); // force creation
              }
              sum = 0L;
              size = 0;
              overflow = false;
              for (int j = 0; j < segments.length; ++j) {
                  Segment<K,V> seg = segmentAt(segments, j);
                  if (seg != null) {
                      sum += seg.modCount;
                      int c = seg.count;
                      if (c < 0 || (size += c) < 0)
                          overflow = true;
                  }
              }
              if (sum == last)
                  break;
              last = sum;
          }
      } finally {
          if (retries > RETRIES_BEFORE_LOCK) {
              for (int j = 0; j < segments.length; ++j)
                  segmentAt(segments, j).unlock();
          }
      }
      return overflow ? Integer.MAX_VALUE : size;
    }

**（2）JDK1.8实现**

在JDK1.8中对ConcurrentHashmap做了两个改进：

*  取消segments字段，直接采用transient volatile HashEntry<K,V>\[\] table保存数据，**采用table数组元素作为锁，从而实现了对每一行数据进行加锁，进一步减少并发冲突的概率**。
 *  将原先 **table数组＋单向链表** 的数据结构，变更为 **table数组＋单向链表＋红黑树** 的结构。对于hash表来说，最核心的能力在于将key hash之后能均匀的分布在数组中。如果hash之后散列的很均匀，那么table数组中的每个队列长度主要为0或者1。但实际情况并非总是如此理想，虽然ConcurrentHashMap类默认的加载因子为0.75，但是在数据量过大或者运气不佳的情况下，还是会存在一些队列长度过长的情况，如果还是采用单向列表方式，**那么查询某个节点的时间复杂度为O(n)；因此，对于个数超过8(默认值)的列表，jdk1.8中采用了红黑树的结构，那么查询的时间复杂度可以降低到O(logN)，**可以改进性能。

### **12. TreeMap、HashMap、LinkedHashMap的区别。** ###

Map主要用于存储健值对，根据键得到值，因此不允许键重复(重复了覆盖了),但允许值

重复。Hashmap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度，遍历时，取得数据的顺序是完全随机的。HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步，可以用 Collections的synchronizedMap方法使HashMap具有同步的能力，或者使用ConcurrentHashMap。

*  HashMap：线程不同步。根据key的hashcode进行存储，内部使用静态内部类Node的数组进行存储，默认初始大小为16，每次扩大一倍。当发生Hash冲突时，采用拉链法（链表）。**可以接受为null的键值(key)和值(value)**。JDK 1.8中：当单个桶中元素个数大于等于8时，链表实现改为红黑树实现；当元素个数小于6时，变回链表实现。由此来防止hashCode攻击。
 *  LinkedHashMap：**保存了记录的插入顺序**，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的. 也可以在构造时用带参数，按照应用次数排序。在遍历的时候会比HashMap慢，不过有种情况例外，当HashMap容量很大，实际数据较少时，遍历起来可能会比LinkedHashMap慢，因为LinkedHashMap的遍历速度只和实际数据有关，和容量无关，而HashMap的遍历速度和他的容量有关。**LinkedHashMap采用的hash算法和HashMap相同，但是它重新定义了数组中保存的元素Entry，该Entry除了保存当前对象的引用外，还保存了其上一个元素before和下一个元素after的引用，从而在哈希表的基础上又构成了双向链接列表。**
 *  TreeMap：线程不同步，基于 **红黑树** （Red-Black tree）的NavigableMap 实现，**能够把它保存的记录根据键排序,默认是按键值的升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。**
 *  HashTable：线程安全，HashMap的迭代器(Iterator)是fail-fast迭代器。**HashTable不能存储NULL的key和value。**

### **13. Collection包结构，与Collections的区别。** ###

**（1）Collection 是单列集合**

**List** 元素是有序的、可重复

有序的 collection，可以对列表中每个元素的插入位置进行精确地控制。

可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

可存放重复元素，元素存取是有序的。

List接口中常用类

**l Vector**：线程安全，但速度慢，已被ArrayList替代。

底层数据结构是数组结构

**l ArrayList**：线程不安全，查询速度快。

底层数据结构是数组结构

**l LinkedList**：线程不安全。增删速度快。

底层数据结构是列表结构

**Set**(集) 元素无序的、不可重复。

取出元素的方法只有迭代器。不可以存放重复元素，元素存取是无序的。

Set接口中常用的类

**l HashSet**：线程不安全，存取速度快。

它是如何保证元素唯一性的呢？依赖的是元素的hashCode方法和euqals方法。

**l TreeSet**：线程不安全，可以对Set集合中的元素进行排序。

它的排序是如何进行的呢？通过compareTo或者compare方法中的来保证元素的唯一性。元素是以二叉树的形式存放的。

**（2）Map** 是一个双列集合

|--**Hashtable**:线程安全，速度快。底层是哈希表数据结构。是**同步**的。

不允许null作为键，null作为值。

|--**Properties**:用于配置文件的定义和操作，使用频率非常高，同时键和值都是字符串。

是集合中可以和IO技术相结合的对象。(到了IO在学习它的特有和io相关的功能。)

|--**HashMap**:线程不安全，速度慢。底层也是哈希表数据结构。是**不同步**的。

允许null作为键，null作为值。替代了Hashtable.

|--**LinkedHashMap**: 可以保证HashMap集合有序。存入的顺序和取出的顺序一致。

|--**TreeMap**：可以用来对Map集合中的**键**进行排序.

**（3）Collection 和 Collections的区别**

**Collection**是集合类的上级接口，子接口主要有Set 和List。

**Collections**是针对集合类的一个帮助类，提供了操作集合的工具方法：一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

### **14. try catch finally，try里有return，finally还执行么？** ###

答案：执行，并且finally的执行早于try里面的return

结论：

1、不管有木有出现异常，finally块中代码都会执行；

2、当try和catch中有return时，finally仍然会执行；

3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；

4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

举例：

**情况1**：try\{\} catch()\{\}finally\{\} return;

显然程序按顺序执行。

**情况2**:try\{ return; \}catch()\{\} finally\{\} return;

程序执行try块中return之前（包括return语句中的表达式运算）代码；

再执行finally块，最后执行try中return;

finally块之后的语句return，因为程序在try中已经return所以不再执行。

**情况3**:try\{ \} catch()\{return;\} finally\{\} return;

程序先执行try，如果遇到异常执行catch块，

有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，

最后执行catch块中return. finally之后也就是4处的代码不再执行。

无异常：执行完try再finally再return.

**情况4**:try\{ return; \}catch()\{\} finally\{return;\}

程序执行try块中return之前（包括return语句中的表达式运算）代码；

再执行finally块，因为finally块中有return所以提前退出。

**情况5**:try\{\} catch()\{return;\}finally\{return;\}

程序执行catch块中return之前（包括return语句中的表达式运算）代码；

再执行finally块，因为finally块中有return所以提前退出。

**情况6**:try\{ return;\}catch()\{return;\} finally\{return;\}

程序执行try块中return之前（包括return语句中的表达式运算）代码；

有异常：执行catch块中return之前（包括return语句中的表达式运算）代码；

则再执行finally块，因为finally块中有return所以提前退出。

无异常：则再执行finally块，因为finally块中有return所以提前退出。

**最终结论：**任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。

如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的，编译器把finally中的return实现为一个warning。

### **15. Excption与Error包结构。OOM你遇到过哪些情况，SOF你遇到过哪些情况。** ###

**（1）Java异常**

Java中有Error和Exception，它们都是继承自Throwable类。

![v2-d43fa29197d4f914adbaeccb05320845_hd.jpg][]

![v2-c45d4ef2375c8d45e0e6c923ddfdb1a1_hd.jpg][]

**二者的不同之处**

Exception：

*  可以是可被控制(checked) 或不可控制的(unchecked)。
 *  表示一个由程序员导致的错误。
 *  应该在应用程序级被处理。

Error：

*  总是不可控制的(unchecked)。
 *  经常用来用于表示系统错误或低层资源的错误。
 *  如何可能的话，应该在系统级被捕捉。

**异常的分类**

*  **Checked exception**: 这类异常都是Exception的子类。异常的向上抛出机制进行处理，假如子类可能产生A异常，那么在父类中也必须throws A异常。可能导致的问题：代码效率低，耦合度过高。
 *  **Unchecked exception**: **这类异常都是RuntimeException的子类，虽然RuntimeException同样也是Exception的子类，但是它们是非凡的，它们不能通过client code来试图解决**，所以称为Unchecked exception 。

### **16. Java面向对象的三个特征与含义。** ###

答案：继承、多态、封装

### **17. Override和Overload的含义与区别。** ###

答案：见JVM静态分派和动态分派

### **18. Interface与abstract类的区别。** ###

答案：  
1.abstract class 在Java中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。  
2.在abstract class 中可以有自己的数据成员，也可以有非abstarct的方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的方法都是public abstract的。  
3.抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。接口中定义的变量默认是public static final 型，且必须给其赋初值，所以实现类中不能重新定义，也不能改变其值。  
4.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系，门和报警的关系。   
5.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

abstract class 和 interface 是 Java语言中的两种定义抽象类的方式，它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理，因为它们表现了概念间的不同的关系。

### **19. Static class 与non static class的区别。** ###

答案：

**比对如下：**

静态对象 非静态对象   
拥有属性： 是类共同拥有的 是类各对象独立拥有的  
内存分配： 内存空间上是固定的 空间在各个附属类里面分配   
分配顺序： 先分配静态对象的空间 继而再对非静态对象分配空间,也就是初始化顺序是先静态再非静态.  
**Java静态对象到底有什么好处？**

A，静态对象的数据在全局是唯一的，一改都改。如果你想要处理的东西是整个程序中唯一的，弄成静态是个好方法。 非静态的东西你修改以后只是修改了他自己的数据，但是不会影响其他同类对象的数据。   
B，引用方便。**直接用 类名.静态方法名 或者 类名.静态变量名**就可引用并且直接可以修改其属性值，不用get和set方法。  
C，保持数据的唯一性。此数据全局都是唯一的，修改他的任何一处地方，在程序所有使用到的地方都将会体现到这些数据的修改。有效减少多余的浪费。

D，static final用来修饰成员变量和成员方法，可简单理解为“全局常量”。对于变量，表示一旦给值就不可修改；对于方法，表示不可覆盖。

### **20. 锁的等级：方法锁、对象锁、类锁。** ###

**（1）基础**

Java中的每一个对象都可以作为锁。

*  对于同步方法，**锁是当前实例对象**。
 *  对于静态同步方法，**锁是当前对象的Class对象**。
 *  对于同步方法块，**锁是Synchonized括号里配置的对象**。

当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。那么锁存在哪里呢？锁里面会存储什么信息呢？

**（2）同步的原理**

JVM规范规定JVM基于进入和退出 Monitor 对象来实现方法同步和代码块同步，但两者的实现细节不一样。代码块同步是使用monitorenter和monitorexit指令实现，而方法同步是使用另外一种方式实现的，细节在JVM规范里并没有详细说明，但是方法的同步同样可以使用这两个指令来实现。

monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处，JVM要保证每个monitorenter必须有对应的monitorexit与之配对。任何对象都有一个monitor与之关联，当且一个monitor被持有后，它将处于锁定状态。线程执行到 monit

### **21. 反射的作用与原理。** ###

（1）概念

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

（2）功能

反射机制主要提供了以下功能：

*  在运行时判断任意一个对象所属的类；
 *  在运行时构造任意一个类的对象；
 *  在运行时判断任意一个类所具有的成员变量和方法；
 *  在运行时调用任意一个对象的方法；
 *  生成动态代理。

> 我有一个微信公众号，经常会分享一些Java技术相关的干货；如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。

[v2-3be5a521b36db1f7851dbccefd26fe24_hd.jpg]: /images/20220315/a0adbe3a2f8a4d09aa1a6a5817469b1e.png
[Java]: http://link.zhihu.com/?target=https%3A//www.baidu.com/s%3Fwd%3DJava%26tn%3D44039180_cpr%26fenlei%3Dmv6quAkxTZn0IZRqIHckPjm4nH00T1YzmWm3Pjn3nHf3PynLm1RY0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EnW0dPjD3rjbLrjT3n1TkPjb3Ps
[Map]: http://link.zhihu.com/?target=https%3A//www.baidu.com/s%3Fwd%3DMap%25E6%258E%25A5%25E5%258F%25A3%26tn%3D44039180_cpr%26fenlei%3Dmv6quAkxTZn0IZRqIHckPjm4nH00T1Y1mH6YnHRLujRsnjuhmHcv0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3En1RsPjDsPjRv
[Link 1]: http://link.zhihu.com/?target=https%3A//www.baidu.com/s%3Fwd%3D%25E7%25BA%25BF%25E7%25A8%258B%25E5%25AE%2589%25E5%2585%25A8%26tn%3D44039180_cpr%26fenlei%3Dmv6quAkxTZn0IZRqIHckPjm4nH00T1Y1mH6YnHRLujRsnjuhmHcv0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3En1RsPjDsPjRv
[https_www.zhihu.com_question_20733617]: https://www.zhihu.com/question/20733617
[http_blog.csdn.net_ll530304349_article_details_53056346]: http://link.zhihu.com/?target=http%3A//blog.csdn.net/ll530304349/article/details/53056346
[v2-451348ba1836dbe9ed7619dfd7e2f4d4_hd.jpg]: /images/20220315/fb561b5eb07b400a8f5581c60812b8ca.png
[v2-d43fa29197d4f914adbaeccb05320845_hd.jpg]: /images/20220315/d7d81cc1059b4b8f974459cf34047799.png
[v2-c45d4ef2375c8d45e0e6c923ddfdb1a1_hd.jpg]: /images/20220315/b084a635b92345fea71d17e066903200.png