面试题总结1-68

Java 基础题库
1. JDK 和 JRE 有什么区别？
    JDK：Java Development Kit 的简称，java 开发工具包，提供了 java 的开发环境和运行环境。
    JRE：Java Runtime Environment 的简称，java 运行环境，为 java 的运行提供了所需环境。
    具体来说 JDK 其实包含了 JRE，同时还包含了编译 java 源码的编译器 javac，还包含了很多
     java 程序调试和分析的工具。简单来说：如果你需要运行 java 程序，
     只需安装 JRE 就可以了，如果你需要编写 java 程序，需要安装 JDK。
    
2. == 和 equals 的区别是什么？
    一、对象类型不同
    1、equals()：是超类Object中的方法。
    2、==：是操作符。
    二、比较的对象不同
    1、equals()：用来检测两个对象是否相等，即两个对象的内容是否相等。
    2、==：用于比较引用和比较基本数据类型时具有不同的功能。
    三、运行速度不同
    1、equals()：没有==运行速度快。
    2、==：运行速度比equals()快，因为==只是比较引用。
    
3. 两个对象的 hashCode() 相同，则 equals() 也一定为 true，对吗？
    两个对象equals相等，则它们的hashcode必须相等，反之则不一定。
    两个对象==相等，则其hashcode一定相等，反之不一定成立。
    hashCode 的常规协定：
    1.在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，
    前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
    2.两个对象的equals()相等，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。
    3.两个对象的equals()不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不要求一定生成不同的整数结果。
    但是，为不相等的对象生成不同整数结果可以提高哈希表的性能。
    
