Java基础知识点总结（长文慎入！）

末蓝、 2023-07-10 14:15 1阅读 0赞

### 文章目录 ###

*   *   *  什么是面向对象？
         *  1. 描述一下值传递和引用传递的区别
         *  2. ==和equals区别？String的equals方法是如何重写的？为什么要重写equals方法？为什么要重写hashCode方法?
         *  3. String s1 = new String("abc"); String s2 = "abc"; s1 == s2? 语句1在内存中创建了几个对象？
         *  4. String为什么是不可变的？jdk源码中的String如何定义的？为什么这么设计？
         *  4. 请描述一下static关键字和final关键字的用法。
         *  5. 接口和抽象类的区别是什么？
         *  6. 重载和重写的区别？
         *  7. 面向对象的三大特性，谈谈你对xx的理解
         *  8. 请写出下面程序的输出结果 （考察的是基本类型的转换，及原码反码补码的运算）
         *  9. byte的取值范围是多少？怎么计算出来的？
         *  10. hashMap相关
         *   *  10.1 连环问
             *  10.2 HashMap 和 Hashtable 的区别
             *  10.3 HashMap和HashSet区别
             *  10.4 HashMap底层实现
             *  10.5 HashMap的长度为什么是2的幂次方
             *  10.6 HashMap多线程操作导致死循环问题
             *  10.7 HashMap的线程安全实现有哪些？
             *  10.8 ConcurrentHashMap的底层实现
         *  11. Integer缓存池
         *  12. UTF-8和Unicode的关系
         *  13. 项目为UTF-8环境，char c = ‘中’，是否合法？
         *  14. Arrays.asList获得的List使用时需要注意什么
         *  15. Collection和Collections区别？
         *  16. 你知道fail-fast 和 fail-safe吗?
         *  17. ArrayList和LinkedList和Vector的区别？
         *  18. Set和List区别？Set如何保证元素不重复?
         *  19. UTF-8与GBK互转，为什么会乱码
         *  20. 重载和重写的区别
         *  21. 为什么Java是解释性语言
         *  22. Mybatis执行流程
         *  23. Mybatis缓存
         *  24. Mybatis用到的设计模式
         *  25. ConcurrentHashMap 1.7和1.8的区别
         *   *   *  1、整体结构
                 *  2、put（）
                 *  3、get（）
                 *  4、resize（）
                 *  5、size（）
         *  26. 地址栏输入URL发生了什么
         *  27. 组合和聚合的区别：
         *  28. OSI七层模型
         *  29. 讲一下CMS垃圾回收器
         *  30. Spring事务管理原理？
         *  31. JDK动态代理和GClib动态代理
         *   *  31.1、JDK动态代理具体实现原理：
             *  31.2、CGLib动态代理：
             *  31.3、两者对比：
             *  31.4、使用注意：
             *  32. Threadlocal 内存泄漏问题
             *  33.StringBuilder 安全怎么实现的？详细描述怎么扩容的？

### 什么是面向对象？ ###

这个问题其实是最不好回答的，因为这个东西甚至就可以上升到哲学方面…，回答的好与不好很能看出Java学的深浅，这里借用《Think in Java》这本书来说一下吧

1.  万物皆对象
2.  程序是对象的集合，它们通过发送消息来告知彼此所要做的。
3.  每个对象都有自己的由其他对象所构成的存储。
4.  每个对象都有其类型
5.  而某-特定类型的所有对象都可以接收同样的消息。

### 1. 描述一下值传递和引用传递的区别 ###

https://blog.csdn.net/qq\_17806439/article/details/86075353

> **值传递：**
> 
> 方法调用时，实际参数把它的值传递给对应的形式参数，函数接收的是原始值的一个copy，**此时内存中存在两个相等的基本类型，即实际参数和形式参数**，**后面方法中的操作都是对形参这个值的修改，不影响实际参数的值**。
> 
> **引用传递：**
> 
> 也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，函数接收的是原始值的内存地址；
> 
> **在方法执行中，形参和实参内容相同，指向同一块内存地址，方法执行中对引用的操作将会影响到实际对象**。

### 2. ==和equals区别？String的equals方法是如何重写的？为什么要重写equals方法？为什么要重写hashCode方法? ###

可参考：http://www.bimowu.com/kstudy-web/clienttopic/view.do?topicId=751

以及：[Java 如何重写对象的 equals 方法和 hashCode 方法][Java _ equals _ hashCode]

### 3. String s1 = new String(“abc”); String s2 = “abc”; s1 == s2? 语句1在内存中创建了几个对象？ ###

