本文深入解析Java面试中常考的知识点，涵盖Java基础、集合框架、多线程、Web技术、JVM等核心内容，旨在帮助读者巩固Java技能，备战面试。
最近几天真的很烦躁，包括在群里和其他人交流，向大佬咨询一些问题时，以及拒绝培训班的游说时都会被来这么一句：“你基础怎么样？”但我自信满满的打出“还不错”的时候，就会被各种问题，或者直接甩过来的一些题目打脸。所以，我在网上收集了一些面试中会问到的Java问题，也算是洗心革面，重新学习~（2020.5.13）
啊话说这确实有点多，而且我不想百度答案之后Ctrl+cv过来，但自从发现CSDN发布博客不会改变时间之后，我就决定每天做1-2个，持续更新~（2020.5.20）
这是近期整理的面经问题，会慢慢发布，大家敬请期待！
巨详细的Java面试问题及复习内容（Java基础--第一部分）
巨详细的Java面试问题及复习内容（Java基础--第二部分）
巨详细的Java面试问题及复习内容（Java并发--第三部分）
巨详细的Java面试问题及复习内容（Java虚拟机--第四部分）
2、描述一下ArrayList和LinkedList各自实现和区别
3、反射中，Class.forName和classloader的区别
4、说说Java集合类，list、set、queue、map实现类
6、string、stringbuilder、stringbuffer区别
2、一个页面从输入 URL 到页面加载显示完成，这个过程中都发生了什么
1、ConcurrentHashMap与HashMap的区别
一、Java基础
1、String类为什么是final的
//附上String类的源码
public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence为什么String类是final的？主要是为了保持String是不可变的，因为被final修饰的类不能被继承，也就是说不能拥有自己的子类、不能被重写、需要进行初始化操作，所以String是final的保证了String的安全性和效率，因为在第二次给String赋值时不是在原地址上修改数据，而是重新指向一个对象，新地址，才有了字符串常量池。
解释一下字符串常量池：创建字符串时，如果该字符串已经存在于池中，则将返回现有字符串的引用，而不是创建新对象。这时就会有多个String变量引用指向同一个地址的情况，这也是字符串的处理速度快的原因；如果字符串随时都可以被改变，那么改变一个字符串的值，对其进行引用的字符串就会错误，这样是很危险的，比如黑客直接改变数据库账号密码引用的字符串指向对象的值，就会造成安全漏洞。
因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享，不会因为线程安全问题而使用同步，字符串自己就是线程安全的。
因为字符串是不可变的，所以在它创建的时候HashCode就被缓存了，不需要重新计算，这就使字符串很适合作为Map中的键，字符串的处理速度要快过其它的键对象，这就是为什么HashMap中的键往往都使用字符串。而HashCode在java中经常配合基于散列的集合一起正常运行，这样的散列集合包括HashSet、HashMap以及HashTable，因为当向集合中插入对象时，是通过hashcode判别在集合中是否已存在该对象，不是通过equals方法低效率的逐个比较。
2、描述一下ArrayList和LinkedList各自实现和区别
List是接口类，ArrayList和LinkedList是List的实现类。
ArrayList是动态数组（顺序表）的数据结构，顺序表的存储地址是连续的所以查找比较快，但在插入和删除时由于需要把其它的元素顺序向后移动（或向前移动）所以比较耗时。
LinkedList是链表的数据结构，链表的存储地址是不连续的，每个存储地址通过指针指向，在查找时需要进行通过指针遍历元素所以在查找时比较慢，由于链表插入时不需移动其它元素所以在插入和删除时比较快。
ArrayList，LinkedList是不同步的，所以如果不要求线程安全的话可以使用ArrayList或LinkedList节省为同步而耗费的开销，也可以通过一些办法包装ArrayList，LinkedList使他们也达到同步，但效率可能会有所降低。
ArrayList的内部实现是基于基础的对象数组的，因此它使用get方法访问列表中的任意一个元素时速度要比LinkedList快；LinkedList中的get方法是按照顺序从列表的一端开始检查直到另外一端；对 LinkedList而言，访问列表中的某个指定元素没有更快的方法了。
时间复杂度
假设有一个很大的列表，里面的元素已经排好序了，这个列表可能是ArrayList类型的也可能是LinkedList类型的，现在对这个列表来进行二分查找来比较分别是ArrayList和LinkedList时的查询速度，基本上ArrayList的时间要明显小于LinkedList的时间，因此在这种情况下不宜用LinkedList，二分查找法使用的随机访问策略，而LinkedList是不支持快速随机访问的，对一个LinkedList做随机访问所消耗的时间与这个list的大小是成比例的，而相应的在ArrayList中进行随机访问所消耗的时间是固定的。
在某些情况 下LinkedList的表现要优于ArrayList，有些算法在LinkedList中实现时效率更高，如果有一个列表要对其进行大量的插入和删除操作，在这种情况下 LinkedList就是一个较好的选择，极端一点，重复的在一个列表的开端插入一个元素，当一个元素被加到ArrayList的最开端时，所有已经存在的元素都会后移，这就意味着数据移动和复制上的开销；相反的，将一个元素加到LinkedList的最开端只是简单的为这个元素分配一个记录，然后调整两个连接；在 LinkedList的开端增加一个元素的开销是固定的，而在ArrayList的开端增加一个元素的开销是与ArrayList的大小成比例的。
空间复杂度
//在LinkedList中有一个私有的内部类，定义如下 private static class Entry { Object element; Entry next; Entry previous; }每个Entry对象列表中有一个元素，同时还有在LinkedList中它的上一个元素和下一个元素，一个有1000个元素的LinkedList对象将有1000个连接在一起的Entry对象，每个对象都对应列表中的一个元素；这样的话，在一个LinkedList结构中将有一个很大的空间开销，因为它要存储这1000个Entity对象的相关信息。
ArrayList使用一个内置的数组来存储元素，这个数组的起始容量是10，当数组需要增长时，新的容量按如下公式获得：新容量=(旧容量*3)/2+1，也就是说每一次容量大概会增长50%，这就意味着，如果有一个包含大量元素的ArrayList对象， 那么最终将有很大的空间会被浪费掉，这个浪费是由ArrayList的工作方式本身造成的。如果没有足够的空间来存放新的元素，数组将不得不被重新进行分 配以便能够增加新的元素。对数组进行重新分配，将会导致性能急剧下降。如果知道一个ArrayList将会有多少个元素，可以通过构造方法来指定容量，还可以通过trimToSize方法在ArrayList分配完毕之后去掉浪费掉的空间。
总结一下
对ArrayList和LinkedList而言，在列表末尾增加一个元素所用的时间开销都是固定的，对 ArrayList而言主要是在内部数组中增加一项指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言这个开销是统一的，会分配一个内部Entry对象。
在ArrayList中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。
LinkedList不支持高效的随机元素访问。
ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。
3、反射中，Class.forName和classloader的区别
Java中的Class.forName()，classLoader,都可用来对类进行加载，Class.forName()除了会将.class文件加载到JVM之外，还会对类进行解释，执行类中的static静态代码块；而classLoader只干一件事，就是将.class加载到JVM中，并不会对static静态代码块中的内容进行解析，只有在new Instance()方法的时候才会对static进行解析。
Class.forName(String name)该方法内部调用的是：Class.forName(className, true, ClassLoader.getClassLoader(caller))
方法：Class.forName(String name, boolean initialize, ClassLoader loader)
参数name代表全限定类名；参数initialize表示是否初始化该类，为true是初始化该类；参数loader 对应的类加载器
Classloder.loaderClass(String name)其实该方法内部调用的是：Classloder. loadClass(name, false)
方法：Classloder. loadClass(String name, boolean resolve)
参数name代表类的全限定类名；参数resolve代表是否解析，resolve为true是解析该类
两者的区别：Class.forName得到的class是已经初始化完成的，Classloder.loaderClass得到的class是还没有链接的。
4、说说Java集合类，list、set、queue、map实现类
在编程中经常需要保存多个数据，一般我们会想到数组，但数组的前提是需要明确的知到要保存的对象的数量，而一旦数组在初始化时指定了长度，那么这个长度就是不可变的，所以当我们需要保存一个可以动态增长的数据(也就是在编译时不知道具体会有多少数量)，Java集合类就是一个很好的选择。
集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类。所以的集合类都位于java.util包下，后来为了处理多线程环境下的并发安全问题，JDK1.5还在java.util.concurrent包下提供了一些多线程支持的集合类。
Collection：一组"对立"的元素，通常这些元素都服从某种规则
List必须保持元素特定的顺序
Set不能有重复元素
Queue保持一个队列(先进先出)的顺序
Map：一组成对的"键值对"对象
Collection和Map的区别在于容器中每个位置保存的元素个数：Collection 每个位置只能保存一个元素(对象)；Map保存的是"键值对"，就像一个小型数据库，可以通过"键"找到该键对应的"值"。
Set
Set继承Collection接口，不能包含重复元素，Set判断两个对象不是使用==来判断，是使用equals方法，新加入的元素会与已有的元素判断equals比较返回false则加入，否则拒绝加入，所以使用Set的时候有两点需要注意：放入的对象要实现equals方法；对set的构造函数中，传入的Collection参数不能包含重复的元素。
HashSet
HashSet实现了Set接口，由哈希表提供支持，不保证Set的迭代顺序；允许使用null值，同时不允许元素有重复，因为HashSet底层是使用HashMap来实现的，HashSet中的元素都存放在HashMap的key上面，value是一个统一的静态变量；
HashSet中添加元素调用add方法，然后会调用HashMap的put方法插入元素，HashMap的put方法插入元素时，会首先判断是否存在key，如果不存在，则插入这个key-value,存在则修改value值；在set中，value值没用，因此往HashSet中添加元素，首先判断key是否存在，不存在插入元素，存在则不做处理；
向HashSet中存入一个元素时，HashSet调用对象的HashCode方法获取对象的HashCode值，根据HashCode值决定对象的存储位置。HashSet判断元素对象是否相同的方法是同时使用HashCode和equals方法来判断；
HashSet判断元素相等方法时，首先判断两个对象的HashCode是否相等，如果不相等，则认为两个对象也不相等，如果相等再判断equals方法是否相等；如果hashCode相等，equals方法不相等，则认为时不同的对象；为什么这样做，主要是为了提高效率，HashCode的效率比equals效率更高，不必每次重新计算Hash值。
LinkedHashSet
linkedHashSet继承自HashSet，但和HashSet不同的是，它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的；当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。 LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet的性能，但在迭代访问Set里的全部元素时(遍历)将有很好的性能(链表很适合进行遍历)。
SortedSet
主要用于排序操作，实现此接口的子类都属于排序子类。
TreeSet
TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态，底层实现是通过二叉树，插入的元素要实现Comparable接口。
EnumSet
EnumSet是一个专门为枚举类设计的集合类，EnumSet中所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显式、或隐式地指定。EnumSet的集合元素也是有序的，它们以枚举值在Enum类内的定义顺序来决定集合元素的顺序。
List
List代表元素有序，可重复的集合，集合中每个元素都有对应的顺序索引，允许加入重复元素，通过索引指定元素的位置，默认按元素的添加顺序设置元素的索引。
ArrayList
ArrayList是基于数组实现的List类，它封装了一个动态的增长的、允许再分配的Object[]数组。
Vector
Vector和ArrayList在用法上几乎完全相同，但由于Vector是一个古老的集合，所以Vector提供了一些方法名很长的方法，但随着JDK1.2以后，java提供了系统的集合框架，就将Vector改为实现List接口，统一归入集合框架体系中.
Stack
Stack是Vector提供的一个子类，用于模拟"栈"这种数据结构(LIFO后进先出)。
LinkedList
实现List接口，能对它进行队列操作，即可以根据索引来随机访问集合中的元素。同时它还实现Deque接口，即能将LinkedList当作双端队列使用，自然也可以被当作"栈来使用"。
ArrayList和Vector最大的区别在于：ArrayList是非线程安全的，而Vector是线程安全的。当一个Iterator被创建并使用时，使用另一个线程修改Vector中的元素时，调用Iterator方法会抛出ConcurrentModificationException异常
Queue
Queue用于模拟"队列"这种数据结构(先进先出 FIFO)，新元素插入(offer)到队列的尾部，访问元素(poll)操作会返回队列头部的元素，队列不允许随机访问队列中的元素。
PriorityQueue
PriorityQueue并不是一个比较标准的队列实现，PriorityQueue保存队列元素的顺序并不是按照加入队列的顺序，而是按照队列元素的大小进行重新排序。
Deque
Deque接口代表一个"双端队列"，双端队列可以同时从两端来添加、删除元素，因此Deque的实现类既可以当成队列使用、也可以当成栈使用。
ArrayDeque
是一个基于数组的双端队列，和ArrayList类似，它们的底层都采用一个动态的、可重分配的Object[]数组来存储集合元素，当集合元素超出该数组的容量时，系统会在底层重新分配一个Object[]数组来存储集合元素
Map
Map用于保存具有"映射关系"的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value。key和value都可以是任何引用类型的数据。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较结果总是返回false。关于Map，我们要从代码复用的角度去理解，java是先实现了Map，然后通过包装了一个所有value都为null的Map就实现了Set集合。
Map的这些实现类和子接口中key集的存储形式和Set集合完全相同(即key不能重复)
Map的这些实现类和子接口中value集的存储形式和List非常类似(即value可以重复、根据索引来查找)
HashMap
HashMap根据键的HashCode值存储数据，具有很快的访问速度，遍历时，获取的元素顺序是随机的；允许null key存在，不支持线程的同步，即同一时刻有多个线程写map，可能导致最终数据不一致。如果需要同步可以用SynchroizedMap方法或者使用ConcurrentHashMap(基于ReentrantLock来实现的)；HashMap是无序的，元素遍历的顺序和插入的顺序是不一致的，如果要一致可以使用下面的LinkedHashMap;和HashSet集合不能保证元素的顺序一样，HashMap也不能保证key-value对的顺序。并且类似于HashSet判断两个key是否相等的标准也是: 两个key通过equals()方法比较返回true、同时两个key的hashCode值也必须相等。
LinkedHashMap
LinkedHashMap也使用双向链表来维护key-value对的次序，该链表负责维护Map的迭代顺序，与key-value对的插入顺序一致(注意和TreeMap对所有的key-value进行排序进行区分)
HashTablb
是一个古老的Map实现类，在处理元素时使用Synchronize，所以它是线程安全的。
Properties
Properties对象在处理属性文件时特别方便(windows平台上的.ini文件)，Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入到属性文件中，也可以把属性文件中的"属性名-属性值"加载到Map对象中。
SortedMap
正如Set接口派生出SortedSet子接口，SortedSet接口有一个TreeSet实现类一样，Map接口也派生出一个SortedMap子接口，SortedMap接口也有一个TreeMap实现类。
TreeMap
TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对(节点)时，需要根据key对节点进行排序。TreeMap可以保证所有的key-value对处于有序状态。同样，TreeMap也有两种排序方式: 自然排序、定制排序。
WeakHashMap
WeakHashMap与HashMap的用法基本相似。区别在于，HashMap的key保留了对实际对象的"强引用"，这意味着只要该HashMap对象不被销毁，该HashMap所引用的对象就不会被垃圾回收。但WeakHashMap的key只保留了对实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，当垃圾回收了该key所对应的实际对象之后，WeakHashMap也可能自动删除这些key所对应的key-value。
IdentityHashMap
IdentityHashMap的实现机制与HashMap基本相似，在IdentityHashMap中，当且仅当两个key严格相等(key1 == key2)时，IdentityHashMap才认为两个key相等。
EnumMap
EnumMap是一个与枚举类一起使用的Map实现，EnumMap中的所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它对应的枚举类。EnumMap根据key的自然顺序(即枚举值在枚举类中的定义顺序) 。
5、HashMap的底层原理与实现结构
HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。
简单来说，HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度依然为O(1)，因为最新的Entry会插入链表头部，仅需简单改变引用链即可，而对于查找操作来讲，此时就需要遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。
在JDK1.6，JDK1.7中，HashMap采用位桶+链表实现，即使用链表处理冲突，而JDK1.8中，HashMap采用位桶+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树。
构造hash表时，如果不指明初始大小，默认大小为16(即Node数组大小16)，如果Node[]数组中的元素达到填充比*Node.length，通过resize()重新调整HashMap大小 变为原来2倍大小,扩容很耗时；当链表数组的容量超过初始容量的0.75时，再散列将链表数组扩大2倍，把原链表数组的搬移到新的数组中，这个值我们称为加载因子，因为提高空间利用率和 减少查询成本的折中，主要是泊松分布，0.75的话碰撞最小。
6、string、stringbuilder、stringbuffer区别
字符串广泛应用 在Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串，String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，这样不仅效率低下，而且大量浪费有限的内存空间。
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类，和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuffer 与 StringBuilder是字符缓冲变量，StringBuffer 与 StringBuilder 中的方法和功能完全是等价的，只是StringBuffer中的方法大都采用了synchronized 关键字进行修饰，因此是线程安全的，而StringBuilder没有这个修饰，可以被认为是线程不安全的。StringBuilder 是在JDK1.5才加入的。jdk的实现中StringBuffer与StringBuilder都继承自AbstractStringBuilder。
1、String类型的字符串对象是不可变的，一旦String对象创建后，包含在这个对象中的字符系列是不可以改变的，直到这个对象被销毁。
2、StringBuilder和StringBuffer类型的字符串是可变的，不同的是StringBuffer类型的是线程安全的，而StringBuilder不是线程安全的。
3、如果是多线程环境下涉及到共享变量的插入和删除操作，StringBuffer则是首选。如果是非多线程操作并且有大量的字符串拼接，插入，删除操作则StringBuilder是首选。毕竟String类是通过创建临时变量来实现字符串拼接的，耗内存还效率不高，怎么说StringBuilder是通过JNI方式实现终极操作的。
4、StringBuilder和StringBuffer的“可变”特性总结如下：
（1）append，insert，delete方法最根本上都是调用System.arraycopy()这个方法来达到目的
（2）substring(int, int)方法是通过重新new String(value, start, end - start)的方式来达到目的。因此，在执行substring操作时，StringBuilder和String基本上没什么区别。
总的来说，三者在执行速度方面的比较：StringBuilder > StringBuffer > String。
1.使用String类的场景：在字符串不经常变化的场景中可以使用String类，例如常量的声明、少量的变量运算。
2.使用StringBuffer类的场景：在频繁进行字符串运算（如拼接、替换、删除等），并且运行在多线程环境中，则可以考虑使用StringBuffer，例如XML解析、HTTP参数解析和封装。
3.使用StringBuilder类的场景：在频繁进行字符串运算（如拼接、替换、和删除等），并且运行在单线程的环境中，则可以考虑使用StringBuilder，如SQL语句的拼装、JSON封装等。
7、HashTable和HashMap区别
1、继承的父类不同
Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口。
2、线程安全性不同
javadoc中关于hashmap的一段描述如下：此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。
Hashtable 中的方法是Synchronize的，而HashMap中的方法在缺省情况下是非Synchronize的。在多线程并发的环境下，可以直接使用Hashtable，不需要自己为它的方法实现同步，但使用HashMap时就必须要自己增加同步处理。（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用Collections.synchronizedMap方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的非同步访问，如下所示：
Map m = Collections.synchronizedMap(new HashMap(...));Hashtable 线程安全很好理解，因为它每个方法中都加入了Synchronize。
3、是否提供contains方法
HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey，因为contains方法容易让人引起误解。
Hashtable则保留了contains，containsValue和containsKey三个方法，其中contains和containsValue功能相同。
4、key和value是否允许null值
其中key和value都是对象，并且不能包含重复key，但可以包含重复的value。
Hashtable中，key和value都不允许出现null值。但是如果在Hashtable中有类似put(null,null)的操作，编译同样可以通过，因为key和value都是Object类型，但运行时会抛出NullPointerException异常，这是JDK的规范规定的。
HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，可能是 HashMap中没有该键，也可能使该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键， 而应该用containsKey()方法来判断。
5、两个遍历方式的内部实现上不同
Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式 。
6、hash值不同
哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。
hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值。
Hashtable计算hash值，直接用key的hashCode()，而HashMap重新计算了key的hash值，Hashtable在求hash值对应的位置索引时，用取模运算，而HashMap在求位置索引时，则用与运算，且这里一般先用hash&0x7FFFFFFF后，再对length取模，&0x7FFFFFFF的目的是为了将负的hash值转化为正值，因为hash值有可能为负数，而&0x7FFFFFFF后，只有符号外改变，而后面的位都不变。
7、内部实现使用的数组初始化和扩容方式不同
HashTable在不指定容量的情况下的默认容量为11，而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。
Hashtable扩容时，将容量变为原来的2倍加1，而HashMap扩容时，将容量变为原来的2倍。
Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11，增加的方式是 old*2+1。
8、String a= “abc” String b = "abc" String c = new String("abc") String d = "ab" + "c" .他们之间用 == 比较的结果
String a = "abc";
String b = "abc";
String c = new String("abc");
String d = "ab" + "c";显而易见的，我们知道String是final的，所以对象a和对象b是字符串常量池中的同一个字符串，所以a b 为 true；
但因为String是final的，所以new一个String对象c，那么 a c 和 b c 都为 false;
同样的，"ab" + "c"就是"abc"，所以a b d 为true，简单总结一下就是第一个问题的字符串常量池知识点：创建字符串时，如果该字符串已经存在于池中，则将返回现有字符串的引用，而不是创建新对象。
9、String类中的方法
关于String类中的方法可以去我的文章紫薇星上的Java——JavaOO（5）进行详细的查看。
10、抽象类和接口的区别
关于抽象类和接口的区别可以去我的文章Java -- 抽象类与接口进行详细的查看。
二、JavaIO
1、IO流
关于IO流可以去我的文章紫薇星上的Java——JavaOO（6）进行详细的查看。
2、NIO
转自https://www.jianshu.com/p/5bb812ca5f8e
传统BIO是一种同步的阻塞IO，IO在进行读写时，该线程将被阻塞，线程无法进行其它操作。IO流在读取时，会阻塞。直到发生以下情况：1、有数据可以读取。2、数据读取完成。3、发生异常。以传统BIO模型为基础，通过线程池的方式维护所有的IO线程，实现相对高效的线程开销及管理。
NIO（JDK1.4）模型是一种同步非阻塞IO，主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector（多路复用器）。传统IO基于字节流和字符流进行操作，而NIO基于Channel和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(多路复用器)用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个线程可以监听多个数据通道。
NIO和传统IO（一下简称IO）之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。
IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。 NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。
NIO优点：
- 通过Channel注册到Selector上的状态来实现一种客户端与服务端的通信。
- Channel中数据的读取是通过Buffer , 一种非阻塞的读取方式。
- Selector 多路复用器 单线程模型， 线程的资源开销相对比较小。
- Channel(通道)。
Channel(通道)
传统IO操作对read()或write()方法的调用，可能会因为没有数据可读/可写而阻塞，直到有数据响应。也就是说读写数据的IO调用，可能会无限期的阻塞等待，效率依赖网络传输的速度。最重要的是在调用一个方法前，无法知道是否会被阻塞。
NIO的Channel抽象了一个重要特征就是可以通过配置它的阻塞行为，来实现非阻塞式的通道。Channel是一个双向通道，与传统IO操作只允许单向的读写不同的是，NIO的Channel允许在一个通道上进行读和写的操作。
- FileChannel:文件
- SocketChannel:
- ServerSocketChannel:
- DatagramChannel: UDP
Buffer(缓冲区)
Bufer顾名思义，它是一个缓冲区，实际上是一个容器，一个连续数组。Channel提供从文件、网络读取数据的渠道，但是读写的数据都必须经过Buffer。
Buffer缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该模块内存。为了理解Buffer的工作原理，需要熟悉它的三个属性：capacity、position和limit。
position和limit的含义取决于Buffer处在读模式还是写模式。不管Buffer处在什么模式，capacity的含义总是一样的。见下图：
capacity、position和limit
- capacity：作为一个内存块，Buffer有固定的大小值，也叫作“capacity”，只能往其中写入capacity个byte、long、char等类型。一旦Buffer满了，需要将其清空（通过读数据或者清楚数据）才能继续写数据。
- position：当你写数据到Buffer中时，position表示当前的位置。出事的position值为0，当写入一个字节数据到Buffer中后，position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity-1。当读取数据时，也是从某个特定位置读，讲Buffer从写模式切换到读模式，position会被重置为0。当从Buffer的position处读取一个字节数据后，position向前移动到下一个可读的位置。
- limit：在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。 写模式下，limit等于Buffer的capacity。当切换Buffer到读模式时， limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到之前写入的所有数据（limit被设置成已写数据的数量，这个值在写模式下就是position）
Buffer的分配：
对Buffer对象的操作必须首先进行分配，Buffer提供一个allocate(int capacity)方法分配一个指定字节大小的对象。向Buffer中写数据：写数据到Buffer中有两种方式：
1.从channel写到Buffer
int bytes = channel.read(buf); //将channel中的数据读取到buf中
2.通过Buffer的put()方法写到Buffer
buf.put(byte); //将数据通过put()方法写入到buf中
- flip()方法：将Buffer从写模式切换到读模式，调用flip()方法会将position设置为0，并将limit设置为之前的position的值。
从Buffer中读数据：从Buffer中读数据有两种方式：
1.从Buffer读取数据到Channel
int bytes = channel.write(buf); //将buf中的数据读取到channel中
2.通过Buffer的get()方法读取数据
byte bt = buf.get(); //从buf中读取一个byte
- rewind()方法：Buffer.rewind()方法将position设置为0，使得可以重读Buffer中的所有数据，limit保持不变。
- clear()与compact()方法：一旦读完Buffer中的数据，需要让Buffer准备好再次被写入，可以通过clear()或compact()方法完成。如果调用的是clear()方法，position将被设置为0，limit设置为capacity的值。但是Buffer并未被清空，只是通过这些标记告诉我们可以从哪里开始往Buffer中写入多少数据。如果Buffer中还有一些未读的数据，调用clear()方法将被"遗忘 "。compact()方法将所有未读的数据拷贝到Buffer起始处，然后将position设置到最后一个未读元素的后面，limit属性依然设置为capacity。可以使得Buffer中的未读数据还可以在后续中被使用。
- mark()与reset()方法：通过调用Buffer.mark()方法可以标记一个特定的position，之后可以通过调用Buffer.reset()恢复到这个position上。
Selector(多路复用器)
Selector与Channel是相互配合使用的，将Channel注册在Selector上之后，才可以正确的使用Selector，但此时Channel必须为非阻塞模式。Selector可以监听Channel的四种状态（Connect、Accept、Read、Write），当监听到某一Channel的某个状态时，才允许对Channel进行相应的操作。
- Connect：某一个客户端连接成功后
- Accept：准备好进行连接
- Read:可读
- Write:可写
3、String 编码UTF-8 和GBK的区别
- UTF8编码格式很强大，支持所有国家的语言，正是因为它的强大，才会导致它占用的空间大小要比GBK大，对于网站打开速度而言，也是有一定影响的。
- GBK编码格式，它的功能少，仅限于中文字符，当然它所占用的空间大小会随着它的功能而减少，打开网页的速度比较快。
Java中UTF-8转GBK之所以不会出现中文乱码，是因为UTF-8编码为兼容性最大的字符集编码，它本身就支持中文字符。在Java开发中，特别是web开发，乱码是一种很常见而且很头疼的问题，这常常是由于页面端、服务端、数据库等几处所使用的字符不一致所致，故开发中，保持编码一致， 往往能减少由于乱码而带来的时间浪费，是一件非常重要的事情。
4、什么时候使用字节流、什么时候使用字符流
在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据的时候要使用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。
字符流处理的单元为2个字节的Unicode字符，操作字符、字符数组或字符串，字节流处理单元为1个字节，操作字节和字节数组；所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点。
如果是读写字符数据的时候则使用字符流，如果读写的数据都不需要转换成字符的时候，则使用字节流。
5、递归读取文件夹下的文件，代码怎么实现
/**
* 递归读取文件夹下的 所有文件
*
* @param testFileDir 文件名或目录名
*/
private static void testLoopOutAllFileName(String testFileDir) {
if (testFileDir == null) {
//因为new File(null)会空指针异常,所以要判断下
return;
}
File[] testFile = new File(testFileDir).listFiles();
if (testFile == null) {
return;
}
for (File file : testFile) {
if (file.isFile()) {
System.out.println(file.getName());
} else if (file.isDirectory()) {
System.out.println("-------this is a directory, and its files are as follows:-------");
testLoopOutAllFileName(file.getPath());
} else {
System.out.println("文件读入有误！");
}
}
}三、JavaWeb
1、session和cookie的区别和联系
cookie 和session 的区别：
- cookie数据存放在客户的浏览器上，session数据放在服务器上。
- cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗，考虑到安全应当使用session。
- session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能，考虑到减轻服务器性能方面，应当使用COOKIE。
- 单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。
cookie 和session 的联系：
- session是通过cookie来工作的
- session和cookie之间是通过$_COOKIE['PHPSESSID']来联系的，通过$_COOKIE['PHPSESSID']可以知道session的id，从而获取到其他的信息。
2、传统JDBC连接方式
- 注册驱动（驱动程序管理类DriverManager）
- 建立连接（数据库连接类Connection）
- 创建statement（声明类Statement）
- 执行sql，得到ResultSet（结果集合类ResultSet）
- 查看结果
- 释放资源
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class javaTest {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
String URL="jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8";
String USER="root";
String PASSWORD="tiger";
//1.加载驱动程序
Class.forName("com.mysql.jdbc.Driver");
//2.获得数据库链接
Connection conn=DriverManager.getConnection(URL, USER, PASSWORD);
//3.通过数据库的连接操作数据库，实现增删改查（使用Statement类）
Statement st=conn.createStatement();
ResultSet rs=st.executeQuery("select * from user");
//4.处理数据库的返回结果(使用ResultSet类)
while(rs.next()){
System.out.println(rs.getString("user_name")+" "
+rs.getString("user_password"));
}
//关闭资源
rs.close();
st.close();
conn.close();
}
}四、JVM
1、Java的内存模型
程序计数器
程序计数器是众多编程语言都共有的一部分，作用是标示下一条需要执行的指令的位置，分支、循环、跳转、异常处理、线程恢复等基础功能都是依赖程序计数器完成的。
对于Java的多线程程序而言，不同的线程都是通过轮流获得cpu的时间片运行的，这符合计算机组成原理的基本概念，因此不同的线程之间需要不停的获得运行，挂起等待运行，所以各线程之间的计数器互不影响，独立存储。这些数据区属于线程私有的内存。
Java虚拟机栈
VM虚拟机栈也是线程私有的，生命周期与线程相同。虚拟机栈描述的是Java方法执行的内存模型：每个方法在执行的同时都会创建一个栈帧(Stack Frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法调用直至执行完的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。
有人将java内存区域划分为栈与堆两部分，在这种粗略的划分下，栈标示的就是当前讲的虚拟机栈，或者是虚拟机栈对应的局部变量表。之所以说这种划分比较粗略是角度不同，这种划分方法关心的是新申请内存的存在空间，而我们目前谈论的是JVM整体的内存划分，由于角度不同，所以划分的方法不同，没有对与错。
局部变量表存放了编译期可知的各种基本类型，对象引用，和returnAddress。其中64位长的long和double占用了2个局部变量空间(slot)，其他类型都占用1个。这也从存储的角度上说明了long与double本质上的非原子性。局部变量表所需的内存在编译期间完成分配，当进入一个方法时，这个方法在栈帧中分配多大的局部变量空间是完全确定的，在方法运行期间不会改变局部变量表大小。
由于栈帧的进出栈，显而易见的带来了空间分配上的问题。如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverFlowError异常；如果虚拟机栈可以扩展，扩展时无法申请到足够的内存，将会抛出OutOfMemoryError。显然，这种情况大多数是由于循环调用与递归带来的。
本地方法栈
本地方法栈与虚拟机栈的作用十分类似，不过本地方法是为native方法服务的。部分虚拟机（比如 Sun HotSpot虚拟机）直接将本地方法栈与虚拟机栈合二为一。与虚拟机栈一样，本地方法栈也会抛出StactOverFlowError与OutOfMemoryError异常。
Java堆
Java堆是虚拟机所管理的内存中最大的一块，在虚拟机启动时创建，此块内存的唯一目的就是存放对象实例，几乎所有的对象实例都在对上分配内存。JVM规范中的描述是：所有的对象实例以及数据都要在堆上分配。但是随着JIT编译器的发展与逃逸分析技术的逐渐成熟，栈上分配(对象只存在于某方法中，不会逃逸出去，因此方法出栈后就会销毁，此时对象可以在栈上分配，方便销毁)，标量替换(新对象拥有的属性可以由现有对象替换拼凑而成，就没必要真正生成这个对象)等优化技术带来了一些变化，目前并非所有的对象都在堆上分配了。
当java堆上没有内存完成实例分配，并且堆大小也无法扩展是，将会抛出OutOfMemoryError异常。Java堆是垃圾收集器管理的主要区域。
方法区
方法区与java堆一样，是线程共享的数据区，用于存储被虚拟机加载的类信息、常量、静态变量、即时编译的代码。JVM规范将方法与堆区分开，但是HotSpot将方法区作为永久代(Permanent Generation)实现。这样方便将GC分代手机方法扩展至方法区，HotSpot的垃圾收集器可以像管理Java堆一样管理方法区。但是这种方向已经逐步在被HotSpot替换中，在JDK1.7的版本中，已经把原本存放在方法区的字符串常量区移出。
运行时常量池
运行时常量池是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等信息外，还有一项信息是常量池(Constant Poll Table)用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后进入方法区的运行时常量池存放。
其中字符串常量池属于运行时常量池的一部分，不过在HotSpot虚拟机中，JDK1.7将字符串常量池移到了java堆中
2、GC算法
首先我们了解一下什么是GC：
GC垃圾收集，Java提供的GC可以自动监测对象是否超过作用域从而达到自动回收内存的目的。
垃圾回收可有效使用内存和防止内存泄露。垃圾回收器通常是作为一个单独的低优先级线程运行，不可预知的情况下对内存堆中已死亡或长久无使用的对象进行清除和回收。
回收机制：分代复制垃圾回收、标记垃圾回收、增量垃圾回收等方式。
JVM的内存空间，从大的层面上来分析包含：新生代空间(Young)和老年代空间（Old）。新生代空间（Young）又被分为2个部分（Eden区域、Survivous区域）和3个板块（1个Eden区域和2个Survivous区域）
一般来说是这样的：
我们来了解一下这些概念：
新生代，顾名思义，主要是用来存放新生的对象。新生代又细分为 Eden区、SurvivorFrom区、SurvivorTo区。
新创建的对象都会被分配到Eden区(如果该对象占用内存非常大，则直接分配到老年代区), 当Eden区内存不够的时候就会触发MinorGC（Survivor满不会引发MinorGC，而是将对象移动到老年代中），在Minor GC开始的时候，对象只会存在于Eden区和Survivor from区，Survivor to区是空的。
Minor GC操作后，Eden区如果仍然存活（判断的标准是被引用了，通过GC root进行可达性判断）的对象，将会被移到Survivor To区。而From区中，对象在Survivor区中每熬过一次Minor GC，年龄就会+1岁，当年龄达到一定值(年龄阈值，可以通过-XX:MaxTenuringThreshold来设置，默认是15)的对象会被移动到年老代中，否则对象会被复制到“To”区。经过这次GC后，Eden区和From区已经被清空。
“From”区和“To”区互换角色，原Survivor To成为下一次GC时的Survivor From区, 总之，GC后，都会保证Survivor To区是空的。
奇怪为什么有 From和To，2块区域？这就要说到新生代Minor GC的算法了：复制算法。把内存区域分为两块，每次使用一块，GC的时候把一块中的内容移动到另一块中，原始内存中的对象就可以被回收了，优点是避免内存碎片。
老年代，随着Minor GC的持续进行，老年代中对象也会持续增长，导致老年代的空间也会不够用，最终会执行Major GC（MajorGC 的速度比 Minor GC 慢很多很多，据说10倍左右）。Major GC使用的算法是：标记清除（回收）算法或者标记压缩算法。
标记清除（回收）：首先会从GC root进行遍历，把可达对象（存过的对象）打标记；再从GC root二次遍历，将没有被打上标记的对象清除掉。
优点：老年代对象一般是比较稳定的，相比复制算法，不需要复制大量对象。之所以将所有对象扫描2次，看似比较消耗时间，其实不然，是节省了时间。举个栗子，数组 1,2,3,4,5,6。删除2,3,4，如果每次删除一个数字，那么5,6要移动3次，如果删除1次，那么5,6只需移动1次。
缺点：这种方式需要中断其他线程（STW），相比复制算法，可能产生内存碎片。
标记压缩：和标记清除算法基本相同，不同的就是，在清除完成之后，会把存活的对象向内存的一边进行压缩，这样就可以解决内存碎片问题。
当老年代也满了装不下的时候，就会抛出OOM（Out of Memory）异常。
永久代（元空间），在Java8中，永久代已经被移除，被一个称为“元数据区”（元空间，Metaspace）的区域所取代。
值得注意的是：元空间并不在虚拟机中，而是使用本地内存（之前，永久代是在jvm中）。这样，解决了以前永久代的OOM问题，元数据和class对象存在永久代中，容易出现性能问题和内存溢出，毕竟是和老年代共享堆空间。java8后，永久代升级为元空间独立后，也降低了老年代GC的复杂度。
接下来我们说一下四大GC算法：
引用计数算法（Reference counting）
每个对象在创建的时候，就给这个对象绑定一个计数器。每当有一个引用指向该对象时，计数器加一；每当有一个指向它的引用被删除时，计数器减一。这样，当没有引用指向该对象时，该对象死亡，计数器为0，这时就应该对这个对象进行垃圾回收操作。为每个对象额外存储一个计数器 RC ，根据 RC 的值来判断对象是否死亡，从而判断是否执行 GC 操作。
优点：
- 简单
- 计算代价分散
- “幽灵时间”短（幽灵时间指对象死亡到回收的这段时间，处于幽灵状态）
缺点：
- 不全面（容易漏掉循环引用的对象）
- 并发支持较弱
- 占用额外内存空间
标记-清除算法
最基础的垃圾收集算法是“标记-清除”(Mark Sweep)算法，正如名字一样，算法分为2个阶段：1.标记处需要回收的对象，2.回收被标记的对象。标记算法分为两种:1.引用计数算法(Reference Counting) 2.可达性分析算法(Reachability Analysis)。由于引用技术算法无法解决循环引用的问题，所以这里使用的标记算法均为可达性分析算法。
如图所示，当进行过标记清除算法之后，出现了大量的非连续内存。当java堆需要分配一段连续的内存给一个新对象时，发现虽然内存清理出了很多的空闲，但是仍然需要继续清理以满足“连续空间”的要求。所以说，这种方法比较基础，效率也比较低下。
优点：
- 最大的优点是，相比于引用计数法，标记—清除算法中每个活着的对象的引用只需要找到一个即可，找到一个就可以判断它为活的。
- 此外，这个算法相比于引用计数法更全面，在指针操作上也没有太多的花销。更重要的是，这个算法并不移动对象的位置（后面俩算法涉及到移动位置的问题）。
缺点：
- 很长的幽灵时间，判断对象已经死亡，消耗了很多时间，这样从对象死亡到对象被回收之间的时间过长。
- 每个活着的对象都要在标记阶段遍历一遍；所有对象都要在清除阶段扫描一遍，因此算法复杂度较高。
- 没有移动对象，导致可能出现很多碎片空间无法利用的情况。
复制算法
为了解决效率与内存碎片问题，复制(Copying)算法出现了，它将内存划分为两块相等的大小，每次使用一块，当这一块用完了，就讲还存活的对象复制到另外一块内存区域中，然后将当前内存空间一次性清理掉。这样的对整个半区进行回收，分配时按照顺序从内存顶端依次分配，这种实现简单，运行高效。不过这种算法将原有的内存空间减少为实际的一半，代价比较高。
从图中可以看出，整理后的内存十分规整，但是白白浪费一般的内存成本太高。然而这其实是很重要的一个收集算法，因为现在的商业虚拟机都采用这种算法来回收新生代。IBM公司的专门研究表明，新生代中的对象98%都是“朝生夕死”的，所以不需要按照1:1的比例来划分内存。HotSpot虚拟机将Java堆划分为年轻代(Young Generation)、老年代(Tenured Generation），其中年轻代又分为一块Eden和两块Survivor。
所有的新建对象都放在年轻代中，年轻代使用的GC算法就是复制算法。其中Eden与Survivor的内存大小比例为8:2，其中Eden由1大块组成，Survivor由2小块组成。每次使用内存为1Eden+1Survivor，即90%的内存。由于年轻代中的对象生命周期往往很短，所以当需要进行GC的时候就将当前90%中存活的对象复制到另外一块Survivor中，原来的Eden与Survivor将被清空。但是这就有一个问题，我们无法保证每次年轻代GC后存活的对象都不高于10%。所以在当活下来的对象高于10%的时候，这部分对象将由Tenured进行担保，即无法复制到Survivor中的对象将移动到老年代。
优点：
- 实现简单
- 不产生内存碎片
- 每次运行，总有一半内存是空的，导致可使用的内存空间只有原来的一半。
标记-整理算法
复制算法在极端情况下(存活对象较多)效率变得很低，并且需要有额外的空间进行分配担保。所以在老年代中这种情况一般是不适合的。
所以就出现了标记-整理(Mark-Compact)算法。与标记清除算法一样，首先是标记对象，然而第二步是将存货的对象向内存一段移动，整理出一块较大的连续内存空间。
优点：
- 该算法不会像标记-清除算法那样产生大量的碎片空间。
- 如果存活的对象过多，整理阶段将会执行较多复制操作，导致算法效率降低。
复制算法与标记-整理算法的区别在于，复制算法不是在同一个区域复制，而是将所有存活的对象复制到另一个区域内。
- 不同算法有不同的优点和缺点，除了引用计数法不常用外，其他三种算法在现在的java虚拟机上也是很常见的，间接说明了这几个经典算法还是有其适用性的。
- Java堆分为年轻代有年老代，其中年轻代分为1个Eden与2个Survior，同时只有1个Eden与1个Survior处于使用中状态，又有年轻代的对象生存时间为往往很短，因此使用复制算法进行垃圾回收。
- 年老代由于对象存活期比较长，并且没有可担保的数据区，所以往往使用标记-清除与标记-整理算法进行垃圾回收。
**阿里面经问题
具体问题可查看文章面经|2020阿里暑期实习电话面试|一面
1、spring的原理和核心
IOC、DI、AOP
IOC（Inversion of Control）控制反转
简单地说，由spring来负责控制对象的生命周期和对象间的关系。传统的Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IOC是有专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建；就是把new对象实例化的工作交给spring容器来完成，spring帮我们负责销毁对象，控制对象的生命周期，在需要使用对象的时候直接向spring申请即可。控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。
DI（Dependency Injection）依赖注入
组件之间依赖关系由容器在运行期决定，由容器动态的将某个依赖关系注入到组件之中。在系统运行中，动态的向某个对象提供它所需要的其他对象。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。
注入方式：set方式注入、构造器注入、工厂方法注入，注解方式注入set方式注入：目标对象中需要提供相关的set方法，需要调用set方法将资源传递给目标对象使用。
构造器注入：目标对象中提供带参数的构造方法，通过构造方法将资源传递给目标对象使用。
静态工厂注入：调用静态工厂的方法来获取自己需要的对象。
实例工厂注入：实例工厂的意思是获取对象实例的方法不是静态的，所以你需要首先new工厂类，再调用普通的实例方法
注解方式注入：Spring2.5之后，Spring增加了注解注入。@Autowired 注解，可以对Bean类成员变量、方法及构造函数进行标注，完成依赖注入的自动装配工作。使用@Autowired可以省略Bean类的待依赖注入对象的set方法。@Resource注解的功能和@Autowired注解功能相近，@Resource有name和type两个主要的属性。Spring容器对于@Resource注解的name属性解析为bean的名字，type属性则解析为bean的类型。因此使用name属性，则按byName模式的自动注入策略，如果使用type属性则按 byType模式自动注入策略。如果两个属性都未指定，Spring容器将通过反射技术默认按byName模式注入。
AOP（Aspect-OrientedProgramming）面向切面
纵向重复的代码横向抽取，使用过滤器 Filter
在面向对象编程（oop）思想中，我们将事物纵向抽成一个个的对象。而在面向切面编程中，我们将一个个的对象某些类似的方面横向抽成一个切面，对这个切面进行一些如权限控制、事物管理，记录日志等公用操作处理的过程就是面向切面编程的思想。
2、一个页面从输入 URL 到页面加载显示完成，这个过程中都发生了什么
输入URL、DNS转换、HTTP服务器请求、服务器处理请求、网站后台处理、浏览器解析渲染、断开链接
在浏览器输入url后，浏览器并不能直接通过url找到服务器，而是要通过ip地址
DNS作为将域名和IP地址相互映射的一个分布式数据库，能够使人更方便地访问互联网。而不用去记住能够被机器直接读取的IP数串。通过主机名，最终得到该主机名对应的IP地址的过程叫做域名解析（或主机名解析）
HTTP 请求分为三个部分：TCP 三次握手、http 请求响应信息、关闭 TCP 连接
第一次握手：建立连接，发送包到服务器，等待服务器确认；
第二次握手：服务器收到包，必须确认客户的包，同时自己也发送一个包；
第三次握手：客户端（浏览器）收到服务器的包，向服务器发送确认包，完成三次握手；
三次握手结束后，开始发送 HTTP 请求报文
服务器对于不同用户发送的请求，会结合配置文件，把不同请求委托给服务器上处理对应请求的程序进行处理（例如CGI脚本，JSP脚本，servlets，ASP脚本，服务器端JavaScript，或者一些其它的服务器端技术等），然后返回后台程序处理产生的结果作为响应
网站处理，就是实际后台处理的工作。后台开发现在有很多框架，大部分都还是按照MVC设计模式进行搭建的。MVC是Model（模型）、View（视图）和Controller（控制）
通过后台处理返回的html字符串结果会被浏览器读取解析，对应就是html页面加载、解析、渲染的工作
当数据传送完毕，需要断开 tcp 连接，此时发起 tcp 四次挥手
TCP客户端发送一个FIN，用来关闭客户到服务器的数据传送；
服务器收到这个FIN，它发回一个ACK，确认序号为收到的序号加1；
服务器关闭客户端的连接，发送一个FIN给客户端；
客户端发回ACK报文确认，并将确认序号设置为收到序号加1；
3、POST和GET的区别
GET提交的数据放在URL中，POST则不会，这是最显而易见的差别。这点意味着GET更不安全（POST也不安全，因为HTTP是明文传输抓包就能获取数据内容，要想安全还得加密）；
GET回退浏览器无害，POST会再次提交请求（GET方法回退后浏览器再缓存中拿结果，POST每次都会创建新资源）；
GET提交的数据大小有限制（是因为浏览器对URL的长度有限制，GET本身没有限制），POST没有；
GET可以被保存为书签（BookMark），POST不可以；
GET会被浏览器主动cache，而POST不会，除非手动设置；
GET只允许ASCII字符，POST没有限制；
GET只能进行url编码，而POST支持多种编码方式；
GET会保存在浏览器历史记录中，POST不会；
GET产生一个TCP数据包；POST产生两个TCP数据包
对于GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数据）；
对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200 ok（返回数据）；
在网络环境好的情况下，发一次包的时间和发两次包的时间差别基本可以无视。而在网络环境差的情况下，两次包的TCP在验证数据包完整性上，有非常大的优点；
并不是所有浏览器都会在POST中发送两次包，Firefox就只发送一次
4、转发和重定向的区别
Forward和Redirect代表了两种请求转发方式：直接转发和间接转发。
直接转发方式（Forward），客户端和浏览器只发出一次请求，Servlet、HTML、JSP或其它信息资源，由第二个信息资源响应该请求，在请求对象request中，保存的对象对于每个信息资源是共享的；
地址栏不发生变化，显示的是上一个页面的地址
请求次数：只有1次请求
根目录：http://localhost:8080/项目地址/，包含了项目的访问地址
请求域中数据不会丢失
间接转发方式（Redirect）实际是两次HTTP请求，服务器端在响应第一次请求的时候，让浏览器再向另外一个URL发出请求，从而达到转发的目的；
地址栏：显示新的地址
请求次数：2次
根目录：http://localhost:8080/ ，没有项目的名字
请求域中的数据会丢失，因为是2次请求
5、为什么要使用自定义的异常类
Java虽然提供了丰富的异常处理类，但是在项目中还会经常使用自定义异常，其主要原因是Java提供的异常类在某些情况下还是不能满足实际需球。例如以下情况：
系统中有些错误是符合Java语法，但不符合业务逻辑；
在分层的软件结构中，通常是在表现层统一对系统其他层次的异常进行捕获处理；
6、红黑树的特性
每个结点是黑色或者红色。
根结点是黑色。
每个叶子结点（NIL）是黑色。 [注意：这里叶子结点，是指为空(NIL或NULL)的叶子结点！]
如果一个结点是红色的，则它的子结点必须是黑色的。
每个结点到叶子结点NIL所经过的黑色结点的个数一样的。[确保没有一条路径会比其他路径长出俩倍，所以红黑树是相对接近平衡的二叉树的！]
具体的红黑树操作以及左旋右旋，变色这些操作，可以参考文章紫薇星上的Java——比较器与二叉树、红黑树
7、如何在100 亿URL中判断某个URL是否存在
问题描述：如果现在有一台电脑接收了1亿个url，现在又有一个url过来，如何在短时间内确定这个url之前有没有来过？
解决方法：布隆过滤器
当输入一个 url 的时候，此时这个 url 会经过 k 个哈希函数处理，得到多个哈希值（v1,v2,...,vk）之后分别将这些哈希值除以数组的长度 m，和对 m 取模，得到这些哈希值对应在数组的下标位置，最后将这些下标的元素都置为 1；
这是再来一个url时，它经过上述处理之后，会得到多个数组的下标位置，如果这些下标的元素值都已经为 1 了，说明该在黑名单里面，否则不在；
但是这样有一个缺点就是，已经存在的数据是绝对可以查找到的，但是不存在的数据也有可能会被认为时存在过的，具有一定的失误率。
**京东面经问题
具体问题可以查看文章面经 | 2021京东“寻猎计划”电话面试 | 一二面
1、ConcurrentHashMap与HashMap的区别
最大的区别就是ConcurrentHashMap是线程安全的，hashMap不是线程安全的。
- 底层采用分段的数组+链表实现，线程安全
- 通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。(读操作不加锁，由于HashEntry的value变量是 volatile的，也能保证读取到最新的值。)
- Hashtable的synchronized是针对整张Hash表的，即每次锁住整张表让线程独占，ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术
- 有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁
- 扩容：段内扩容（段内元素超过该段对应Entry数组长度的75%触发扩容，不会对整个Map进行扩容），插入前检测需不需要扩容，有效避免无效扩容
2、MySql的索引
MySQL索引的建立对于MySQL的高效运行是很重要的，索引可以大大提高MySQL的检索速度。
索引分单列索引和组合索引。单列索引，即一个索引只包含单个列，一个表可以有多个单列索引，但这不是组合索引。组合索引，即一个索引包含多个列。
创建索引时，需要确保该索引是应用在 SQL 查询语句的条件(一般作为 WHERE 子句的条件)。实际上，索引也是一张表，该表保存了主键与索引字段，并指向实体表的记录。
上面都在说使用索引的好处，但过多的使用索引将会造成滥用。因此索引也会有它的缺点：虽然索引大大提高了查询速度，同时却会降低更新表的速度，如对表进行INSERT、UPDATE和DELETE。因为更新表时，MySQL不仅要保存数据，还要保存一下索引文件。建立索引会占用磁盘空间的索引文件。
拿汉语字典的目录页（索引）打比方，我们可以按拼音、笔画、偏旁部首等排序的目录（索引）快速查找到需要的字。
3、排序算法
关于算法可以去我的文章紫薇星上的数据结构（10）进行详细的查看。
而说到排序算法，就要说一下十大排序算法，十种常见排序算法可以分为两大类：
- 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
- 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
- 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
- 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
- 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
- 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。
1、冒泡排序
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
function bubbleSort(arr) {
varlen = arr.length;
for(vari = 0; i < len - 1; i++) {
for(varj = 0; j < len - 1 - i; j++) {
if(arr[j] > arr[j+1]) { // 相邻元素两两对比
vartemp = arr[j+1]; // 元素交换
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
returnarr;
}2、选择排序
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
- 初始状态：无序区为R[1..n]，有序区为空；
- 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
- n-1趟结束，数组有序化了。
function selectionSort(arr) {
varlen = arr.length;
varminIndex, temp;
for(vari = 0; i < len - 1; i++) {
minIndex = i;
for(varj = i + 1; j < len; j++) {
if(arr[j] < arr[minIndex]) { // 寻找最小的数
minIndex = j; // 将最小数的索引保存
}
}
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
returnarr;
} 表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。
3、插入排序
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
function insertionSort(arr) {
varlen = arr.length;
varpreIndex, current;
for(vari = 1; i < len; i++) {
preIndex = i - 1;
current = arr[i];
while(preIndex >= 0 && arr[preIndex] > current) {
arr[preIndex + 1] = arr[preIndex];
preIndex--;
}
arr[preIndex + 1] = current;
}
returnarr;
}插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
4、希尔排序
1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列个数k，对序列进行k 趟排序；
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
function shellSort(arr) {
varlen = arr.length;
for(vargap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
// 注意：这里和动图演示的不一样，动图是分组执行，实际操作是多个分组交替执行
for(vari = gap; i < len; i++) {
varj = i;
varcurrent = arr[i];
while(j - gap >= 0 && current < arr[j - gap]) {
arr[j] = arr[j - gap];
j = j - gap;
}
arr[j] = current;
}
}
returnarr;
}希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。动态定义间隔序列的算法是《算法（第4版）》的合著者Robert Sedgewick提出的。
5、归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
- 把长度为n的输入序列分成两个长度为n/2的子序列；
- 对这两个子序列分别采用归并排序；
- 将两个排序好的子序列合并成一个最终的排序序列。
function mergeSort(arr) {
varlen = arr.length;
if(len < 2) {
returnarr;
}
varmiddle = Math.floor(len / 2),
left = arr.slice(0, middle),
right = arr.slice(middle);
returnmerge(mergeSort(left), mergeSort(right));
}
function merge(left, right) {
varresult = [];
while(left.length>0 && right.length>0) {
if(left[0] <= right[0]) {
result.push(left.shift());
} else{
result.push(right.shift());
}
}
while(left.length)
result.push(left.shift());
while(right.length)
result.push(right.shift());
returnresult;
}归并排序是一种稳定的排序方法。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。
6、快速排序
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
- 从数列中挑出一个元素，称为 “基准”（pivot）；
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
function quickSort(arr, left, right) {
varlen = arr.length,
partitionIndex,
left = typeofleft != 'number'? 0 : left,
right = typeofright != 'number'? len - 1 : right;
if(left < right) {
partitionIndex = partition(arr, left, right);
quickSort(arr, left, partitionIndex-1);
quickSort(arr, partitionIndex+1, right);
}
returnarr;
}
function partition(arr, left ,right) { // 分区操作
varpivot = left, // 设定基准值（pivot）
index = pivot + 1;
for(vari = index; i <= right; i++) {
if(arr[i] < arr[pivot]) {
swap(arr, i, index);
index++;
}
}
swap(arr, pivot, index - 1);
returnindex-1;
}
function swap(arr, i, j) {
vartemp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}7、堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
- 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
- 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
- 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
varlen; // 因为声明的多个函数都需要数据长度，所以把len设置成为全局变量
function buildMaxHeap(arr) { // 建立大顶堆
len = arr.length;
for(vari = Math.floor(len/2); i >= 0; i--) {
heapify(arr, i);
}
}
function heapify(arr, i) { // 堆调整
varleft = 2 * i + 1,
right = 2 * i + 2,
largest = i;
if(left < len && arr[left] > arr[largest]) {
largest = left;
}
if(right < len && arr[right] > arr[largest]) {
largest = right;
}
if(largest != i) {
swap(arr, i, largest);
heapify(arr, largest);
}
}
function swap(arr, i, j) {
vartemp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
function heapSort(arr) {
buildMaxHeap(arr);
for(vari = arr.length - 1; i > 0; i--) {
swap(arr, 0, i);
len--;
heapify(arr, 0);
}
returnarr;
}8、计数排序
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
- 找出待排序的数组中最大和最小的元素；
- 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
- 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
- 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
function countingSort(arr, maxValue) {
varbucket = newArray(maxValue + 1),
sortedIndex = 0;
arrLen = arr.length,
bucketLen = maxValue + 1;
for(vari = 0; i < arrLen; i++) {
if(!bucket[arr[i]]) {
bucket[arr[i]] = 0;
}
bucket[arr[i]]++;
}
for(varj = 0; j < bucketLen; j++) {
while(bucket[j] > 0) {
arr[sortedIndex++] = j;
bucket[j]--;
}
}
returnarr;
}计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时，时间复杂度是O(n+k)，空间复杂度也是O(n+k)，其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。
9、桶排序
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。
- 设置一个定量的数组当作空桶；
- 遍历输入数据，并且把数据一个一个放到对应的桶里去；
- 对每个不是空的桶进行排序；
- 从不是空的桶里把排好序的数据拼接起来。
function bucketSort(arr, bucketSize) {
if(arr.length === 0) {
returnarr;
}
vari;
varminValue = arr[0];
varmaxValue = arr[0];
for(i = 1; i < arr.length; i++) {
if(arr[i] < minValue) {
minValue = arr[i]; // 输入数据的最小值
} elseif(arr[i] > maxValue) {
maxValue = arr[i]; // 输入数据的最大值
}
}
// 桶的初始化
varDEFAULT_BUCKET_SIZE = 5; // 设置桶的默认数量为5
bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
varbucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
varbuckets = newArray(bucketCount);
for(i = 0; i < buckets.length; i++) {
buckets[i] = [];
}
// 利用映射函数将数据分配到各个桶中
for(i = 0; i < arr.length; i++) {
buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
}
arr.length = 0;
for(i = 0; i < buckets.length; i++) {
insertionSort(buckets[i]); // 对每个桶进行排序，这里使用了插入排序
for(varj = 0; j < buckets[i].length; j++) {
arr.push(buckets[i][j]);
}
}
returnarr;桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。
10、基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
- 取得数组中的最大数，并取得位数；
- arr为原始数组，从最低位开始取每个位组成radix数组；
- 对radix进行计数排序（利用计数排序适用于小范围数的特点）；
varcounter = [];
function radixSort(arr, maxDigit) {
varmod = 10;
vardev = 1;
for(vari = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
for(varj = 0; j < arr.length; j++) {
varbucket = parseInt((arr[j] % mod) / dev);
if(counter[bucket]==null) {
counter[bucket] = [];
}
counter[bucket].push(arr[j]);
}
varpos = 0;
for(varj = 0; j < counter.length; j++) {
varvalue = null;
if(counter[j]!=null) {
while((value = counter[j].shift()) != null) {
arr[pos++] = value;
}
}
}
}
returnarr;
}基数排序基于分别排序，分别收集，所以是稳定的。但基数排序的性能比桶排序要略差，每一次关键字的桶分配都需要O(n)的时间复杂度，而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O(d*2n) ，当然d要远远小于n，因此基本上还是线性级别的。
基数排序的空间复杂度为O(n+k)，其中k为桶的数量。一般来说n>>k，因此额外空间需要大概n个左右。
4、Spring和SpringMVC的区别
spring是一个一站式的框架，提供了表现层（springmvc）到业务层（spring）再到数据层的全套解决方案；spring的两大核心IOC(控制反转)和AOP(面向切面编程)更是给我们的程序解耦和代码的简介提供了支持。
而SpringMVC是基于Spring功能之上添加的Web框架，想用SpringMVC必须先依赖Spring，springmvc仅给spring的表现层提供支持。
Spring可以说是一个管理bean的容器，也可以说是包括很多开源项目的总称，spring mvc是其中一个开源项目，所以简单走个流程的话，http请求一到，由容器（如：tomact）解析http搞成一个request，通过映射关系（路径，方法，参数啊）被spring mvc一个分发器去找到可以处理这个请求的bean，那tomcat里面就由spring管理bean的一个池子（bean容器）里面找到，处理完了就把响应返回回去。
SpringMVC是一个MVC模式的WEB开发框架，Spring是一个通用解决方案, 最大的用处就是通过Ioc/AOP解耦, 降低软件复杂性, 所以Spring可以结合SpringMVC等很多其他解决方案一起使用, 不仅仅只适用于WEB开发。
**百度面经问题
具体问题可查看文章面经 | 2021百度提前批电话面试 | 一面
1、线程与进程的区别
进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位；
线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位；
线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
进程是对运行时程序的封装,是系统进行资源调度和分配的基本单位,实现操作系统的并发；
线程是进程的子任务,是CPU调度和分派的基本单位,用于保证程序的实时性,实现进程内部的并发；
一个程序至少有一个进程,一个进程至少有一个线程,线程依赖进程的存在；
进程执行过程中拥有独立的内存单元,而多个线程共享进程的内存。
2、进程的通信方式
管道（pipe）及命名管道（named pipe）： 管道可用于具有亲缘关系的父子进程间的通信，有名管道除了具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；
信号（signal）： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生；
消息队列： 消息队列是消息的链接表，它克服了上两种通信方式中信号量有限的缺点，具有写权限得进程可以按照一定得规则向消息队列中添加新信息；对消息队列有读权限得进程则可以从消息队列中读取信息；
共享内存： 可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据得更新。这种方式需要依靠某种同步操作，如互斥锁和信号量等；
信号量： 主要作为进程之间及同一种进程的不同线程之间得同步和互斥手段；
套接字： 这是一种更为一般得进程间通信机制，它可用于网络中不同机器之间的进程间通信，应用非常广泛。
几种方式的比较：
管道：速度慢、容量有限
消息队列：容量收到系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题。
信号量：不能传递复杂信息，只能用来同步。
共享内存：能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题，相当于线程中的线程安全。
3、线程的同步方式
同步就是协同步调，按预定的先后次序进行运行。这里的同步千万不要理解成那个同时进行，应是指协同、协助、互相配合。线程同步是指多线程通过特定的设置（如互斥量，事件对象，临界区）来控制线程之间的执行顺序（即所谓的同步）也可以说是在线程之间通过同步建立起执行顺序的关系，如果没有同步，那线程之间是各自运行各自的！
线程互斥是指对于共享的进程系统资源，在各单个线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。线程互斥可以看成是一种特殊的线程同步（下文统称为同步）。
临界区（Critical Section）、互斥对象（Mutex）：主要用于互斥控制；都具有拥有权的控制方法，只有拥有该对象的线程才能执行任务，所以拥有，执行完任务后一定要释放该对象。
信号量（Semaphore）、事件对象（Event）：事件对象是以通知的方式进行控制，主要用于同步控制！
1、临界区：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。在任意时刻只允许一个线程对共享资源进行访问，如果有多个线程试图访问公共资源，那么在有一个线程进入后，其他试图访问公共资源的线程将被挂起，并一直等到进入临界区的线程离开，临界区在被释放后，其他线程才可以抢占。它并不是核心对象，不是属于操作系统维护的，而是属于进程维护的。
- 关键段共初始化化、销毁、进入和离开关键区域四个函数。
- 关键段可以解决线程的互斥问题，但因为具有“线程所有权”，所以无法解决同步问题。
- 推荐关键段与旋转锁配合使用。
2、互斥对象：互斥对象和临界区很像，采用互斥对象机制，只有拥有互斥对象的线程才有访问公共资源的权限。因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程同时访问。当前拥有互斥对象的线程处理完任务后必须将线程交出，以便其他线程访问该资源。
- 互斥量是内核对象，它与关键段都有“线程所有权”所以不能用于线程的同步。
- 互斥量能够用于多个进程之间线程互斥问题，并且能完美的解决某进程意外终止所造成的“遗弃”问题。
3、信号量：信号量也是内核对象。它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目
- 在用CreateSemaphore()创建信号量时即要同时指出允许的最大资源计数和当前可用资源计数。
- 一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1 ，只要当前可用资源计数是大于0的，就可以发出信号量信号。
- 但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目，不能在允许其他线程的进入，此时的信号量信号将无法发出。
- 线程在处理完共享资源后，应在离开的同时通过ReleaseSemaphore()函数将当前可用资源计数加1。在任何时候当前可用资源计数决不可能大于最大资源计数。
4、事件对象： 通过通知操作的方式来保持线程的同步，还可以方便实现对多个线程的优先级比较的操作
- 事件是内核对象，事件分为手动置位事件和自动置位事件。事件Event内部它包含一个使用计数（所有内核对象都有），一个布尔值表示是手动置位事件还是自动置位事件，另一个布尔值用来表示事件有无触发。
- 事件可以由SetEvent()来触发，由ResetEvent()来设成未触发。还可以由PulseEvent()来发出一个事件脉冲。
- 事件可以解决线程间同步问题，因此也能解决互斥问题。
4、如果多个线程访问同一资源怎么处理
如果将CPU比作一个工厂，那么不同的车间就是不同的进程，而车间里的工人就是线程，那么车间里的工具以及空间就是资源，如果这时有人要上厕所，那么其他人只能等待里面的人出来才能进去，这就叫做阻塞，而里面的人为了防止外面的人破门而入（占有），就要给厕所装一把锁（互斥锁），这样有钥匙（互斥对象）的人才能进去，进去后锁门就可以防止别的线程占有；
而有些地方只允许一定数量的线程进入（多个线程访问同一资源），这时就需要一定数量的钥匙（信号量）来配这个地方的锁，每有一个线程使用资源就拿走一把钥匙（信号量减一），直到没有钥匙（信号量为零）这样其他的线程就不能占有资源了；
或者在第一个例子中，我们使用事件（或者叫信号），当一个线程正在占有资源，其他线程只能等待，当这个线程完成任务后，主动唤醒下一个线程，这样不但实现了多线程的同步，还可以方便的实现多线程优先级的比较操作。
5、死锁的产生
在两个或者多个并发进程中，如果每个进程持有某种资源而又等待其它进程释放它或它们现在保持着的资源，在未改变这种状态之前都不能向前推进，称这一组进程产生了死锁。通俗的讲就是两个或多个进程无限期的阻塞、相互等待的一种状态。
死锁产生的四个条件（有一个条件不成立，则不会产生死锁）
- 互斥：一个资源一次只能被一个进程使用，若其他申请使用该资源，那么申请进程必须等到该资源被释放为止；
- 占有并等待：一个进程必须占有至少一个资源，并等待另一个资源，而等待资源被其他进程所占有；
- 非抢占：进程不能被抢占，即资源只能被进程在完成任务后自愿释放
- 循环等待：若干进程之间形成一种头尾相接的环形等待资源关系
6、死锁的处理
解决死锁的基本方法主要有 预防死锁、避免死锁、检测死锁、解除死锁 、鸵鸟策略等
死锁预防的基本思想是只要确保死锁发生的四个必要条件中至少有一个不成立，就能预防死锁的发生，具体方法包括：
打破互斥条件：允许进程同时访问某些资源。但是，有些资源是不能被多个进程所共享的，这是由资源本身属性所决定的，因此，这种办法通常并无实用价值。
打破占有并等待条件：可以实行资源预先分配策略(进程在运行前一次性向系统申请它所需要的全部资源，若所需全部资源得不到满足，则不分配任何资源，此进程暂不运行；只有当系统能满足当前进程所需的全部资源时，才一次性将所申请资源全部分配给该线程)或者只允许进程在没有占用资源时才可以申请资源（一个进程可申请一些资源并使用它们，但是在当前进程申请更多资源之前，它必须全部释放当前所占有的资源）。但是这种策略也存在一些缺点：在很多情况下，无法预知一个进程执行前所需的全部资源，因为进程是动态执行的，不可预知的；同时，会降低资源利用率，导致降低了进程的并发性。
打破非抢占条件：允许进程强行从占有者哪里夺取某些资源。也就是说，一个进程占有了一部分资源，在其申请新的资源且得不到满足时，它必须释放所占有的资源以便让其它线程使用。这种预防死锁的方式实现起来困难，会降低系统性能。
打破循环等待条件：实行资源有序分配策略。对所有资源排序编号，所有进程对资源的请求必须严格按资源序号递增的顺序提出，即只有占用了小号资源才能申请大号资源，这样就不回产生环路，预防死锁的发生。
死锁避免的基本思想是动态地检测资源分配状态，以确保循环等待条件不成立，从而确保系统处于安全状态。
所谓安全状态是指：如果系统能按某个顺序为每个进程分配资源（不超过其最大值），那么系统状态是安全的，换句话说就是，如果存在一个安全序列，那么系统处于安全状态。
资源分配图算法和银行家算法是两种经典的死锁避免的算法，其可以确保系统始终处于安全状态。其中，资源分配图算法应用场景为每种资源类型只有一个实例(申请边，分配边，需求边，不形成环才允许分配)，而银行家算法应用于每种资源类型可以有多个实例的场景。
死锁解除的常用两种方法为进程终止和资源抢占。
所谓进程终止是指简单地终止一个或多个进程以打破循环等待，包括两种方式：终止所有死锁进程和一次只终止一个进程直到取消死锁循环为止；
所谓资源抢占是指从一个或多个死锁进程那里抢占一个或多个资源，此时必须考虑三个问题：
- 选择一个牺牲品
- 回滚：回滚到安全状态
- 饥饿（在代价因素中加上回滚次数，回滚的越多则越不可能继续被作为牺牲品，避免一个进程总是被回滚）
鸵鸟策略就是对死锁进行忽视。
因为解决死锁的代价很高，当死锁对用户不会产生很大影响的时候采用鸵鸟策略可以大大提高系统的效率。
7、数组和链表的区别
数组，就是相同数据类型的元素按一定顺序排列的集合；数组的存储区间是连续的，占用内存比较大，故空间复杂的很大。但数组的二分查找时间复杂度小，都是O(1)；数组的特点是：查询简单，增加和删除困难；
- 在内存中，数组是一块连续的区域；
- 数组需要预留空间，在使用前需要提前申请所占内存的大小，如果提前不知道需要的空间大小时，预先申请就可能会浪费内存空间，即数组的空间利用率较低。注：数组的空间在编译阶段就需要进行确定，所以需要提前给出数组空间的大小(在运行阶段是不允许改变的)；
- 在数组起始位置处，插入数据和删除数据效率低。插入数据时，待插入位置的元素和他后面的所有元素都需要向后搬移；删除数据时，待删除位置后面的所有元素都需要向前搬移；
- 随机访问效率很高，时间复杂度可以达到O(1)，因为数组的内存是连续的，想要访问那个元素，直接从数组的首地址向后偏移就可以访问到了；
- 数组开辟的空间，在不够使用的时候需要进行扩容；扩容的话，就涉及到需要把旧数组中的所有元素向新数组中搬移；
- 数组的空间是从栈分配的。（栈：先进后出）
数组的优点
- 随机访问性强,查找速度快，时间复杂度是O(1)
数组的缺点
- 从头部删除、从头部插入的效率低，时间复杂度是o(n),因为需要相应的向前搬移和向后搬移。
- 空间利用率不高
- 内存空间要求高，必须要有足够的连续的内存空间。
- 数组的空间大小是固定的，不能进行动态扩展。
链表，是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。
- 在内存中，元素的空间可以在任意地方，空间是分散的，不需要连续；
- 链表中的元素有两个属性，一个是元素的值，另一个是指针，此指针标记了下一个元素的地址；
- 每一个数据都会保存下一个数据的内存地址，通过该地址就可以找到下一个数据；
- 查找数据时间效率低，时间复杂度是o(n)，因为链表的空间是分散的，所以不具有随机访问性，如果需要访问某个位置的数据，需要从第一个数开始找起，依次往后遍历，知道找到待查询的位置，故可能在查找某个元素时，时间复杂度是o(n)；
- 空间不需要提前指定大小，是动态申请的，根据需求动态的申请和删除内存空间，扩展方便，故空间的利用率较高；
- 任意位置插入元素和删除元素时间效率较高，时间复杂度是o(1)；
- 链表的空间是从堆中分配的。（堆：先进先出，后进后出）
链表的优点
- 任意位置插入元素和删除元素的速度快，时间复杂度是o(1)
- 内存利用率高，不会浪费内存
- 链表的空间大小不固定，可以动态拓展。
链表的缺点
- 随机访问效率低，时间复杂度是o(1)
8、深度优先和广度优先算法
深度优先算法
遍历规则：不断地沿着顶点的深度方向遍历。顶点的深度方向是指它的邻接点方向。
对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历（我们前面使用的是先序遍历）。具体说明如下：
- 先序遍历：对任一子树，先访问根，然后遍历其左子树，最后遍历其右子树。
- 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树。
- 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。
算法：不全部保留结点，占用空间少；有回溯操作(即有入栈、出栈操作)，运行速度慢。
广度优先算法
遍历规则：先访问完当前顶点的所有邻接点。(应该看得出广度的意思)；先访问顶点的邻接点先于后访问顶点的邻接点被访问。
又叫层次遍历，从上往下对每一层依次访问，在每一层中，从左往右（也可以从右往左）访问结点，访问完一层就进入下一层，直到没有结点可以访问为止。
算法：保留全部结点，占用空间大； 无回溯操作(即无入栈、出栈操作)，运行速度快。
通常深度优先搜索法不全部保留结点，扩展完的结点从数据库中弹出删去，这样，一般在数据库中存储的结点数就是深度值，因此它占用空间较少。所以，当搜索树的结点较多，用其它方法易产生内存溢出时，深度优先搜索不失为一种有效的求解方法。
广度优先搜索算法，一般需存储产生的所有结点，占用的存储空间要比深度优先搜索大得多，因此，程序设计中，必须考虑溢出和节省内存空间的问题。但广度优先搜索法一般无回溯操作，即入栈和出栈的操作，所以运行速度比深度优先搜索要快些。
9、多态
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作。
多态存在的三个必要条件：继承；重写；基类引用指向派生类对象（引用还是指向基类）
多态又分为向上转型与向下转型：
子类引用的对象转换为父类类型称为向上转型，通俗地说就是是将子类对象转为父类对象，此处父类对象可以是接口。向上转型时，子类单独定义的方法会丢失；子类引用不能指向父类对象。向上转型可以减少重复代码，使代码变得简洁；提高系统扩展性。
与向上转型相对应的就是向下转型了，向下转型是把父类对象转为子类对象。向下转型的前提是父类对象指向的是子类对象（也就是说，在向下转型之前，它得先向上转型）；向下转型只能转型为本类对象。
10、为什么要进行三次握手
防止失效的连接请求报文段被服务端接收，从而产生错误。
失效的连接请求：若客户端向服务端发送的连接请求丢失，客户端等待应答超时后就会再次发送连接请求，此时，上一个连接请求就是『失效的』。
若建立连接只需两次握手，客户端并没有太大的变化，仍然需要获得服务端的应答后才进入ESTABLISHED状态，而服务端在收到连接请求后就进入ESTABLISHED状态。此时如果网络拥塞，客户端发送的连接请求迟迟到不了服务端，客户端便超时重发请求，如果服务端正确接收并确认应答，双方便开始通信，通信结束后释放连接。此时，如果那个失效的连接请求抵达了服务端，由于只有两次握手，服务端收到请求就会进入ESTABLISHED状态，等待发送数据或主动发送数据。但此时的客户端早已进入CLOSED状态，服务端将会一直等待下去，这样浪费服务端连接资源。
11、MySQL的特性
有三大特性：插入缓存、doubleWrite、自适应哈希索引
具体可查看网络文章：https://www.cnblogs.com/drizzle-xu/p/9712894.html
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