4. final 在 Java 中有什么作用？
    final作为Java中的关键字可以用于三个地方。用于修饰类、类属性和类方法。
    特征：凡是引用final关键字的地方皆不可修改！
    (1)修饰类：表示该类不能被继承；
    (2)修饰方法：表示方法不能被重写；
    (3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。
    相信大家都具备基本的常识: 被final修饰的变量是不能够被改变的. 但是这里的"不能够被改变"对于不同的数据类型是有不同的含义的.
    当final修饰的是一个基本数据类型数据时, 这个数据的值在初始化后将不能被改变; 当final修饰的是一个引用类型数据时, 
    也就是修饰一个对象时, 引用在初始化后将永远指向一个内存地址, 不可修改. 但是该内存地址中保存的对象信息, 是可以进行修改的.
    上一段话可能比较抽象, 希望下面的图能有助于你理解, 你会发现虽说有不同的含义, 但本质还是一样的.
    首先是final修饰基本数据类型时的内存示意图
    如上图, 变量a在初始化后将永远指向003这块内存, 而这块内存在初始化后将永远保存数值100.
    下面是final修饰引用数据类型的示意图
    在上图中, 变量p指向了0003这块内存, 0003内存中保存的是对象p的句柄(存放对象p数据的内存地址), 这个句柄值是不能被修改的,
    也就是变量p永远指向p对象. 但是p对象的数据是可以修改的.
    不难看出final修饰变量的本质: final修饰的变量会指向一块固定的内存, 这块内存中的值不能改变.
    引用类型变量所指向的对象之所以可以修改, 是因为引用变量不是直接指向对象的数据, 而是指向对象的引用的. 
    所以被final修饰的引用类型变量将永远指向一个固定的对象, 不能被修改; 对象的数据值可以被修改.
    
5. Java 中的 Math. round(-1. 5) 等于多少？
    Math.round(1.5)的返回值是2，Math.round(-1.5)的返回值是-1。四舍五入的原理是在参数上加0.5然后做向下取整。
    
6. String 属于基础的数据类型吗？
    String类并不是基本数据类，而是一个类（2113class），是C++、java等编程语言中的5261字符串。
    String类是不可变的，对4102String类的任何改变，都是返回一个新的String类对象。 
    String 对象是 System.Char 对象的有序1653集合，用于表示字符串。String 对象的值是该有序集合的内内容，并且该值是不可变的。
    而java的8大基本数据类型分别是：
    逻辑类 boolean
    文本类 char
    整数容类 byte, short, int, long
    浮点类 double, float。
    
7. Java 中操作字符串都有哪些类？它们之间有什么区别？
    主要是一下三种：String、StringBuffer、StringBuilder
    这个知识点我个人认为还是比较重要的。特别是在项目中。先来看一下这三种操作方式的区别：
    String是不可变的对象，对每次对String类型的改变时都会生成一个新的对象，
    StringBuffer和StringBuilder是可以改变对象的。
    对于操作效率：StringBuilder > StringBuffer > String
    对于线程安全：StringBuffer 是线程安全，可用于多线程；
    StringBuilder 是非线程安全，用于单线程
    不频繁的字符串操作使用 String。反之，StringBuffer 和 StringBuilder 都优于String
    所以，如果在项目中需要拼接字符串最好是采用StringBuffer 而非String.

8. String str="i"与 String str=new String("i")一样吗？
    String x = "张三";
    String y = "张三";
    String z = new String("张三");
    System.out.println(x == y); // true
    System.out.println(x == z); // false
    为什么会输出上边的结果呢，String x = "张三" 的方式，Java 虚拟机会将其分配到常量池中，
    而常量池中没有重复的元素，比如当执行“张三”时，java虚拟机会先在常量池中检索是否已经有“张三”,
    如果有那么就将“张三”的地址赋给变量，如果没有就创建一个，然后在赋给变量；
    而 String z = new String(“张三”) 则会被分到堆内存中，即使内容一样还是会创建新的对象。

9. String s = new String("abc");产生了几个对象？
    可能产生1和或者2个对象。
    通过new String()方法产生的字符串，先会在常量池去查询有木有abc的对象，如果没有，
    则会在常量池里开辟一个空间，存放abc，紧接着，将拷贝此对象到堆中产生一个对象。
    如果有，则堆中直接创建一个常量池中此 ”abc” 对象的拷贝对象。

10. String 类的常用方法都有那些？
    indexOf() 返回指定字符得索引
    charAt() 返回指定索引处得字符
    repalce() 字符串替换
    trim() 去除字符串两端的空白
    split() 分割字符串 返回分割后的字符串数组
    getBytes() 返回字符串的byte类型数组
    length() 返回字符串的长度
    toLowerCase() 字符串转小写
    toUpperCase() 字符串转大写
    substring() 截取字符串
    equals() 字符串比较

11. 抽象类必须要有抽象方法吗？
    抽象类可以没有抽象方法，但是如果你的一个类已经声明成了抽象类，即使这个类中没有抽象方法，
    它也不能再实例化，即不能直接构造一个该类的对象。
    如果一个类中有了一个抽象方法，那么这个类必须声明为抽象类，否则编译通不过。
    
12. 普通类和抽象类有哪些区别？
    抽象类不能被实例化
    抽象类可以有抽象方法，抽象方法只需申明，无需实现
    含有抽象方法的类必须申明为抽象类
    抽象的子类必须实现抽象类中所有抽象方法，否则这个子类也是抽象类
    抽象方法不能被声明为静态
    抽象方法不能用private修饰
    抽象方法不能用final修饰

13. 抽象类能使用 final 修饰吗？
    不能，抽象类是被用于继承的，final修饰代表不可修改、不可继承的。
    
14. 接口和抽象类有什么区别？
    他们都不能实例化对象，都可以包含抽象方法，而且抽象方法必须被继承的类全部实现。
    区别：
    1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，
        接口变量必须指向实现所有接口方法的类对象。
    2、抽象类要被子类继承，接口要被类实现。
    3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
    4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
    5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。
        同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
    6、抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果
    7、抽象类里可以没有抽象方法
    8、如果一个类里有抽象方法，那么这个类只能是抽象类
    9、抽象方法要被实现，所以不能是静态的，也不能是私有的。
    10、接口可继承接口，并可多继承接口，但类只能单根继承。
    
    抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；
    抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；
    接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
    一个类只能继承一个抽象类，而一个类却可以实现多个接口。

15. Java 中 IO 流分为几种？
    Java中的流分为两种，一种是字节流，另一种是字符流，分别由四个抽象类来表示（每种流包括输入和输出两种所以一共四个）:
    InputStream，OutputStream，Reader，Writer。Java中其他多种多样变化的流均是由它们派生出来的.
    字符流和字节流是根据处理数据的不同来区分的。字节流按照8位传输，字节流是最基本的，
    所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。
    1.字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串；
    2.节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以。
    读文本的时候用字符流，例如txt文件。读非文本文件的时候用字节流，例如mp3。理论上任何文件都能够用字节流读取，
    但当读取的是文本数据时，为了能还原成文本你必须再经过一个转换的工序，相对来说字符流就省了这个麻烦，可以有方法直接读取。
    字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，
    操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！

16. BIO、NIO、AIO 有什么区别？
    BIO：Block IO 同步阻塞式 IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能力低。
    NIO：Non IO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）通讯，实现了多路复用。
    AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制。

    BIO是一个连接一个线程。
    NIO是一个请求一个线程。
    AIO是一个有效请求一个线程。

    BIO：同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，
    如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
    NIO：同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，
    多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
    AIO：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。
    适用场景分析
    BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。
    NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持。
    AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

17. Files的常用方法都有哪些？
    Files.exists()：检测文件路径是否存在。
    Files.createFile()：创建文件。
    Files.createDirectory()：创建文件夹。
    Files.delete()：删除一个文件或目录。
    Files.copy()：复制文件。
    Files.move()：移动文件。
    Files.size()：查看文件个数。
    Files.read()：读取文件。
    Files.write()：写入文件。

18.如何将字符串反转？
    使用 StringBuilder 或 StringBuffer 的 reverse 方法，本质都调用了它们的父类
    AbstractStringBuilder 的 reverse 方法实现。（JDK1.8） 不考虑字符串中的字符是否是 Unicode 编码，自己实现。 递归 &...

容器
18. Java 容器都有哪些？
    数组,String,java.util下的集合容器
    数组长度限制为 Integer.Integer.MAX_VALUE;
    String的长度限制: 底层是char 数组 长度 Integer.MAX_VALUE 线程安全的
    List:存放有序,列表存储,元素可重复
    Set:无序,元素不可重复
    Map:无序,元素可重复

19. Collection 和 Collections 有什么区别？
    Collection 是集合的接口，其继承类又List Set
    Collections 是集合的工具类，定义了许多操作集合的静态方法。是帮助类。

20. List、Set、Map 之间的区别是什么？
    List(列表)
        List的元素以线性方式存储，可以存放重复对象，List主要有以下两个实现类：
        ArrayList : 长度可变的数组，可以对元素进行随机的访问，向ArrayList中插入与删除元素的速度慢。
        JDK8 中ArrayList扩容的实现是通过grow()方法里使用语句newCapacity = oldCapacity + (oldCapacity >> 1)
        （即1.5倍扩容）计算容量，然后调用Arrays.copyof()方法进行对原数组进行复制。
        LinkedList: 采用链表数据结构，插入和删除速度快，但访问速度慢。
    Set(集合)
        Set中的对象不按特定(HashCode)的方式排序，并且没有重复对象，Set主要有以下两个实现类：
        HashSet： HashSet按照哈希算法来存取集合中的对象，存取速度比较快。
        当HashSet中的元素个数超过数组大小*loadFactor（默认值为0.75）时，
        就会进行近似两倍扩容（newCapacity = (oldCapacity << 1) + 1）。
        TreeSet ：TreeSet实现了SortedSet接口，能够对集合中的对象进行排序。
    Map(映射)
        Map是一种把键对象和值对象映射的集合，它的每一个元素都包含一个键对象和值对象。 Map主要有以下两个实现类：
        HashMap：HashMap基于散列表实现，其插入和查询<K,V>的开销是固定的，可以通过构造器设置容量和负载因子来调整容器的性能。
        LinkedHashMap：类似于HashMap，但是迭代遍历它时，取得<K,V>的顺序是其插入次序，或者是最近最少使用(LRU)的次序。
        TreeMap：TreeMap基于红黑树实现。查看<K,V>时，它们会被排序。TreeMap是唯一的带有subMap()方法的Map，subMap()可以返回一个子树。
    HashMap
    底层实现：HashMap底层整体结构是一个数组，数组中的每个元素又是一个链表。每次添加一个对象（put）时会产生一个链表对象（Object类型），
    Map中的每个Entry就是数组中的一个元素（Map.Entry就是一个<Key,Value>），它具有由当前元素指向下一个元素的引用，这就构成了链表。
    存储原理：当向HsahMap中添加元素的时候，先根据HashCode重新计算Key的Hash值，得到数组下标，如果数组该位置已经存在其他元素，
    那么这个位置的元素将会以链表的形式存放，新加入的放在链头，最先加入的放在链尾，如果数组该位置元素不存在，那么就直接将该元素放到此数组中的该位置。
    去重原理：不同的Key算到数组下标相同的几率很小，新建一个<K,V>放入到HashMap的时候，首先会计算Key的数组下标，
    如果数组该位置已经存在其他元素，则比较两个Key，若相同则覆盖写入，若不同则形成链表。
    读取原理：从HashMap中读取（get）元素时，首先计算Key的HashCode，找到数组下标，然后在对应位置的链表中找到需要的元素。
    扩容机制：当HashMap中的元素个数超过数组大小*loadFactor（默认值为0.75）时，就会进行2倍扩容（oldThr << 1）。

21. HashMap 和 Hashtable 有什么区别？
    底层都是数组+链表实现
    Hashtable：
    1.无论是key还是value都不能为null，线程安全，实现线程安全的方式是在修改数据时锁住整个Hashtable，效率低
    2.初始size为11，扩容：newsize＝oldsize*2+1
    Hashmap：
    1.可以存储null键和null值，线程不安全
    2.初始size为16，扩容：newsize ＝oldsize*2，size一定为2的n次幂
    HashTable使用Enumeration遍历，HashMap使用Iterator进行遍历。
    在Hashmap中，null可以作为键，这样的键只有一个，但可以有一个或多个键所对应的值为null.当get（）方法返回null值时，
    即可以表示Hashmap中没有该key，也可以表示该key所对应的value为null。
    因此，在Hashmap中不能由get（）方法来判断Hashmap中是否存在某个key，应该用containsKey（）方法来判断。
    
22. 如何决定使用 HashMap 还是 TreeMap？
    HashMap基于散列桶（数组和链表）实现；TreeMap基于红黑树实现。
    HashMap不支持排序；TreeMap默认是按照Key值升序排序的，可指定排序的比较器，主要用于存入元素时对元素进行自动排序。
    HashMap大多数情况下有更好的性能，尤其是读数据。在没有排序要求的情况下，使用HashMap。
    都是非线程安全。
    
23. 说一下 HashMap 的实现原理？
    hashMap基于hashing原理，我们通过put()和get()方法存储和获取对象。当我们将键值对传给put()方法时；
    它调用键对象的hashCode()方法来计算hashCode，然后找到bucket位置来存值对象。
    当获取对象时，通过键值对的equals()方法来找到正确的键值对。然后返回值对象。
    HashMap使用链表来解决碰撞问题，当发生碰撞时，对象会存储在链表的下一个节点。hashMap在每个链表的阶段存储键值对对象。
    当两个不同的键对象hashCode相同时会发生什么？他们会存储在同一个bucket位置的链表中。建对象的equals()方法用来找到键值对。
    
24. 说一下 HashSet 的实现原理？
    HashSet 是基于 HashMap 实现的，HashSet 底层使用 HashMap 来保存所有元素，因此 HashSet 的实现比较简单。
    相关 HashSet 的操作，基本上都是直接调用底层 HashMap 的相关方法来完成，HashSet 不允许重复的值。
    
25. ArrayList 和 LinkedList 的区别是什么？
    1、数据结构不同
    ArrayList是Array(动态数组)的数据结构，LinkedList是Link(链表)的数据结构。
    2、效率不同
    当随机访问List（get和set操作）时，ArrayList比LinkedList的效率更高，因为LinkedList是线性的数据存储方式，所以需要移动指针从前往后依次查找。
    当对数据进行增加和删除的操作(add和remove操作)时，LinkedList比ArrayList的效率更高，因为ArrayList是数组，
    所以在其中进行增删操作时，会对操作点之后所有数据的下标索引造成影响，需要进行数据的移动。
    3、自由性不同
    ArrayList自由性较低，因为它需要手动的设置固定大小的容量，但是它的使用比较方便，只需要创建，然后添加数据，通过调用下标进行使用；
    而LinkedList自由性较高，能够动态的随数据量的变化而变化，但是它不便于使用。
    4、主要控件开销不同
    ArrayList主要控件开销在于需要在lList列表预留一定空间；而LinkList主要控件开销在于需要存储结点信息以及结点指针信息。

26. 如何实现数组和 List 之间的转换？
    数组转List 使用Arrays.asList(array)进行转换
    List 转数组：使用 List 自带的 toArray() 方法。
    
27. ArrayList 和 Vector 的区别是什么？
    同步性：Vector是线程安全的，用synchronized实现线程安全，而ArrayList是线程不安全的。
    （实现同步需要很高的花费，所以访问Vector比访问ArrayList慢）
    数据容量增长：二者都有一个初始容量大小，采用线性连续存储空间，当存储的元素的个数超过了容量时，就需要增加二者的存储空间，
    Vector增长原来的一倍，ArrayList增加原来的0.5倍。
    
28. Array 和 ArrayList 有何区别？
    ①Array是Java中的数组，声明数组有三种方式
    int[] a=new int[10];
    int a[]=new int[10];
    int a[]={1,2,3,4};
    可以看出：在定义一个数组的时候，必须指定这个数组的数据类型及数组的大小，也就是说数组中存放的元素个数固定并且类型一样

    ②ArrayList是动态数组,也就是数组的复杂版本，它可以动态的添加和删除元素，被称为”集合“，集合的声明如下
    ArrayList list = new ArrayList(10);
    ArrayList list1 = new ArrayList();
    可以看出：在不使用泛型的情况下，这个list是可以添加进不同类型的元素的，而且arraylist是可以不用指定长度的。在使用泛型时，我们就只能添加一种类型的数据了

29. 在 Queue 中 poll()和 remove()有什么区别？
    1、offer()和add()的区别
    add()和offer()都是向队列中添加一个元素。但是如果想在一个满的队列中加入一个新元素，调用 add() 方法就会抛出一个 unchecked 异常，
    而调用 offer() 方法会返回 false。可以据此在程序中进行有效的判断！
    2、peek()和element()的区别
    peek()和element()都将在不移除的情况下返回队头，但是peek()方法在队列为空时返回null，调用element()方法会抛出NoSuchElementException异常。
    3、poll()和remove()的区别
    poll()和remove()都将移除并且返回对头，但是在poll()在队列为空时返回null，而remove()会抛出NoSuchElementException异常。

30. 哪些集合类是线程安全的？
    Vector：就比Arraylist多了个同步化机制（线程安全）。
    Hashtable：就比Hashmap多了个线程安全。
    ConcurrentHashMap:是一种高效但是线程安全的集合。
    Stack：栈，也是线程安全的，继承于Vector。

31. 迭代器 Iterator 是什么？
    首先说一下迭代器模式，它是 Java 中常用的设计模式之一。用于顺序访问集合对象的元素，无需知道集合对象的底层实现。
    Iterator 是可以遍历集合的对象，为各种容器提供了公共的操作接口，隔离对容器的遍历操作和底层实现，从而解耦。
    缺点是增加新的集合类需要对应增加新的迭代器类，迭代器类与集合类成对增加。

32. Iterator 怎么使用？有什么特点？
    java.lang.Iterable 接口被 java.util.Collection 接口继承，java.util.Collection 接口的 iterator() 方法返回一个 Iterator 对象
    next() 方法获得集合中的下一个元素
    hasNext() 检查集合中是否还有元素
    remove() 方法将迭代器新返回的元素删除
    forEachRemaining(Consumer<? super E> action) 方法，遍历所有元素

33. Iterator 和 ListIterator 有什么区别？
    我们需要知道的第一个则是：
    （1）所属关系，ListIterator是一个Iterator的子类型。
    （2）局限：只能应用于各种List类的访问。
    （3）优势：Iterator只能向前移动，而ListIterator可以双向移动。
    还可以产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引
    nextIndex()、previousIndex()方法。
    还可以通过set（）方法替换它访问过的最后一个元素。
    还可以通过调用listIterator（）方法产生一个指向List开始处的ListIterator，当然也可以有参数，即指向索引为参数处的ListIterator。
    （4）ListIterator 有 add() 方法，可以向 List 中添加对象，而 Iterator 不能。

34. 怎么确保一个集合不能被修改？
    我们可以采用Collections包下的unmodifiableMap方法，通过这个方法返回的map,是不可以修改的。他会报 java.lang.UnsupportedOperationException错。
    同理：Collections包也提供了对list和set集合的方法。
    Collections.unmodifiableList(List)
    Collections.unmodifiableSet(Set)
    示例代码如下：
    List<String> list = new ArrayList<>();
    list. add("A");
    Collection<String> unmlist = Collections. unmodifiableCollection(list);
    unmlist. add("B"); // 运行时此行报错
    System. out. println(list.size());

多线程
35. 并行和并发有什么区别？
    并发（concurrency）和并行（parallellism）是：
    解释一：并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。
    解释二：并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。
    解释三：在一台处理器上“同时”处理多个任务，在多台处理器上同时处理多个任务。如hadoop分布式集群
    所以并发编程的目标是充分的利用处理器的每一个核，以达到最高的处理性能。

36. 线程和进程的区别？
    1、首先是定义
    进程：是执行中一段程序，即一旦程序被载入到内存中并准备执行，它就是一个进程。进程是表示资源分配的的基本概念，
    又是调度运行的基本单位，是系统中的并发执行的单位。
    线程：单个进程中执行中每个任务就是一个线程。线程是进程中执行运算的最小单位。
    2、一个线程只能属于一个进程，但是一个进程可以拥有多个线程。多线程处理就是允许一个进程中在同一时刻执行多个任务。
    3、线程是一种轻量级的进程，与进程相比，线程给操作系统带来侧创建、维护、和管理的负担要轻，意味着线程的代价或开销比较小。
    4、线程没有地址空间，线程包含在进程的地址空间中。线程上下文只包含一个堆栈、一个寄存器、一个优先权，
    线程文本包含在他的进程 的文本片段中，进程拥有的所有资源都属于线程。所有的线程共享进程的内存和资源。
    同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。
    但是每个线程拥有自己的栈段， 寄存器的内容，栈段又叫运行时段，用来存放所有局部变量和临时变量。
    5、父和子进程使用进程间通信机制，同一进程的线程通过读取和写入数据到进程变量来通信。
    6、进程内的任何线程都被看做是同位体，且处于相同的级别。不管是哪个线程创建了哪一个线程，
    进程内的任何线程都可以销毁、挂起、恢复和更改其它线程的优先权。线程也要对进程施加控制，
    进程中任何线程都可以通过销毁主线程来销毁进程，销毁主线程将导致该进程的销毁，对主线程的修改可能影响所有的线程。
    7、子进程不对任何其他子进程施加控制，进程的线程可以对同一进程的其它线程施加控制。子进程不能对父进程施加控制，
    进程中所有线程都可以对主线程施加控制。
    相同点：
    进程和线程都有ID/寄存器组、状态和优先权、信息块，创建后都可更改自己的属性，
    都可与父进程共享资源、都不鞥直接访问其他无关进程或线程的资源。
    
37. 守护线程是什么？
    守护线程（即daemon thread），是个服务线程，准确地来说就是服务其他的线程，这是它的作用——而其他的线程只有一种，那就是用户线程。所以java里线程分2种，
    1、守护线程，比如垃圾回收线程，就是最典型的守护线程。
    2、用户线程，就是应用程序里的自定义线程。
    1、守护线程，专门用于服务其他的线程，如果其他的线程（即用户自定义线程）都执行完毕，连main线程也执行完毕，
    那么jvm就会退出（即停止运行）——此时，连jvm都停止运行了，守护线程当然也就停止执行了。
    2、再换一种说法，如果有用户自定义线程存在的话，jvm就不会退出——此时，守护线程也不能退出，
    也就是它还要运行，干嘛呢，就是为了执行垃圾回收的任务啊。
    3、守护线程又被称为“服务进程”“精灵线程”“后台线程”，是指在程序运行是在后台提供一种通用的线程，
    这种线程并不属于程序不可或缺的部分。 通俗点讲，任何一个守护线程都是整个JVM中所有非守护线程的“保姆”。
    
38. 创建线程有哪几种方式？
    一、继承Thread类创建线程类
    （1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
    （2）创建Thread子类的实例，即创建了线程对象。
    （3）调用线程对象的start()方法来启动该线程。
    上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。
    二、通过Runnable接口创建线程类
    （1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
    （2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
    （3）调用线程对象的start()方法来启动该线程。
    三、通过Callable和Future创建线程
    （1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
    （2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
    （3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
    （4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
    总结：创建线程的三种方式的对比
    采用实现Runnable、Callable接口的方式创见多线程时，优势是：
    线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。
    在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，
    从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
    劣势是：
    编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。
    使用继承Thread类的方式创建多线程时优势是：
    编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。
    劣势是：
    线程类已经继承了Thread类，所以不能再继承其他父类。

39. 说一下 runnable 和 callable 有什么区别？
    相同点：
    都是接口
    都可以编写多线程程序
    都采用Thread.start()启动线程
    不同点：
    Runnable没有返回值；Callable可以返回执行结果，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果
    Callable接口的call()方法允许抛出异常；Runnable的run()方法异常只能在内部消化，不能往上继续抛
    注：Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

40. 线程有哪些状态？
    线程状态有 5 种，新建，就绪，运行，阻塞，死亡。关系图如下：
    1. 线程 start 方法执行后，并不表示该线程运行了，而是进入就绪状态，意思是随时准备运行，
    但是真正何时运行，是由操作系统决定的，代码并不能控制，
    2. 同样的，从运行状态的线程，也可能由于失去了 CPU 资源，回到就绪状态，也是由操作系统决定的。
    这一步中，也可以由程序主动失去 CPU 资源，只需调用 yield 方法。
    3. 线程运行完毕，或者运行了一半异常了，或者主动调用线程的 stop 方法，那么就进入死亡。死亡的线程不可逆转。
    4. 下面几个行为，会引起线程阻塞。
        主动调用 sleep 方法。时间到了会进入就绪状态
        主动调用 suspend 方法。主动调用 resume 方法，会进入就绪状态
        调用了阻塞式 IO 方法。调用完成后，会进入就绪状态。
        试图获取锁。成功的获取锁之后，会进入就绪状态。
        线程在等待某个通知。其它线程发出通知后，会进入就绪状态

41. sleep() 和 wait() 有什么区别？
    sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定立即恢复执行。
    这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非“醒来”的线程具有更高的优先级，正在运行的线程因为其它原因而阻塞。
　　wait()是线程交互时，如果线程对一个同步对象x 发出一个wait()调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。 

42. notify() 和 notifyAll() 有什么区别？
    先说两个概念：锁池和等待池
    锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，
    由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。
    等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁后，进入到了该对象的等待池中
    Reference：java中的锁池和等待池
    然后再来说notify和notifyAll的区别
    如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。
    当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），
    被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，
    而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争
    优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，
    它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。
    Reference：线程间协作：wait、notify、notifyAll
    综上，所谓唤醒线程，另一种解释可以说是将线程由等待池移动到锁池，notifyAll调用后，会将全部线程由等待池移到锁池，
    然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在锁池等待锁被释放后再次参与竞争。而notify只会唤醒一个线程。
    有了这些理论基础，后面的notify可能会导致死锁，而notifyAll则不会的例子也就好解释了
43. 线程的 run() 和 start() 有什么区别？
    调用 start() 方法是用来启动线程的，轮到该线程执行时，会自动调用 run()；直接调用 run() 方法，无法达到启动多线程的目的，
    相当于主线程线性执行 Thread 对象的 run() 方法。
    一个线程对线的 start() 方法只能调用一次，多次调用会抛出 java.lang.IllegalThreadStateException 异常；run() 方法没有限制。
    
44. 创建线程池有哪几种方式？
    通常开发者都是利用Executors提供的通用线程池创建方法，去创建不同配置的线程池，主要区别在于不同的
    Executors目前提供了5种不同的线程池创建配置：
    1、newCachedThreadPool（），它是用来处理大量短时间工作任务的线程池，具有几个鲜明特点：它会试图缓存线程并重用，
    当无缓存线程可用时，就会创建新的工作线程；如果线程闲置时间超过60秒，则被终止并移除缓存；长时间闲置时，
    这种线程池，不会消耗什么资源。其内部使用SynchronousQueue作为工作队列。
    2、newFixedThreadPool（int nThreads），重用指定数目（nThreads）的线程，其背后使用的是无界的工作队列，
    任何时候最多有nThreads个工作线程是活动的。这意味着，如果任务数量超过了活动线程数目，将在工作队列中等待空闲线程出现；
    如果工作线程退出，将会有新的工作线程被创建，以补足指定数目nThreads。
    3、newSingleThreadExecutor()，它的特点在于工作线程数目限制为1，操作一个无界的工作队列，所以它保证了所有的任务都是被顺序执行，
    最多会有一个任务处于活动状态，并且不予许使用者改动线程池实例，因此可以避免改变线程数目。
    4、newSingleThreadScheduledExecutor()和newScheduledThreadPool(int corePoolSize)，创建的是个ScheduledExecutorService，
    可以进行定时或周期性的工作调度，区别在于单一工作线程还是多个工作线程。
    5、newWorkStealingPool(int parallelism)，这是一个经常被人忽略的线程池，Java 8 才加入这个创建方法，
    其内部会构建ForkJoinPool，利用Work-Stealing算法，并行地处理任务，不保证处理顺序。

45. 线程池都有哪些状态？
    1.RUNNING：这是最正常的状态，接受新的任务，处理等待队列中的任务。线程池的初始化状态是RUNNING。
    线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0。
    2.SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务。调用线程池的shutdown()方法时，线程池由RUNNING -> SHUTDOWN。
    3.STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程。
    调用线程池的shutdownNow()方法时，线程池由(RUNNING or SHUTDOWN ) -> STOP。
    4.TIDYING：所有的任务都销毁了，workCount 为 0，线程池的状态在转换为 TIDYING 状态时，
    会执行钩子方法 terminated()。因为terminated()在ThreadPoolExecutor类中是空的，所以用户想在线程池变为TIDYING时进行相应的处理；
    可以通过重载terminated()函数来实现。?
    当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。
    当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。
    5.TERMINATED：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

46. 线程池中 submit() 和 execute() 方法有什么区别？
    execute() 参数 Runnable ；submit() 参数 (Runnable) 或 (Runnable 和 结果 T) 或 (Callable)
    execute() 没有返回值；而 submit() 有返回值
    submit() 的返回值 Future 调用get方法时，可以捕获处理异常

47. 在 Java 程序中怎么保证多线程的运行安全？
    1.原子性：提供互斥访问，同一时刻只能有一个线程对数据进行操作，（atomic,synchronized）；
    2.可见性：一个线程对主内存的修改可以及时地被其他线程看到，（synchronized,volatile）；
    3.有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序，该观察结果一般杂乱无序，（happens-before原则）。

48. 多线程中 synchronized 锁升级的原理是什么？
    锁的级别从低到高：
    无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁
    锁分级别原因：
    没有优化以前，sychronized是重量级锁（悲观锁），使用 wait 和 notify、notifyAll 来切换线程状态非常消耗系统资源；
    线程的挂起和唤醒间隔很短暂，这样很浪费资源，影响性能。所以 JVM 对 sychronized 关键字进行了优化，把锁分为 无锁、偏向锁、轻量级锁、重量级锁 状态。
    1、无锁：没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功，其他修改失败的线程会不断重试直到修改成功。
    2、偏向锁：对象的代码一直被同一线程执行，不存在多个线程竞争，该线程在后续的执行中自动获取锁，降低获取锁带来的性能开销。
    偏向锁，指的就是偏向第一个加锁线程，该线程是不会主动释放偏向锁的，只有当其他线程尝试竞争偏向锁才会被释放。
    偏向锁的撤销，需要在某个时间点上没有字节码正在执行时，先暂停拥有偏向锁的线程，然后判断锁对象是否处于被锁定状态。
    如果线程不处于活动状态，则将对象头设置成无锁状态，并撤销偏向锁；
    如果线程处于活动状态，升级为轻量级锁的状态。
    3、轻量级锁：轻量级锁是指当锁是偏向锁的时候，被第二个线程 B 所访问，此时偏向锁就会升级为轻量级锁，
    线程 B 会通过自旋的形式尝试获取锁，线程不会阻塞，从而提高性能。
    当前只有一个等待线程，则该线程将通过自旋进行等待。但是当自旋超过一定的次数时，轻量级锁便会升级为重量级锁；
    当一个线程已持有锁，另一个线程在自旋，而此时又有第三个线程来访时，轻量级锁也会升级为重量级锁。
    4、重量级锁：指当有一个线程获取锁之后，其余所有等待获取该锁的线程都会处于阻塞状态。
    重量级锁通过对象内部的监视器（monitor）实现，而其中 monitor 的本质是依赖于底层操作系统的 Mutex Lock 实现，
    操作系统实现线程之间的切换需要从用户态切换到内核态，切换成本非常高。

49. 什么是死锁？
    所谓死锁：是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，
    它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
    由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，
    永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象死锁。
    虽然进程在运行过程中，可能发生死锁，但死锁的发生也必须具备一定的条件，死锁的发生必须具备以下四个必要条件。
    1）互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。
    如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。
    2）请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，
    此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
    3）不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。
    4）环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；
    P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。
    
    在系统中已经出现死锁后，应该及时检测到死锁的发生，并采取适当的措施来解除死锁。目前处理死锁的方法可归结为以下四种：
    1) 预防死锁。
    　　这是一种较简单和直观的事先预防的方法。方法是通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，
    来预防发生死锁。预防死锁是一种较易实现的方法，已被广泛使用。但是由于所施加的限制条件往往太严格，可能会导致系统资源利用率和系统吞吐量降低。
    2) 避免死锁。
    　　该方法同样是属于事先预防的策略，但它并不须事先采取各种限制措施去破坏产生死锁的的四个必要条件，
    而是在资源的动态分配过程中，用某种方法去防止系统进入不安全状态，从而避免发生死锁。
    3)检测死锁。
    　　这种方法并不须事先采取任何限制性措施，也不必检查系统是否已经进入不安全区，此方法允许系统在运行过程中发生死锁。
    但可通过系统所设置的检测机构，及时地检测出死锁的发生，并精确地确定与死锁有关的进程和资源，然后采取适当措施，从系统中将已发生的死锁清除掉。
    4)解除死锁。
    　　这是与检测死锁相配套的一种措施。当检测到系统中已发生死锁时，须将进程从死锁状态中解脱出来。
    常用的实施方法是撤销或挂起一些进程，以便回收一些资源，再将这些资源分配给已处于阻塞状态的进程，使之转为就绪状态，以继续运行。
    死锁的检测和解除措施，有可能使系统获得较好的资源利用率和吞吐量，但在实现上难度也最大。
    