http://www.bimowu.com/kstudy-web/clienttopic/view.do?topicId=751

**补充：**

String str1 = "str";
            String str2 = "ing";
    
            String str3 = "str" + "ing";//常量池中的对象
            String str4 = str1 + str2; //在堆上创建的新的对象	  
            String str5 = "string";//常量池中的对象
            System.out.println(str3 == str4);//false
            System.out.println(str3 == str5);//true
            System.out.println(str4 == str5);//false

String s1 = new String("计算机");
            String s2 = s1.intern();
            String s3 = "计算机";
            System.out.println(s2);//计算机
            System.out.println(s1 == s2);//false，因为一个是堆内存中的 String 对象一个是常量池中的 String 对象，
            System.out.println(s3 == s2);//true，因为两个都是常量池中的 String 对象

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70_pic_center]

**尽量避免多个字符串拼接，因为这样会重新创建对象。如果需要改变字符串的话，可以使用 StringBuilder 或者 StringBuffer。**

**请着重掌握关于String的以下知识：**

*  String对"+"的重载
    
     *  String s = “a” + “b”，编译器会进行常量折叠(因为两个都是编译期常量，编译期可知)，即变成 String s = “ab”
     *  对于能够进行优化的(String s = “a” + 变量 等)用 StringBuilder 的 append() 方法替代，最后调用 toString() 方法 (底层就是一个 new String())
 *  [字符串拼接的几种方式和区别][Link 1]
 *  [JDK 6和JDK 7中substring的原理及区别][JDK 6_JDK 7_substring]
 *  [对new String(“abc”)的理解][new String_abc]

### 4. String为什么是不可变的？jdk源码中的String如何定义的？为什么这么设计？ ###

https://blog.csdn.net/weixin\_42447959/article/details/82598778

### 4. 请描述一下static关键字和final关键字的用法。 ###

> 静态变量、静态方法、静态类
> 
> 1.静态变量：
> 
> 声明为static的静态变量实质上就是全局变量，当声明一个对象时，并不产生static变量的拷贝，而是该类所有实例变量共用同一个static变量。也就是说这个静态变量只加载一次，只分配一块储存空间。
> 
> 2.静态方法：
> 
> 声明为static的静态方法有以下几个特点：
> 
> （1）静态方法只能调用静态方法；
> 
> （2）静态方法只能访问静态数据；
> 
> （3）静态方法不能以任何方式引用this或super；
> 
> 3.静态类：
> 
> 通常一个普通类不允许声明为静态，只有一个内部类才可以（main方法就是一个典型），这时这个声明的静态类可以直接作为一个普通类来使用，而不需要实例一个外部类。
> 
> final的作用从变量、方法、类三个方面来理解、
> 
> final修饰的变量的值不能被修改，是一个常量；
> 
> final修饰的方法不能被重写；
> 
> final修饰的类不能被继承；

### 5. 接口和抽象类的区别是什么？ ###

https://www.jianshu.com/p/c4f023d02f0c

### 6. 重载和重写的区别？ ###

> 重载： 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。
> 
> 重写： 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private则子类就不能重写该方法。

### 7. 面向对象的三大特性，谈谈你对xx的理解 ###

https://www.cnblogs.com/inspred/p/9526253.html

### 8. 请写出下面程序的输出结果 （考察的是基本类型的转换，及原码反码补码的运算） ###

public static void main(String[] args) {
        
               // TODO Auto-generated method stub
               int a=255;
               System.out.println(Integer.toBinaryString(a));
               System.out.println((byte) a); 
       }

### 9. byte的取值范围是多少？怎么计算出来的？ ###

https://blog.csdn.net/qq\_23418393/article/details/57421688

int i = Integer.MAX_VALUE;
           int j = Integer.MAX_VALUE;
       
           int k = i + j;
           System.out.println("i (" + i + ") + j (" + j + ") = k (" + k + ")");

输出结果：`i (2147483647) + j (2147483647) = k (-2)`

每个类型都有一定的表示范围，但是，在程序中有些计算会导致超出表示范围，即溢出，溢出的时候并不会抛异常，也没有任何提示。***这里思考一下为什么结果是-2。***

### 10. hashMap相关 ###

#### 10.1 连环问 ####

1.  hashMap平时都怎么使用？key值可以传null吗?
2.  hashMap工作原理是什么？内部是什么数据结构？
3.  当两个key对象的hashcode一样，put的时候会发生什么
4.  当两个key对象的hashcode一样时，get如何处理？
5.  当hashMap的大小超过了负载因子定义的容量，会发生什么？
6.  hashMap的key对象必须是不可变的吗？如果是可变的，那会出现什么问题？
7.  hashMap是线程安全的吗？会在哪些方法或者功能出现线程安全的问题？线程安全的集合实现有哪些？  
    这些可以去我之前的博客看，[传送门：][Link 2]