50. 怎么防止死锁？
    尽量使用 tryLock(long timeout, TimeUnit unit)的方法(ReentrantLock、ReentrantReadWriteLock)，设置超时时间，超时可以退出防止死锁。
    尽量使用 Java. util. concurrent 并发类代替自己手写锁。
    尽量降低锁的使用粒度，尽量不要几个功能用同一把锁。
    尽量减少同步的代码块。

51. ThreadLocal 是什么？有哪些使用场景？
    ThreadLocal 是线程本地存储，在每个线程中都创建了一个 ThreadLocalMap 对象，每个线程可以访问自己内部 ThreadLocalMap 对象内的 value。
    通过这种方式，避免资源在多线程间共享。
    经典的使用场景是为每个线程分配一个 JDBC 连接 Connection。这样就可以保证每个线程的都在各自的 Connection 上进行数据库的操作，
    不会出现 A 线程关了 B线程正在使用的 Connection； 还有 Session 管理 等问题。
    ThreadLocal 是线程本地存储,在每个线程都创建了一个ThreadLocalMap对象,每个线程可以访问自己内部ThreadLocalMal对象内的value. 
    通过这种方式,避免资源在多线程见共享
    如果使用ThreadLocal管理变量,则每一个使用该变量的线程都会获得该变量的副本
    副本之间相互独立,这样每一个线程都可以随意更改自己的变量副本,而不会对其他线程产生影响
    ThreadLocal();创建一个线程本地变量
    get();返回此线程局部变量的当前线程副本中的值
    initialValue();返回此线程局部变量的当前线程的"初始值"
    set(T value):将此线程局部变量的当前线程副本中的值设置为value