#### 10.2 HashMap 和 Hashtable 的区别 ####

1.  **线程是否安全：** HashMap 是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过`synchronized` 修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！）；
2.  **效率：** 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它；
3.  **对Null key 和Null value的支持：** HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。。但是在 HashTable 中 put 进的键值只要有一个 null，直接抛出 NullPointerException。
4.  **初始容量大小和每次扩充容量大小的不同 ：** ①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。②创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小（HashMap 中的`tableSizeFor()`方法保证，下面给出了源代码）。也就是说 HashMap 总是使用2的幂作为哈希表的大小,后面会介绍到为什么是2的幂次方。
5.  **底层数据结构：** JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。

**HashMap 中带有初始容量的构造函数：**

public HashMap(int initialCapacity, float loadFactor) {
        
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal initial capacity: " +
                                                   initialCapacity);
            if (initialCapacity > MAXIMUM_CAPACITY)
                initialCapacity = MAXIMUM_CAPACITY;
            if (loadFactor <= 0 || Float.isNaN(loadFactor))
                throw new IllegalArgumentException("Illegal load factor: " +
                                                   loadFactor);
            this.loadFactor = loadFactor;
            this.threshold = tableSizeFor(initialCapacity);
        }
         public HashMap(int initialCapacity) {
        
            this(initialCapacity, DEFAULT_LOAD_FACTOR);
        }

下面这个方法保证了 HashMap 总是使用2的幂作为哈希表的大小。

/**
         * Returns a power of two size for the given target capacity.
         */
        static final int tableSizeFor(int cap) {
        
            int n = cap - 1;
            n |= n >>> 1;
            n |= n >>> 2;
            n |= n >>> 4;
            n |= n >>> 8;
            n |= n >>> 16;
            return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
        }