52. 说一下 synchronized 底层实现原理？

53. synchronized 和 volatile 的区别是什么？

54. synchronized 和 Lock 有什么区别？

55. synchronized 和 ReentrantLock 区别是什么？

56. 说一下 atomic 的原理？

反射
57. 什么是反射？
    AVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意一个方法和属性，
    这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
    这个类用于操纵（反向解析）一个类的属性，方法，构造器等。

58. 什么是 Java 序列化？什么情况下需要序列化？
    序列化：将 Java 对象转换成字节流的过程。
    反序列化：将字节流转换成 Java 对象的过程。
    当?Java 对象需要在网络上传输 或者 持久化存储到文件中时，就需要对 Java 对象进行序列化处理。
    序列化的实现：类实现 Serializable 接口，这个接口没有需要实现的方法。实现 Serializable 接口是为了告诉 jvm 这个类的对象可以被序列化。
    注意事项：
    某个类可以被序列化，则其子类也可以被序列化
    声明为 static 和 transient 的成员变量，不能被序列化。static 成员变量是描述类级别的属性，transient 表示临时数据
    反序列化读取序列化对象的顺序要保持一致

59. 动态代理是什么？有哪些应用？
    动态代理是运行时动态生成代理类。 动态代理的应用有 spring aop、hibernate 数据查询、测试框架的后端 mock、rpc，Java注解对象获取等。