具体内容也请看我的之前的博客：  
深入浅出HashMap[https://blog.csdn.net/AAAhxz/article/details/103777586][Link 2]

#### 10.3 HashMap和HashSet区别 ####

如果你看过 `HashSet` 源码的话就应该知道：HashSet 底层就是基于 HashMap 实现的。（HashSet 的源码非常非常少，因为除了 `clone()`、`writeObject()`、`readObject()`是 HashSet 自己不得不实现之外，其他方法都是直接调用 HashMap 中的方法。

<table> 
 <thead> 
  <tr> 
   <th align="center">HashMap</th> 
   <th align="center">HashSet</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">实现了Map接口</td> 
   <td align="center">实现Set接口</td> 
  </tr> 
  <tr> 
   <td align="center">存储键值对</td> 
   <td align="center">仅存储对象</td> 
  </tr> 
  <tr> 
   <td align="center">调用 <code>put（）</code>向map中添加元素</td> 
   <td align="center">调用 <code>add（）</code>方法向Set中添加元素</td> 
  </tr> 
  <tr> 
   <td align="center">HashMap使用键（Key）计算Hashcode</td> 
   <td align="center">HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，</td> 
  </tr> 
 </tbody> 
</table>

#### 10.4 HashMap底层实现 ####

*  JDK1.8之前
    
    JDK1.8 之前 `HashMap` 底层是 **数组和链表** 结合在一起使用也就是 **链表散列**。**HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 (n - 1) & hash 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。**
    
    **所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使用扰动函数之后可以减少碰撞。**
    
    **JDK 1.8 HashMap 的 hash 方法源码:**
    
    JDK 1.8 的 hash方法 相比于 JDK 1.7 hash 方法更加简化，但是原理不变。
    
        static final int hash(Object key) {
              
              int h;
              // key.hashCode()：返回散列值也就是hashcode
              // ^ ：按位异或
              // >>>:无符号右移，忽略符号位，空位都以0补齐
              return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
          }
    
    对比一下 JDK1.7的 HashMap 的 hash 方法源码.
    
        static int hash(int h) {
              
            // This function ensures that hashCodes that differ only by
            // constant multiples at each bit position have a bounded
            // number of collisions (approximately 8 at default load factor).
        
            h ^= (h >>> 20) ^ (h >>> 12);
            return h ^ (h >>> 7) ^ (h >>> 4);
        }
    
    相比于 JDK1.8 的 hash 方法 ，JDK 1.7 的 hash 方法的性能会稍差一点点，因为毕竟扰动了 4 次。
    
    所谓 **“拉链法”** 就是：将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。
    
    ![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FExoYase-1583196535784)(https://camo.githubusercontent.com/04f7d7f070f31c50f3d09da26f9459fdea2a7b4a/68747470733a2f2f6d792d626c6f672d746f2d7573652e6f73732d636e2d6265696a696e672e616c6979756e63732e636f6d2f323031392d362f6a646b312e382545342542392538422545352538392538442545372539412538342545352538362538352545392538332541382545372542422539332545362539452538342d486173684d61702e6a7067)\]][img-FExoYase-1583196535784_https_camo.githubusercontent.com_04f7d7f070f31c50f3d09da26f9459fdea2a7b4a_68747470733a2f2f6d792d626c6f672d746f2d7573652e6f73732d636e2d6265696a696e672e616c6979756e63732e636f6d2f323031392d362f6a646b312e382545342542392538422545352538392538442545372539412538342545352538362538352545392538332541382545372542422539332545362539452538342d486173684d61702e6a7067]
 *  JDK1.8之后
    
    相比于之前的版本， JDK1.8之后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70_pic_center 1]

TreeMap、TreeSet以及JDK1.8之后的HashMap底层都用到了红黑树。红黑树就是为了解决二叉查找树的缺陷，因为二叉查找树在某些情况下会退化成一个线性结构。

**推荐阅读：**

*  《Java 8系列之重新认识HashMap》 ：https://zhuanlan.zhihu.com/p/21673805

#### 10.5 HashMap的长度为什么是2的幂次方 ####

为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀。我们上面也讲到了过了，Hash 值的范围值-2147483648到2147483647，前后加起来大概40亿的映射空间，只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。但问题是一个40亿长度的数组，内存是放不下的。所以这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算，得到的余数才能用来要存放的位置也就是对应的数组下标。这个数组下标的计算方法是“ `(n - 1) & hash`”。（n代表数组长度）。这也就解释了 HashMap 的长度为什么是2的幂次方。

**这个算法应该如何设计呢？**

我们首先可能会想到采用%取余的操作来实现。但是，重点来了：**“取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作（也就是说 hash%length==hash&(length-1)的前提是 length 是2的 n 次方；）。”** 并且 **采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是2的幂次方。**

#### 10.6 HashMap多线程操作导致死循环问题 ####

主要原因在于 并发下的Rehash 会造成元素之间会形成一个循环链表。不过，jdk 1.8 后解决了这个问题，但是还是不建议在多线程下使用 HashMap,因为多线程下使用 HashMap 还是会存在其他问题比如数据丢失。并发环境下推荐使用 ConcurrentHashMap 。

#### 10.7 HashMap的线程安全实现有哪些？ ####

ConcurrentHashMap 和 HashTable的区别主要体现在实现线程安全的方式上不同。

*  **底层数据结构：** JDK1.7的 ConcurrentHashMap 底层采用 **分段的数组+链表** 实现，JDK1.8 采用的数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树。HashTable和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 **数组+链表** 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的；
 *  **实现线程安全的方式（重要）：** ① **在JDK1.7的时候，ConcurrentHashMap（分段锁）** 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。 **到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6以后 对 synchronized锁做了很多优化）** 整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② **Hashtable(同一把锁)** :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。

**两者的对比图：**

**HashTable:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70_pic_center 2]

**JDK1.7的ConcurrentHashMap：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70_pic_center 3]

**JDK1.8的ConcurrentHashMap（TreeBin: 红黑二叉树节点 Node: 链表节点）：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70_pic_center 4]

#### 10.8 ConcurrentHashMap的底层实现 ####

这部分博主会另出一篇，因为比较细，涉及到得点比较多

### 11. Integer缓存池 ###

Integer x = 3;
    Integer y = 3;
    System.out.println(x == y);// true
    Integer a = new Integer(3);
    Integer b = new Integer(3);
    System.out.println(a == b);//false
    System.out.println(a.equals(b));//true

> Integer a = 10; = Integer.valueOf(3) 当创建Integer对象时大小在-128~127之间，对象存放在Integer常量池中
> 
> 下次再用到会直接从常量池中取出。有点像String常量池。

### 12. UTF-8和Unicode的关系 ###

https://www.zhihu.com/question/23374078/answer/65352538

### 13. 项目为UTF-8环境，char c = ‘中’，是否合法？ ###

> 因为Java是以unicode字符集作为编码方式的（JVM内部使用的是UTF-16编码）。unicode是一个定长的编码标准，每个字符都是2个字节，也就是1个char类型的空间。
> 
> Java在编译时会把utf8的中文字符转换成对应的unicode来进行传输运算（即UTF-16）。
> 
> 所以是合法的。（即UTF-8是项目环境，实际展示的时候是转换为unicode字符集的UTF-16进行运算的）

### 14. Arrays.asList获得的List使用时需要注意什么 ###

>  *  asList 得到的只是一个 Arrays 的内部类，一个原来数组的视图 List，因此如果对它进行增删操作会报错
>  *  用 ArrayList 的构造器可以将其转变成真正的 ArrayList

### 15. Collection和Collections区别？ ###

>  *  Collection 是一个集合接口。 它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。是list，set等的父接口。
>  *  Collections 是一个包装类。 它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。
>  *  日常开发中，不仅要了解Java中的Collection及其子类的用法，还要了解Collections用法。可以提升很多处理集合类的效率。

### 16. 你知道fail-fast 和 fail-safe吗? ###

简单来说，fail-fast快速失败原理是在迭代器上维护了一个modCount的数值，每遍历一次就比较一次modCount的内存数值和当前的数值，如果不同，则证明被其他线程修改了，则直接Throw一个modifiCationExpection（不知道拼的对不对）  
相对的安全失败则在遍历时讲当前集合的值复制到一个新的集合里面，外界无法对这个集合进行访问，当遍历完后将集合再覆盖到原有集合

### 17. ArrayList和LinkedList和Vector的区别？ ###

> List主要有ArrayList、LinkedList与Vector几种实现。
> 
> 这三者都实现了List 接口，使用方式也很相似,主要区别在于因为实现方式的不同,所以对不同的操作具有不同的效率。
> 
> ArrayList 是一个可改变大小的数组.当更多的元素加入到ArrayList中时,其大小将会动态地增长.内部的元素可以直接通过get与set方法进行访问,因为ArrayList本质上就是一个数组.
> 
> LinkedList 是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.
> 
> 当然,这些对比都是指数据量很大或者操作很频繁的情况下的对比,如果数据和运算量很小,那么对比将失去意义.
> 
> Vector 和ArrayList类似,但属于强同步类。如果你的程序本身是线程安全的(thread-safe,没有在多个线程之间共享同一个集合/对象),那么使用ArrayList是更好的选择。
> 
> Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间，而ArrayList每次对size增长50%.
> 
> 而 LinkedList 还实现了 Queue 接口,该接口比List提供了更多的方法,包括 offer(),peek(),poll()等.
> 
> 注意: 默认情况下ArrayList的初始容量非常小,所以如果可以预估数据量的话,分配一个较大的初始值属于最佳实践,这样可以减少调整大小的开销。

### 18. Set和List区别？Set如何保证元素不重复? ###

> ***Set和List区别如下：***
> 
> List,Set都是继承自Collection接口。都是用来存储一组相同类型的元素的。
> 
> List特点：元素有放入顺序，元素可重复 。
> 
> 有顺序，即先放入的元素排在前面。
> 
> Set特点：元素无放入顺序，元素不可重复。
> 
> 无顺序，即先放入的元素不一定排在前面。 不可重复，即相同元素在set中只会保留一份。所以，有些场景下，set可以用来去重。 不过需要注意的是，set在元素插入时是要有一定的方法来判断元素是否重复的。这个方法很重要，决定了set中可以保存哪些元素。

> ***Set如何保证元素不重复:***
> 
> 在Java的Set体系中，根据实现方式不同主要分为两大类。HashSet和TreeSet。
> 
> 1、TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值 2、HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束
> 
> 在HashSet中，基本的操作都是有HashMap底层实现的，因为HashSet底层是用HashMap存储数据的。当向HashSet中添加元素的时候，首先计算元素的hashcode值，然后通过扰动计算和按位与的方式计算出这个元素的存储位置，如果这个位置位空，就将元素添加进去；如果不为空，则用equals方法比较元素是否相等，相等就不添加，否则找一个空位添加。
> 
> TreeSet的底层是TreeMap的keySet()，而TreeMap是基于红黑树实现的，红黑树是一种平衡二叉查找树，它能保证任何一个节点的左右子树的高度差不会超过较矮的那棵的一倍。
> 
> TreeMap是按key排序的，元素在插入TreeSet时compareTo()方法要被调用，所以TreeSet中的元素要实现Comparable接口。TreeSet作为一种Set，它不允许出现重复元素。TreeSet是用compareTo()来判断重复元素的。

### 19. UTF-8与GBK互转，为什么会乱码 ###