60. 怎么实现动态代理？
    Java领域中，常用的动态代理实现方式有两种，一种是利用JDK反射机制生成代理，另外一种是使用CGLIB代理。
    JDK代理必须要提供接口，而CGLIB则不需要，可以直接代理类，需要引入CGLIB相关Jar包。

对象拷贝
61. 为什么要使用克隆？
    在JAVA中默认的“=”赋值操作，其实是将一个引用复制过去了，二者指向的还是同一块内存
    正因为JAVA的这种特性，所以当我们需要改变b时a的值不会变时，就需要调用clone方法了。
    clone()是JAVAobject类里面的一个protected型方法，要想调用clone()方法，必须先实现Cloneable接口，否则会抛出CloneNotSupportedException异常。
    
62. 如何实现对象克隆？
    有两种方式：
    1). 实现Cloneable接口并重写Object类中的clone()方法；
    2). 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下。

63. 深拷贝和浅拷贝区别是什么？
浅拷贝：复制基本类型的属性；引用类型的属性复制，复制栈中的变量 和 变量指向堆内存中的对象的指针，不复制堆内存中的对象。
深拷贝：复制基本类型的属性；引用类型的属性复制，复制栈中的变量 和 变量指向堆内存中的对象的指针和堆内存中的对象。

Java Web
64. JSP 和 servlet 有什么区别？
    基本介绍
    Servlet：
    Servlet 是一种服务器端的Java应用程序，具有独立于平台和协议的特性，可以生成动态的Web页面。
    它担当客户请求（Web浏览器或其他HTTP客户程序）与服务器响应（HTTP服务器上的数据库或应用程序）的中间层。
    Servlet是位于Web服务器内部的服务器端的Java应用程序，与传统的从命令行启动的Java应用程序不同，
    Servlet由Web服务器进行加载，该Web服务器必须包含支持Servlet的Java虚拟机。
    Jsp：
    JSP 全名为Java Server Pages，中文名叫java服务器页面，其根本是一个简化的Servlet设计。
    JSP技术使用Java编程语言编写类XML的tags和scriptlets，来封装产生动态网页的处理逻辑。
    网页还能通过tags和scriptlets访问存在于服务端的资源的应用逻辑。JSP将网页逻辑与网页设计的显示分离，
    支持可重用的基于组件的设计，使基于Web的应用程序的开发变得迅速和容易。 
    JSP(JavaServer Pages)是一种动态页面技术，它的主要目的是将表示逻辑从Servlet中分离出来。
    相同点
    jsp经编译后就变成了servlet，jsp本质就是servlet，jvm只能识别java的类，不能识别jsp代码，
    web容器将jsp的代码编译成jvm能够识别的java类。
    分析
    其实就是当你通过 http 请求一个 JSP 页面是，首先 Tomcat 会调用 service（）方法将JSP编译成为 Servlet，然后执行 Servlet。
    详细理解：当服务器启动后，当Web浏览器端发送过来一个页面请求时，Web服务器先判断是否是JSP页面请求。
    如果该页面只是一般的HTML/XML页面请求，则直接将HTML/XML页面代码传给Web浏览器端。
    如果请求的页面是JSP页面，则由JSP引擎检查该JSP页面，如果该页面是第一次被请求、或不是第一次被请求但已被修改，
    则JSP引擎将此JSP页面代码转换成Servlet代码，然后JSP引擎调用服务器端的Java编译器javac.exe对Servlet代码进行编译，
    把它变成字节码(.class)文件，然后再调用JAVA虚拟机执行该字节码文件，然后将执行结果传给Web浏览器端。
    如果该JSP页面不是第一次被请求，且没有被修改过，则直接由JSP引擎调用JAVA虚拟机执行已编译过的字节码.class文件，
    然后将结果传送Web浏览器端。
    不同点
    JSP侧重视图，Sevlet主要用于控制逻辑。
    Servlet中没有内置对象 。
    JSP中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象以及HttpServlet对象得到。
    
65. JSP 有哪些内置对象？作用分别是什么？
    1.HttpServletRequet类的Request对象：代表请求对象，主要用于接受客户端通过HTTP协议连接传输服务器端的数据。
    2.HttpSevletResponse类的Response对象：代表响应对象，主要用于向客户端发送数据。
    3.JspWriter类的out对象：主要用于向客户端输出数据，out的基类是jspWriter
    4.HttpSession类的session对象：主要用来分别保存每个月的信息与请求关联的会话；会话状态的维持是web应用开发者必须面对的问题。
    5.ServletContext类的application对象：主要用于保存用户信息，代码片段的运行环境；它是一个共享的内置对象，即一个容器中的多个用户共享一个application
    ，故其保存的信息被所有用户所共享。
    6.PageContext类的PageContext对象：管理网页属性，为jsp页面包装页面的上下文，管理对属于jsp的特殊可见部分中已经命名对象的访问，它的创建和初始化都是由容器来完成的。
    7.ServletConfig类的Config对象：代码片段配置对象，标识Servlet的配置。
    8.Object类的Page对象，处理jsp页面，是object类的一个实例，指的是jsp实现类的实例
    9.Exception对象：处理jsp文件执行时发生的错误和异常，只有在错误页面里才使用，前提是在页面指令里要有isErrorPage=true。