https://blog.csdn.net/yangfengjueqi/article/details/79486162

### 20. 重载和重写的区别 ###

重载（overload）和重写（override）的区别： 重载就是同一个类中，有多个方法名相同，但参数列表不同（包括参数个数和参数类型），与返回值无关，与权限修饰符也无关。调用重载的方法时通过传递给它们不同的参数个数和参数类型来决定具体使用哪个方法，这叫多态。 重写就是子类重写基类的方法，方法名，参数列表和返回值都必须相同，否则就不是重写而是重载。权限修饰符不能小于被重写方法的修饰符。重写方法不能抛出新的异常或者是比被重写方法声明更加宽泛的检查型异常。

### 21. 为什么Java是解释性语言 ###

java程序在运行时字节码才会被jvm翻译成机器码，所以说java是解释性语言

类总是有一个构造函数（可能由java编译器自动提供）

### 22. Mybatis执行流程 ###

1.  获取sqlSessionFactory对象:  
    根据配置文件（全局，sql映射）初始化出Configuration对象  
    解析文件的每一个信息保存在Configuration中，返回包含Configuration的DefaultSqlSession；  
    注意：MappedStatement：代表一个增删改查的详细信息
2.  获取sqlSession对象  
    返回一个DefaultSQlSession对象，包含Executor和Configuration;  
    这一步会创建Executor对象；  
    Executor（根据全局配置文件中的defaultExecutorType创建出对应的Executor）
3.  获取接口的代理对象（MapperProxy）  
    DefaultSqlSession.getMapper（）：拿到Mapper接口对应的MapperProxy；  
    使用MapperProxyFactory创建一个MapperProxy的代理对象  
    代理对象里面包含了，DefaultSqlSession（Executor） 而MyBatis 中 Mapper 和 SQL 语句的绑定正是通过动态代理来完成的，此时我们就已经拿到了具体的SQL语句是怎么写的了。
4.  执行增删改查方法
    
    1）调用DefaultSqlSession的增删改查（Executor）；  
    2）会创建一个StatementHandler对象。（同时也会创建出ParameterHandler和ResultSetHandler）  
    3）调用StatementHandler预编译参数以及设置参数值;  
    使用ParameterHandler来给sql设置参数  
    4）调用StatementHandler的增删改查方法；  
    5）ResultSetHandler封装结果返回

### 23. Mybatis缓存 ###

mybatis 也提供了对缓存的支持， 分为一级缓存和二级缓存。 但是在默认的情况下， 只开启一级缓存（一级缓存是对同一个 SqlSession 而言的）。

**一级缓存：**

*  在同一个 SqlSession 中, Mybatis 会把执行的方法和参数通过算法生成缓存的键值， 将键值和结果存放在一个 基于 PerpetualCache 的 HashMap （key为hashcode+statementId+sql语句。Value为查询出来的结果集映射成的java对象。）本地缓存中， 如果后续的键值一样， 则直接从 HashMap 中获取数据；默认打开一级缓存。
 *  不同的 SqlSession 之间的缓存是相互隔离的；作用域为SqlSession
 *  用一个 SqlSession， 可以通过配置使得在查询前清空缓存；
 *  任何的 UPDATE, INSERT, DELETE 语句都会清空缓存。

**二级缓存：**

二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap 存储，不同在于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache。默认不打开二级缓存，要开启二级缓存，使用二级缓存属性类需要实现Serializable序列化接口(可用来保存对象的状态)，可在它的映射文件中配置 ；

### 24. Mybatis用到的设计模式 ###

Mybatis至少遇到了以下的设计模式的使用：

1.  **Builder模式** :
    
    例如 `SqlSessionFactoryBuilder`、`XMLConfigBuilder`、`XMLMapperBuilder`、`XMLStatementBuilder`、`CacheBuilder`；
2.  **工厂模式** :
    
    例如`SqlSessionFactory`、`ObjectFactory`、`MapperProxyFactory`；
3.  **单例模式** :例如`ErrorContext`和`LogFactory`；
4.  **代理模式** :Mybatis实现的核心，比如`MapperProxy`、`ConnectionLogger`，用的jdk的动态代理；还有`executor.loader`包使用了cglib或者javassist达到延迟加载的效果；
5.  **组合模式** :例如`SqlNode`和各个子类`ChooseSqlNode`等；
6.  **模板方法模式** : 例如`BaseExecutor`和`SimpleExecutor`，还有`BaseTypeHandler`和所有的子类例如`IntegerTypeHandler`；
7.  **适配器模式** : 例如Log的Mybatis接口和它对jdbc、log4j等各种日志框架的适配实现；
8.  **装饰者模式** : 例如`cache`包中的`cache.decorators`子包中等各个装饰者的实现；
9.  **迭代器模式** : 例如迭代器模式`PropertyTokenizer`；

### 25. ConcurrentHashMap 1.7和1.8的区别 ###

##### 1、整体结构 #####

1.7：Segment + HashEntry + Unsafe

1.8: 移除Segment，使锁的粒度更小，Synchronized + CAS + Node + Unsafe

##### 2、put（） #####

1.7：先定位Segment，再定位桶，put全程加锁，没有获取锁的线程提前找桶的位置，并最多自旋64次获取锁，超过则挂起。

1.8：由于移除了Segment，类似HashMap，可以直接定位到桶，拿到first节点后进行判断，1、为空则CAS插入；2、为-1则说明在扩容，则跟着一起扩容；3、else则加锁put（类似1.7）

##### 3、get（） #####

基本类似，由于value声明为volatile，保证了修改的可见性，因此不需要加锁。

##### 4、resize（） #####

1.7：跟HashMap步骤一样，只不过是搬到单线程中执行，避免了HashMap在1.7中扩容时死循环的问题，保证线程安全。

1.8：支持并发扩容，HashMap扩容在1.8中由头插改为尾插（为了避免死循环问题），ConcurrentHashmap也是，迁移也是从尾部开始，扩容前在桶的头部放置一个hash值为-1的节点，这样别的线程访问时就能判断是否该桶已经被其他线程处理过了。

##### 5、size（） #####

1.7：很经典的思路：计算两次，如果不变则返回计算结果，若不一致，则锁住所有的Segment求和。

1.8：用baseCount来存储当前的节点个数，通过累加baseCount和CounterCell数组中的数量，即可得到元素的总个数；

### 26. 地址栏输入URL发生了什么 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70]

### 27. 组合和聚合的区别： ###

组合和聚合是有很大区别的，这个区别不是在形式上，而是在本质上：  
比如A类中包含B类的一个引用b，当**A类的一个对象消亡时，b这个引用所指向的对象也同时消亡**（没有任何一个引用指向它，成了垃圾对象），这种情况叫做组合，

反之b所指向的对象还会有另外的引用指向它，这种情况叫聚合。

### 28. OSI七层模型 ###

1.  应用层
    
    网络服务与最终用户的一个接口。
    
    协议有：**HTTP FTP TFTP SMTP SNMP DNS TELNET HTTPS POP3 DHCP**
2.  表示层
    
    数据的表示、安全、压缩。（在五层模型里面已经合并到了应用层）
    
    格式有，**JPEG、ASCll、DECOIC、加密格式等**
3.  会话层
    
    建立、管理、终止会话。（在五层模型里面已经合并到了应用层）
    
    **对应主机进程，指本地主机与远程主机正在进行的会话**
4.  传输层
    
    定义传输数据的协议端口号，以及流控和差错校验。
    
    协议有：**TCP UDP，数据包一旦离开网卡即进入网络传输层**
5.  网络层
    
    进行逻辑地址寻址，实现不同网络之间的路径选择。
    
    协议有：**ICMP IGMP IP（IPV4 IPV6）**
6.  数据链路层
    
    建立逻辑连接、进行硬件地址寻址、差错校验等功能。（由底层网络定义协议）
    
    将比特组合成字节进而组合成帧，用MAC地址访问介质，错误发现但不能纠正。
7.  物理层
    
    建立、维护、断开物理连接。（由底层网络定义协议）
    
    ![img][]

![åœ¨è¿™é‡Œæ’å¥å›¾ç‰‡æè¿°][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTIzNjIy_size_16_color_FFFFFF_t_70]

### 29. 讲一下CMS垃圾回收器 ###

CMS是concurrent Mark sweep的简写，并发标记清除，相较于其他垃圾回收器有以下特点：

1.  回收速度快，系统停顿时间少（Stop The World）
2.  采用标记清除算法，且只能在老年代进行回收
3.  过程分为四步：1） 初始标记 2） 并发标记 3）重新标记 4）并发清除
4.  大部分web应用使用在老年代使用CMS进行垃圾回收、新生代使用Parllernew

### 30. Spring事务管理原理？ ###

通过这样一个动态代理对所有需要事务管理的Bean进行加载，并根据配置在invoke方法中对当前调用的 方法名进行判定，并在method.invoke方法前后为其加上合适的事务管理代码，这样就实现了Spring式的事务管理。Spring中的AOP实 现更为复杂和灵活，不过基本原理是一致的。