66. 说一下 JSP 的 4 种作用域？

67. session 和 cookie 有什么区别？
    1、存储位置不同
    cookie的数据信息存放在客户端浏览器上。
    session的数据信息存放在服务器上。
    2、存储容量不同
    单个cookie保存的数据<=4KB，一个站点最多保存20个Cookie。
    对于session来说并没有上限，但出于对服务器端的性能考虑，session内不要存放过多的东西，并且设置session删除机制。
    3、存储方式不同
    cookie中只能保管ASCII字符串，并需要通过编码方式存储为Unicode字符或者二进制数据。
    session中能够存储任何类型的数据，包括且不限于string，integer，list，map等。
    4、隐私策略不同
    cookie对客户端是可见的，别有用心的人可以分析存放在本地的cookie并进行cookie欺骗，所以它是不安全的。
    session存储在服务器上，对客户端是透明对，不存在敏感信息泄漏的风险。
    5、有效期上不同
    开发可以通过设置cookie的属性，达到使cookie长期有效的效果。
    session依赖于名为JSESSIONID的cookie，而cookie JSESSIONID的过期时间默认为-1，只需关闭窗口该session就会失效，因而session不能达到长期有效的效果。
    6、服务器压力不同
    cookie保管在客户端，不占用服务器资源。对于并发用户十分多的网站，cookie是很好的选择。
    session是保管在服务器端的，每个用户都会产生一个session。假如并发访问的用户十分多，会产生十分多的session，耗费大量的内存。
    7、浏览器支持不同
    假如客户端浏览器不支持cookie：
    cookie是需要客户端浏览器支持的，假如客户端禁用了cookie，或者不支持cookie，则会话跟踪会失效。关于WAP上的应用，常规的cookie就派不上用场了。
    运用session需要使用URL地址重写的方式。一切用到session程序的URL都要进行URL地址重写，否则session会话跟踪还会失效。
    假如客户端支持cookie：
    cookie既能够设为本浏览器窗口以及子窗口内有效，也能够设为一切窗口内有效。
    session只能在本窗口以及子窗口内有效。
    8、跨域支持上不同
    cookie支持跨域名访问。
    session不支持跨域名访问。