### 31. JDK动态代理和GClib动态代理 ###

#### 31.1、JDK动态代理具体实现原理： ####

*  通过实现InvocationHandlet接口创建自己的调用处理器；
 *  通过为Proxy类指定ClassLoader对象和一组interface来创建动态代理；
 *  通过反射机制获取动态代理类的构造函数，其唯一参数类型就是调用处理器接口类型；
 *  通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数参入；

JDK动态代理是面向**接口**的代理模式，如果被代理目标没有接口那么Spring也无能为力，Spring通过Java的反射机制生产被代理接口的新的匿名实现类，重写了其中AOP的增强方法。

#### 31.2、CGLib动态代理： ####

CGLib是一个强大、高性能的Code生产类库，可以实现运行期动态扩展java类，Spring在运行期间通过 CGlib继承要被动态代理的类，重写父类的方法，实现AOP面向切面编程呢。

#### 31.3、两者对比： ####

JDK动态代理是面向接口的。

CGLib动态代理是通**过字节码底层继承要代理类**来实现。

#### 31.4、使用注意： ####

如果要被代理的对象是个实现类，那么Spring会使用JDK动态代理来完成操作（Spirng默认采用JDK动态代理实现机制）；

如果要被代理的对象不是个实现类那么，Spring会强制使用CGLib来实现动态代理。

#### 32. Threadlocal 内存泄漏问题 ####

主要原因是Map里面的Entry，它继承了弱引用，key 会被作为父类的属性值，所以GC的时候key被回收了，而value还在（value会有一个来自thread的强引用，一般不会被gc）虽然Java团队在get、put的时候会清理这样的value，但也不是任何时候都会清理，所以存在内存泄漏  
深层次原因是，当threadlocal的生命周期跟线程一样长的时候，那些孤儿value永远不会被回收。例如线程池里面的threadlocal，**最佳实践就是使用 remove 方法手动清理 threadlocal，达到 100% 防止泄漏的办法**

#### 33.StringBuilder 安全怎么实现的？详细描述怎么扩容的？ ####

实际的String builder的操作中append `count += len` 不是一个原子操作，很明显的i++类问题，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70_pic_center 5]  
而StringBuilder 采用的是用Synchronize关键字修饰append方法：  
![在这里插入图片描述][20200312114850437.png_pic_center]  
扩容的 newCapacity = (value.length << 1) + 2；**增加为自身长度的一倍然后再加2**  
![在这里插入图片描述][20200312114221835.png]

[Java _ equals _ hashCode]: https://www.cnblogs.com/yuxiaole/p/9570850.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200303085702642.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg==,size_16,color_FFFFFF,t_70#pic_center
[Link 1]: http://www.bimowu.com/kstudy-web/clienttopic/view.do?topicId=856
[JDK 6_JDK 7_substring]: http://www.bimowu.com/kstudy-web/clienttopic/view.do?topicId=857
[new String_abc]: http://www.bimowu.com/kstudy-web/clienttopic/view.do?topicId=860
[Link 2]: https://blog.csdn.net/AAAhxz/article/details/103777586
[img-FExoYase-1583196535784_https_camo.githubusercontent.com_04f7d7f070f31c50f3d09da26f9459fdea2a7b4a_68747470733a2f2f6d792d626c6f672d746f2d7573652e6f73732d636e2d6265696a696e672e616c6979756e63732e636f6d2f323031392d362f6a646b312e382545342542392538422545352538392538442545372539412538342545352538362538352545392538332541382545372542422539332545362539452538342d486173684d61702e6a7067]: https://img-blog.csdnimg.cn/20200303085203736.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200303085228911.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200303085253851.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/2020030308531492.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20200303085327298.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200304211406695.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg==,size_16,color_FFFFFF,t_70
[img]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2dpZi9iR3JpYkd0WUMzbUplYlJPYU5mcGFUR3hhdWFBanV3VTRIVVhQT0h2bFZueUVrN3B5cldpY29zaGVYdGppYzJtanF2RzhZM1ZncEFTdWo3WFFyT3ZLa0hmZy82NDA?x-oss-process=image/format,png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTIzNjIy_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190105164025264.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTIzNjIy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20200312114916347.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FBQWh4eg==,size_16,color_FFFFFF,t_70#pic_center
[20200312114850437.png_pic_center]: https://img-blog.csdnimg.cn/20200312114850437.png#pic_center
[20200312114221835.png]: https://img-blog.csdnimg.cn/20200312114221835.png