java面试题1

太过爱你忘了你带给我的痛 2022-11-04 15:28 181阅读 0赞

## 1，什么是Java虚拟机？ ##

因为虚拟机运行在操作系统中，所以虚拟机运行时是一个进程，没有运行时是一个程序，这个进程可以执行java的字节码。

通常我们编写的是一个  .java文件，通过javac编译器，把.java文件编译成虚拟机认识的.class文件（java源代码——》java字节码，字节码就是一串二进制数）

这是来了一个叫 “虚拟机” 的人：

*  它看到.class文件就把它用嘴吃了进去（虚拟机类加载系统加载.class文件）
 *  .class文件到达肠胃被消化（虚拟机中的执行引擎用来执行class文件中的字节码指令）
 *  当虚拟机还想吃东西（执行过程中需要，创建对象，分配内存），但胃已经装不下了，就会把东西拉出来（虚拟机垃圾处理机制把一些无用的对象清除）
 *  jvm是抽象化的计算机，包含了指令集，寄存器，堆，栈，方法区，垃圾回收，jvm负责将Java字节码文件翻译成不同操作平台的机器码

总结：虚拟机的本质就是一个进程，只是这个进程比较特殊可以运行.claa文件。

## 2，为什么Java被称作是“平台无关的编程语言”？ ##

真正跨平台的不是这个语言本身，而是**不同版本的虚拟机**实现跨平台。

*  .java文件——》.class文件——》不同机器的底层机器码，是语言转化的过程，跨平台值的是同样一个.java文件最终可以编译成不同机器的底层机器码。
 *  在转化的过程虚拟机相当于一个中间转化器，不同的版本虚拟机对应不同的机器，就可以将java文件转化对应的机器码。

## 3，JDK和JRE的区别是什么？ ##

*  Java Runtime Environment ：翻译过来是 java运行时环境，它包含了java虚拟机，java基础类库，作用是可以运行java程序，但不可以开发
 *  Java Development Kit：java开发工具，是java运行时环境的升级，给它加了个javac等各个便于开发的工具，可以将java文件编程class文件，所以可以进行开发。

## 4，”static”关键字是什么意思？ ##

*  static是静态的意思，它可以修饰成员变量，方法，块——》变成，静态成员，静态方法，静态块
 *  比如是我们声明一个静态成员    private static string name="建江"；那么这个name就属于它的类，注意不属于类的实例对象。静态成员实在这个类被调用的时候创建内存的。使用采用   类名.name的方式去调用它。
 *  因为静态方法比非静态方法内存分配的时间早：静态方法中不能调用非静态的方法。
 *  静态成员因为属于类的，所以内存只被分配一次。
 *  类与对象的关系：类是一个模板，对象是具体的实例。比如说我们声明一个类 **people是模板**，那么具体的人     “建江”    就是实例对象。

## 5，Java中是否可以覆盖(override)一个private或者是static的方法？ ##

*  都不能，覆盖指的是子类重写父类的方法，并且方法名和参数完全一样。
 *  方法覆盖是基于运行时动态绑定的，而static方法是编译时静态绑定的。static方法跟类的任何实例都不相关。两者没关系，并且内存分配的时间也不同
 *  private声明的方法是私有的，只能在该类被访问。不能被子类继承就谈不上覆盖（重写）

## 6，Java支持的数据类型有哪些？什么是自动拆装箱？为什么要进行自动拆装箱？ ##

基本数据类型：（注意：String是引用类型不是基本数据类型）

*  整数：byte  1字节，      short  2字节，     int  4字节，      long  8字节
 *  浮点数：float  4字节，    double   8字节
 *  字符：char   1字节
 *  布尔：Boolean  1位（1字节=8位）

引用数据类型：

*  类
 *  接口
 *  数组

自动拆装箱：自动装箱是Java编译器在基本数据类型和对应的对象包装类型之间做的一个转化。比如：把int转化成Integer，double转化成Double，等等。反之就是自动拆箱。

为什么要进行自动拆装箱？

*  如果你想在**方法体内更新基本数据类型的值**，必须要使用基本数据类型对应的引用类型，因为前者使用的值传递，后者使用的是引用传递。
 *  java.**util内操作的都是引用对象**
 *  Java提供的**集合框架中的数据结构**，比如ArrayList和Vector，也是**只能操作对象**。
 *  **多线程中也必须使用对象**来完成各种同步操作。

## 7，Java中的方法覆盖(Overriding)和方法重载(Overload)是什么意思？ ##

*  方法覆盖：子类重写了父类的方法，方法名和参数东西相同，方法体中的内容返回值不要求相同
 *  方法重载：同一个类中用几个，方法名字相同的方法但参数列表不同（返回值无限制）。便于让同一个方法根据参数传入的不同做不同的操作。

## 8，Java中，什么是构造方法？什么是构造方法重载？什么是复制构造方法？ ##

什么是构造方法？

*  每个类都有一个默认的构造方法，它是用来创建对象，和对象的初始化的。
 *  构造方法的方法名与类名一致，并且无返回值类型，不能被static、final、synchronized、abstract和native修饰
 *  当我们重写了构造方法时会覆盖原有的构造方法，所以通常我们会写上默认的构造方法。

什么是构造方法重载？

*  默认的构造方法没有参数
 *  为了更好的完成初始化工作我们通常需要重写构造方法，通过改变参数列表，和构造方法题来重写，相同的方法名，参数列表不同方法也就不同这就是方法重载

什么是复制构造方法？

*  拷贝构造方法就是用一个已经实例化的对象来new另一个对象
 *      public class People{
        private String name;
        private int age;
        //构造方法
        public Test() {
        
        }
        // 拷贝构造方法
        public People(People p) {
        	super();
        	this.name= p.name;
        	this.age= p.age
        }
        }

## 9，Java支持多继承么？（你可以有多个亲生爸爸吗？） ##

*  显然不能
 *  但是它可以实现多个接口来扩展功能

## 10，接口和抽象类的区别是什么？ ##

*  抽象类要被子类继承，接口要被类实现。
 *  接口只能做方法声明，抽象类中可以作方法声明，也可以做方法实现。
 *  接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
 *  接口是设计的结果，抽象类是重构的结果。
 *  抽象类和接口都是用来抽象具体对象的，但是接口的抽象级别最高。
 *  抽象类可以有具体的方法和属性，接口只能有抽象方法和不可变常量。
 *  抽象类主要用来抽象类别，接口主要用来抽象功能。

## 11，在java中按值传递和引用传递有什么区别 ##

什么是按值传递：下面例子中传到changeI方法中的不是变量i的地址，而是把它的值1赋值给number，所以i的值不会发生任何改变，因为方法没有对它进行任何的操作只是把它的值赋给number

（形参和实参指向内存中的不同区域）

public class Test1 {
        public static void main(String[] args) {
            int i=1;
            Test1.changeI(i);//传入的i是实参，调用方法的时候会把i的值1赋值给形参number，使得number的值为1
            System.out.println("我是i="+i);
    
        }
    
       static void  changeI(int number){//形参是number，接收实参的值
            number=10;
            System.out.println(number);
        }
    }

# #

什么是引用传递：传入方法中的不是值，而对象引用的地址，是对这个对象进行操作。（形参和实参指向内存中的相同区域）

public class Test1 {
        public static void main(String[] args) {
            Point point=new Point();
            System.out.println("("+point.x+","+point.y+")");
            Test1.changePoint(point);//传入引用对象
            System.out.println("("+point.x+","+point.y+")");   
        }
        
        static void  changePoint(Point point){//形参是number，接收实参的值
            point.x=10;
            point.y=10;
        }
    }
    
    class Point{
         int x=0;
         int y=0;
    }

## 12，进程和线程的区别是什么？ ##

具体参考：[https://blog.csdn.net/weixin\_44841312/article/details/104966035][https_blog.csdn.net_weixin_44841312_article_details_104966035]，[https://blog.csdn.net/weixin\_44841312/article/details/105191973][https_blog.csdn.net_weixin_44841312_article_details_105191973]

进程：进程实体=程序段+数据段+pcb，我们常说的创建进程其实就是创建pcb，撤销进程就是撤销pcb。所以pcb是进程存在的唯一标志，所以**进程是程序的一次执行过程**，**他是动态的**，**而进程实体是静态的**

线程：进程划分为几个小进程，我们给小进程取个名字叫线程，引入线程的目的：提高并发度。

区别：

*  根本区别：进程是操作系统**资源分配**的基本单位，而线程是**任务调度和执行**的基本单位
 *  开销区别：进程之间切换开销大；同一进程的线程之间切换的开销小。
 *  内存分配：系统为每个进程分配不同的内存空间；而对线程而言，除了CPU外，系统不会为线程分配内存、线程共享所属进程的资源。
 *  包含关系：线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程

## 13，创建线程有几种不同的方式？你喜欢哪一种？为什么？ ##

*  继承Thread类
 *  实现Runnable接口
 *  实现Callable接口
 *  使用Executor框架来创建线程池
 *  实现Runnable接口这种方式更受欢迎，因为这**不需要继承Thread类**。同时，线程池也是非常高效的，有利于资源的利用。

## 14，概括的解释下线程的几种可用状态。 ##

*  新建( new )：新创建了一个线程对象。
 *  可运行( runnable )：线程对象创建后，其他线程(比如 main 线程）调用了该对象 的 start ()方法。**该状态的线程位于可运行线程池中**，等待被线程调度选中，获 取 cpu 的使用权 。
 *  运行( running )：可运行状态( runnable )的线程获得了 cpu 时间片（ timeslice ） ，执行程序代码。 
 *  死亡( dead )：线程 run ()、 main () 方法执行结束，或者因异常退出了 run ()方法，则该线程结束生命周期。死亡的线程不可再次复生。
 *  阻塞( block )：阻塞状态是指线程因为某种原因放弃了 cpu 使用权，也即让出了 cpu 时间片 ，暂时停止运行。
 *  阻塞的情况分三种：

1.   等待阻塞：运行( running )的线程执行 object. **wait ()方法**， JVM 会把该线程放 入等待队列( waitting queue )中。
2.   同步阻塞：运行( running )的线程在获取对象的同步锁时，若该**同步锁 被别的线程占用**，则 JVM 会把该线程放入锁池( lock pool )中。
3.  其他阻塞: 运行( running )的线程执行 Thread .** sleep** ( long ms )或 t .** join ()方法**，或者发出了** I / O 请求时**， JVM 会把该线程置为阻塞状态。当 sleep ()状态超时、 join ()等待线程终止或者超时、或者 I / O 处理完毕时，线程重新转入可运行( runnable )状态。

## 15，什么是同步代码块？为什么要引入它？同步方法和同步代码块的区别是什么？ ##

*  同步代码块：
 *      synchronized(obj)
        {
            //需要被同步的代码块
        }
        /*
        
        其中，obj 称为同步监视器，也就是锁，原理是：当线程开始执行同步代码块前，必须先获得对同步代码块的锁定。并且任何时刻只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完成后，该线程会释放对该同步监视器的锁定。
        
        其中的锁，在非静态方法中可为this，在静态方法中为当前类本身
        */
 *  为什么引入同步代码块：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。即多个线程执行的不确定性引起执行结果的不稳定。
 *  **区别：**
 *  同步方法默认用this或者当前类class对象作为锁；
 *  同步代码块可以**选择以什么来加锁**，比同步方法要更细颗粒度，我们可以选择只同步会发生同步问题的部分代码而不是整个方法；
 *  同步方法使用关键字 synchronized修饰方法，而**同步代码块主要是修饰需要进行同步的代码**，用   synchronized（object）\{代码内容\}进行修饰；

# #

## 16，什么是死锁(deadlock)？ ##

参考：[https://blog.csdn.net/weixin\_44841312/article/details/105339475][https_blog.csdn.net_weixin_44841312_article_details_105339475]

*  所谓死锁是指多个进程因竞争资源而造成互相等待现象，若无外力作用，这些进程都将无法继续执行。
 *  产生死锁的条件：

1.  不可剥夺条件
2.  互斥访问条件
3.  请求保持条件
4.  循环等待条件

## 17，如何确保N个线程可以访问N个资源同时又不导致死锁？ ##

*  只要破坏产生死锁的条件就可以了（互斥条件一般不会破坏）
 *  破坏请求和保持：进程一次性请求它所需要的所有资源，如果资源不够就放弃请求，并释放持有的资源
 *  对各进程请求资源的顺序做一个规定，避免相互等待。

## 18，Java集合类框架的基本接口有哪些？ ##

*  Collection：代表一组对象，每一个对象都是它的子元素。
 *  Set：不包含重复元素的Collection。
 *  List：有顺序的collection，并且可以包含重复元素。
 *  Map：可以把键(key)映射到值(value)的对象，键不能重复。

## 19，为什么集合类没有实现Cloneable和Serializable接口？ ##

1，Serializable接口的作用：将对象的状态保存在存储媒体中以便可以在以后重写创建出完全相同的副本（对象存到字节流文件中，然后可以恢复）

应用：网络传输需要将对象转为字节流进行传输，所以要将对象序列化，转成字节流。

2，Cloneable接口作用：实现对象克隆要调用clone()方法，就必须实现Cloneable接口，这个接口没有具体的方法，主要是标记的作用

3，我们可以知道：Cloneable是复制对象的，序列化也是针对**对象的操作**，集合类只是管理对象的一个工具，就好比说list能够线性的**管理对象**。两者没有交集。

## 20，什么是迭代器(Iterator)？ ##

*  迭代器(Iterator)是一个对象，它的工作是遍历并选择序列中的对象，
 *  它提供了一种访问一个容器(container)对象中的各个元素，而又不必暴露该对象内部细节的方法。
 *  通过迭代器，开发人员不需要了解容器底层的结构，就可以实现对容器的遍历。
 *  由于创建迭代器的代价小，因此迭代器通常被称为轻量级的容器。
 *  例：

public class Test1 {
        public static void main(String[] args) {
            List<String> ll = new LinkedList<String>();
            ll.add("A");
            ll.add("B");
            ll.add("C");
            ll.add("D");
            Iterator<String> iterator = ll.iterator();
            while (iterator.hasNext()){
                String string = iterator.next();
                System.out.println(string);
            }
        }
    }

1.  iterator()方法返回一个Iterator对象，
2.  Iterator的next()方法返回第一个元素。
3.  Iterator()的hasNext()方法判断容器中是否还有元素。
4.  remove()方法删除迭代器返回的元素。

## 21，Iterator和ListIterator的区别是什么？ ##

*  Iterator只能正向遍历集合，适用于获取移除元素
 *  ListIterator继承自Iterator，专门针对List，可以从两个方向来遍历List，并且包含其他的功能，比如：增加元素，替换元素，获取前一个和后一个元素的索引，等等。

# #

## 22，Java中的HashMap的工作原理是什么？ ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70][]

1.  整体结构：jdk1.8以前是：数组+链表，jdk1.8之后：数组+链表+红黑树（当链表长度大于8时就转成红黑树结构，克服了链表太长时查找速度慢的问题）
2.  HashMap是以键值对(key-value)的形式存储元素，put()方法存元素，get()方法取出元素，hash()方法用于
3.  当调用put()方法的时候，HashMap会计算key的hash值，判断对应位置的数组是否有值，没有值就存入该位置，有值就插入对应的链表中（1.7是头插法，1.8是尾插法）。如果插入时key值相同就替换它

public class Test1 {
        public static void main(String[] args) {
            Map<String, Integer> map = new HashMap<String, Integer>();
            map.put(null, 0);
            map.put("java", 1);
            map.put("c++", 2);
            map.put("python", 3);
            map.put("php", 4);
            map.put("nodejs", 5);
            for(Map.Entry<String, Integer> entry : map.entrySet()) {
                System.out.println(entry.getKey() + ": " + entry.getValue());
            }
            System.out.println("php".hashCode() == "c++".hashCode());
        }
    }

# #

## 23，hashCode()和equals()方法的重要性体现在什么地方？为什么要重写equals()? ##

参考：[https://www.cnblogs.com/jesonjason/p/5492208.html][https_www.cnblogs.com_jesonjason_p_5492208.html]

*  HashMap使用hashCode()和equals()方法来确定键值对的索引，获取hashMap中的键值对，发现是否有重复元素需要它来保证精确性
 *  因为默认的equals()方法掉用的是   ==    进行判断两个对象是否指向相同的地址空间来判断是否相等，意味着指相同的两个不同对象是不相等的，所以需要重写

重写equals方法：

class People{
        private String name;
        private int age;
        People(){
        }
        People(String name,int age){
            this.name=name;
            this.age=age;
        }
        public static void main(String[] args) {
            People people1=new People("小明",10);
            People people2=new People("小明",10);
            System.out.println(people1.equals(new ArrayList<String>()));
            System.out.println(people1.equals(null));
            System.out.println(people1.equals(people1));
            System.out.println(people1.equals(people2));
    
    
        }
    
        @Override
        public boolean equals(Object obj) {
            if (obj==null) return false;
            if (obj==this) return true;
            if (obj instanceof People){//防止类型转换异常
                People p = (People) obj;//必须向下转型，因为父类不能访问子类的成员
                return (this.name.equals(p.name)&&this.age==p.age);
            }
            return false;
        }
    
    }

### 为什么重写equals方法后，一定要重写hashCode方法？ ###

因为重写equals方法后，两个对象只需要属性值相同我们就认为这两个对象是相同的，但是由于两个对象的地址不同所以他们的hash值是不同的，存入hashmap中的位置也是不同的。为了杜绝这种情况发生，就需要对hashCode方法进行重写，保证相同的对象具有相同的hashCode，存入hashMap的位置也是相同的。

## 24，HashMap和Hashtable有什么区别？ ##

*  HashMap允许键和值是null，而Hashtable不允许键或者值是null。
 *  Hashtable是同步的，适合于单线程环境；而HashMap不是同步的，适合于多线程环境。
 *  HashMap提供了可供应用迭代的键的集合，因此，HashMap是快速失败的。Hashtable不是

## 25，Array和ArrayList有什么区别？什么时候应该使用Array而不是ArrayList？ ##

*  **存储类型：**Array是数组每次只能存储同类型的数据，这个数据可以是**基本类型**或**引用类型，**而ArrayList是集合，可以存储不同类型的数据，但只能存储引用类型（存基本类型时使用其包装类）
 *  **大小：**Array长度固定，ArrayList的长度可以动态变化。
 *  **功能：**ArrayList提供了更多的方法，如addAll()，removeAll()，iterator()等，功能比较强大
 *  **应用场景：**当能确定长度并且数据类型一致的时候就可以用array，其他时候使用ArrayList

# #

## 26，ArrayList和LinkedList有什么区别？ ##

*  本质区别：ArrayList的底层是动态数组，LinkList的底层是双向链表（所以他们的区别可以转成动态数组与链表的区别）
 *  读取数据的时间复杂度：ArrayList以O(1)时间复杂度对元素进行随机访问(按引用查找），LinkList查找数据的时间复杂度是O(n)。
 *  插入删除数据的速度：ArrayList插入删除数据要移动元素，速度慢。LinkedList只需要改变指针的指向位置就行了，速度快
 *  空间消耗：ArrayList的消耗体现在list列表的结尾预留一定的容量空间，而LinkedList消耗体现在每一个元素都需要消耗相当的空间来存指向上一节点和下一节点的指针。

## 27，Comparable和Comparator接口是干什么的？列出它们的区别。 ##

*  Comparable接口：只有compareTo()方法，这个方法可以个给两个**对象排序**，返回值为（整数 ，0，负数）表明已存在的对象（>     =       <）输入的对象。
 *  Comparator接口：有compare()和equals()方法

1.  compare()方法：用来给两个输入**参数排序**，返回（负数，0，正数）表明第一个参数是（<，=，>）第二个参数。
2.  equals()方法：用来**判断两个comparator是否相等**，输入参数也是一个comparator并且输入参数和当前comparator的排序结果是相同的时候，这个方法才返回true

## **28，什么是Java优先级队列(Priority Queue)？** ##

*  应用场景：任务调度系统，但是呢任务是分等级的，也就是说比较高级的任务必须优先执行
 *  PriorityQueue是无界队列；底层是优先级堆，元素按自然顺序进行排序，不允许有null值（因为null值没有相关联的比较器）；线程不安全，入队和出队的时间复杂度是O(log(n))。
 *  在创建PriorityQueue的时候，我们可以给它提供一个负责给元素排序的比较器：
 *  具体的例子：[https://blog.csdn.net/u010741032/article/details/81806762][https_blog.csdn.net_u010741032_article_details_81806762]

## 29，你了解大O符号(big-O notation)么？你能给出不同数据结构的例子么？ ##

*  数据结构中描述时间复杂度，空间复杂度的东东：如：时间复杂度为O(n），空间复杂度为O(1)
 *  所以他是算法的规模（上界），内存消耗规模的描述符号。
 *  补充：O是上界，Θ是平均值，Ω是下界

## 30，如何权衡是使用无序的数组还是有序的数组？ ##

*  有序数组：优点：可以使用二分查找时间复杂度为O(log(N))，缺点：插入操作的时间复杂度是O(n)（为了保证有序而移动大量元素）
 *  无序数组：优点：插入操作的时间复杂度是O(1)，查找的时间复杂度为O(n)（按值查找）

## 31，Enumeration接口和Iterator接口的区别有哪些？ ##

*  Enumeration速度是Iterator的2倍，同时占用更少的内存。
 *  Iterator比Enumeration的线程安全，因为其他线程不能修改被iterator遍历的集合里面的对象。
 *  Iterator允许调用者删除底层集合里面的元素，Enumeration不能。

## 32，HashSet和TreeSet有什么区别？ ##

*  HashSet：底层是hash结构，所以它的元素是无序。它的add()，remove()，contains()方法的时间复杂度是O(1)。
 *  TreeSet：底层是树形的结构，它的元素是有序的。它的add()，remove()，contains()方法的时间复杂度是O(logn)。

## 33，Java中垃圾回收有什么目的？什么时候进行垃圾回收？ ##

*  目的：回收堆中不再使用的对象，释放资源。
 *  回收时间（触发GC的时间）：当对象失去引用后，系统会在**合适**的时间回收它所占的内存。
 *  深入理解垃圾回收机制：[https://blog.csdn.net/m0\_37719047/article/details/89359996][https_blog.csdn.net_m0_37719047_article_details_89359996]

## 34，System.gc()和Runtime.gc()会做什么事情？ ##

*  gc()方法的作用：呼叫JVM的垃圾回收器运行，回收内存的垃圾。
 *   java.lang.System.gc()和java.lang.Runtime.getRuntime().gc()是相同的方法，两者没有区别

# #

## 35，finalize()方法什么时候被调用？析构函数(finalization)的目的是什么？ ##

*  内存紧张时调用：finalize()用于回收对象（内存充足时不会调用）
 *  finalize()主要是给其他调用而创建的空间在对象回收时页**同步回收**而设置的
 *  finalize()回收特殊渠道申请的内存：JNI(Java Native Interface)调用non-Java程序
 *  补充：（使用native关键字说明这个方法是原生函数，也就是这个方法是用C/C++语言实现的，并且被编译成了DLL，由java去调用。）

## 36，如果对象的引用被置为null，垃圾收集器是否会立即释放对象占用的内存？ ##

*  不会立即释放对象占用的内存。
 *  如果对象的引用被置为null，只是断开了当前线程栈帧中对该对象的引用关系。
 *  而垃圾收集器是运行在后台的线程，只有当**用户线程运行到安全点(safe point)**或者安全区域才会扫描对象引用关系，
 *  扫描到对象没有被引用则会标记对象，这时候**仍然不会立即释放**该对象内存，因为有些对象是可恢复的（在 finalize方法中恢复引用 ）。
 *  只有**确定了对象无法恢复引用**的时候才会清除对象内存。

# #

## 37，什么是Java堆？什么是堆中的永久代(Perm Gen space)? ##

*  **定义**：JVM的堆是**运行时数据区**，它在JVM启动的时候被创建。
 *  **作用**：所有类的实例和数组都是在堆上分配内存，对象所占的堆内存是由垃圾收集器回收。
 *  **组成**：堆内存是由存活和死亡的对象组成的。

1.  **存活的对象**是应用可以访问的，不会被垃圾回收。
2.  **死亡的对象**是应用不可访问尚且还**没有**被垃圾收集器**回收掉**的对象。一直到垃圾收集器把这些对象回收掉之前，他们会一直占据堆内存空间。

*  虚拟机中的堆共划分为三个代：年轻代、年老代， 持久代
 *  年轻代：所有新生成的对象首先都是放在年轻代的。年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象。
 *  年老代：在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。所以年老代中存放的都是一些生命周期较长的对象
 *  持久代：用于存放静态文件，如今Java类、方法等（jdk1.8持久代更名为了元空间）

## 38,串行(serial)收集器和吞吐量(throughput)收集器的区别是什么？ ##

*  吞吐量收集器：使用并行版本的新生代垃圾收集器，用于**中等规模和大规模数据**的应用程序。
 *  串行收集器：对大多数的**小应用**(在现代处理器上需要大概100M左右的内存)就足够了。

## 39，在Java中，对象什么时候可以被垃圾回收？ ##

*  对象死亡，并且不能回复的时候被finalize方法复活。

## 40，JVM的永久代中会发生垃圾回收么？ ##

*  会，永久代满了或者是超过了临界值，会触发完全垃圾回收。

## 41，Java中的两种异常类型是什么？他们有什么区别？ ##

*  unchecked exceptions（运行时异常）：RuntimeException类及其子类异常，如NullPointerException，IndexOutOfBoundsException，ClassCastException——控制台出现报错
 *  checked exceptions（非运行时异常 ）：写代码时出现红线，需要try catch或者throws时出现的异常——如果不处理，程序就不能编译通过

# #

## 42，Java中Exception和Error有什么区别？ ##

Error：是程序无法处理的错误，JVM出现的问题。如 （Virtual MachineError，OutOfMemoryError）JVM一般会选择线程终止。

Exception：是程序本身可以处理的异常。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 1][]

## 44，throw和throws有什么区别？ ##

*  throws出现在方法函数头，而throw出现在函数体。
 *  throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。
 *  它们抛出的异常都由上层调用的函数处理。

## 45，异常处理完成以后，Exception对象会发生什么变化？ ##

*  Exception对象会在下一个垃圾回收过程中被回收掉。

## 46，final关键字、finally代码块和finalize()方法有什么区别？ ##

**final关键字：**

*  final是关键字，final可以修饰类、方法、属性。
 *  如果final修饰类，那么这个类就是最终类，不能派生出新的子类（一个类不能同时被final和abstract修饰）
 *  如果final修饰方法，那么这个方法是最终方法，不允许任何子类重写该方法，但子类仍可以使用该方法。
 *  被final修饰的变量不可变——》所以是常量，因此在创建时就初始化。

**finally代码块：**

*  finally作为异常处理的一部分，只能用在try/catch语句快中，finally代码块中的语句一定会被执行，
 *  经常被用来释放资源，如IO流和数据库资源的释放。

**finalize()方法:**

*  finalize()方法是Object类的一个protected方法，
 *  当垃圾回收器准备释放某个对象占用的空间，JVM将首先调该对象的 finalize()方法，
 *  并且在**下一次垃圾回收动作发生时**，才真正将该对象占用的内存回收

## 47，什么是Applet？生命周期是？（这个技术淘汰了） ##

*  Java的用户程序分为两类：Java Application和Java Applet：

**Application：**

*  application主要是桌面应用程序的开发,application是不能用Jsp加载的 。
 *  Java Application是完整的程序，可以独立运行。
 *  Java Application程序被编译以后，用普通的Java解释器就可以使其边解释边执行。
 *  每个Java Application程序必定含有一个并且只有一个main方法，程序执行时，首先寻找main方法，并以此为入口点开始运行。

**Applet：**

*  applet一般用于B/S页面上作为插件式的开发。
 *  Java Applet程序**不能单独运行**，它必须嵌入到用HTML语言编写的Web页面中，通过与Java兼容的浏览器来控制执行。
 *  Java Applet必须通过网络**浏览器**或者Applet观察器才能**执行**。
 *  Applet程序则**没有含main**方法的主类，这也正是 Applet程序不能独立运行的原因。

**Applet生命周期：**

*  Init：每次被载入的时候都会被初始化。
 *  Start：开始执行applet。
 *  Stop：结束执行applet。
 *  Destroy：卸载applet之前，做最后的清理工作。

==========================================================

## 48，**两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？** ##

*  不对，hashCode()相同说明两个对象在哈希表中的索引下标相同。当它们的实际编号并不相同

## 49，** java 中操作字符串都有哪些类？它们之间有什么区别？** ##

*  ## 操作字符串的类有：String、StringBuffer、StringBuilder。 ##
 *  String 声明的是不可变的对象，每次操作都会生成新的 String 对象，然后将指针指向新的 String 对象。
 *  StringBuffer、StringBuilder 可以在原有对象的基础上进行改变。
 *  StringBuffer 是线程安全的，多线程使用；而 StringBuilder 是非线程安全的，单线程使用
 *  StringBuffer性能低，StringBuilder 的性能高

## 50，java中的堆，栈，常量池的区别？ ##

参考：[https://blog.csdn.net/star20100906/article/details/94405805][https_blog.csdn.net_star20100906_article_details_94405805]

*  栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。Java自动管理栈和堆，，程序员不能直接地设置栈或堆。
 *  栈的优点：存取速度比堆要快，栈数据可以共享。缺点：存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。
 *  堆的优点：可以动态地分配内存大小，存储对象引用。生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。缺点：存取速度较慢（要在运行时动态分配内存）
 *   常量池：存放字符串常量和基本类型常量，优点：避免频繁的创建和销毁对象而影响系统性能，其实现了对象的共享。

## 51，**如何将字符串反转？** ##

*  使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。
 *      class test{
            public static void main(String[] args) {
                StringBuffer stringBuffer=new StringBuffer("hello world!");
                stringBuffer.reverse();
                System.out.println(stringBuffer);
            }
        }

## 52，**String 类的常用方法都有那些？** ##

indexOf()//返回指定字符的索引。
    
    charAt()//返回指定索引处的字符。
    
    replace()//字符串替换。
    
    trim()//去除字符串两端空白。
    
    split()//分割字符串，返回一个分割后的字符串数组。
    
    getBytes()//返回字符串的 byte 类型数组。
    
    length()//返回字符串长度。
    
    toLowerCase()//将字符串转成小写字母。
    
    toUpperCase()//将字符串转成大写字符。
    
    substring()//截取字符串。
    
    equals()//字符串比较。

## 53，** BIO、NIO、AIO 有什么区别？** ##

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

## 54，**Files的常用方法都有哪些？** ##

Files.exists()//检测文件路径是否存在。
    
    Files.createFile()//创建文件。
    
    Files.createDirectory()//创建文件夹。
    
    Files.delete()//删除一个文件或目录。
    
    Files.copy()//复制文件。
    
    Files.move()//移动文件。
    
    Files.size()//查看文件个数。
    
    Files.read()//读取文件。
    
    Files.write()//写入文件。

## 55，**Collection 和 Collections 有什么区别？** ##

*  Collection 是一个集合接口（集合类的一个顶级接口）
 *  Collections则是集合类的一个工具类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

## 56，**List、Set、Map 之间的区别是什么？** ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 2][]

## 57，**如何决定使用 HashMap 还是 TreeMap？** ##

*  对于在Map中插入、删除和定位元素这类操作，HashMap是最好的选择。
 *  然而，假如你需要对一个**有序的key集合进行遍历**，TreeMap是更好的选择。

## 58，**如何实现数组和 List 之间的转换？** ##

*  List转换成为数组：调用ArrayList的toArray方法。
 *  数组转换成为List：调用Arrays的asList方法。

## 59，**在 Queue 中 poll()和 remove()有什么区别？** ##

*  poll() 和 remove() 都是从队列中取出一个元素，
 *  但是 poll() 在获取元素失败的时候会返回空，但是 remove() 失败的时候会抛出异常。

## 60，**哪些集合类是线程安全的？** ##

*  vector：就比arraylist多了个同步化机制（线程安全），效率较低
 *  statck：堆栈类，先进后出。
 *  hashtable：就比hashmap多了个线程安全。
 *  enumeration：枚举，相当于迭代器。

## 61，**说一下 runnable 和 callable 有什么区别？** ##

*  实现Callable接口的任务线程能返回执行结果；而实现Runnable接口的任务线程不能返回结果；
 *  Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛

## 62，**sleep() 和 wait() 有什么区别？** ##

*  sleep()是线程类的静态方法：当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个对象。
 *  wait()是Object类的方法：线程执行到wait()，该线程进入等待池，对象锁会被释放，需要notify，notifyAll方法来唤醒等待的线程。

## 63，**notify()和 notifyAll()有什么区别？** ##

*  notifyAll()：唤醒所有 wait 线程
 *  notify()：随机唤醒一个 wait 线程
 *  notify和notifyAll()会把线程唤醒后加入到锁池中竞争对象锁

## 64，**线程的 run()和 start()有什么区别？** ##

*  **run()方法是线程体，里面是该线程要执行的具体操作**
 *  **start()方法是线程启动的方法，所以start方法是决定了多线程。**

## **65，创建线程池有哪几种方式？** ##

*  newFixedThreadPool(int nThreads)：创建一个固定长度的线程池
 *  newCachedThreadPool()：当线程不够用了，会回收空闲线程或者添加新线程
 *  newSingleThreadExecutor()：单线程，确保依照任务在队列中的顺序来串行执行。
 *   newScheduledThreadPool(int corePoolSize)：创建一个延迟或定时的方式来执行任务固定大小的线程池。

## 66，**线程池都有哪些状态？** ##

*  **Running：线程池接收任务，处理已有任务**
 *  **ShutDown：线程池不接收任务，处理已有任务，****调用shutDownNow方法进入**
 *  **Stop：线程池不接收任务，断已有任务，调用shutDownNow方法进入**
 *  **Tidying：所有的任务已终止，ctl记录的”任务数量”为0**
 *  **Terminated：线程池彻底终止，TIDYING状态时，会执行钩子函数terminated()**

## 67，**在 java 程序中怎么保证多线程的运行安全？** ##

**参考：**[https://www.cnblogs.com/zhengbin/p/5654805.html][https_www.cnblogs.com_zhengbin_p_5654805.html]

*  原子性：一个或者多个操作在 CPU 执行的过程中**不被中断**的特性——》  synchronized 和在 lock、unlock 中操作保证原子性。
 *  可见性：一个线程对**共享变量的修改**，另外一个线程能够**立刻看到——》** volatile、synchronized 和 final 实现可见性。
 *  有序性：程序执行的顺序按照**代码的先后顺序执行——》** volatile 和 synchronized 两个关键字来保证线程之间操作的有序性

## 68，java中的锁升级原理 ##

![图片][8cea7c512766d081fd2719010a073d62.png]

## 69，**ThreadLocal 是什么？有哪些使用场景？** ##

*  ** 是线程内部变量，属于线程所有，是一种线程安全方式**
    
        public class TestThreadLocal {
        	
        	//线程本地存储变量
        	private static final ThreadLocal<Integer> THREAD_LOCAL_NUM = new ThreadLocal<Integer>() {
        		@Override
        		protected Integer initialValue() {
        			return 0;
        		}
        	};
         
        	public static void main(String[] args) {
        		for (int i = 0; i < 3; i++) {//启动三个线程
        			Thread t = new Thread() {
        				@Override
        				public void run() {
        					add10ByThreadLocal();
        				}
        			};
        			t.start();
        		}
        	}
        	
        	/**
        	 * 线程本地存储变量加 5
        	 */
        	private static void add10ByThreadLocal() {
        		for (int i = 0; i < 5; i++) {
        			Integer n = THREAD_LOCAL_NUM.get();
        			n += 1;
        			THREAD_LOCAL_NUM.set(n);
        			System.out.println(Thread.currentThread().getName() + " : ThreadLocal num=" + n);
        		}
        	}
        	
        }

## 70，**一下 synchronized 底层实现原理？** ##

*  **给会发生线程安全问题的代码加锁**
 *  它可以保证方法或者代码块在运行时，同一时刻只有一个线程可以进入到临界区
 *  它还可以保证共享变量的内存可见性。

*  普通同步方法，锁是当前实例对象
 *  静态同步方法，锁是当前类的class对象
 *  同步方法块，锁是括号里面的对象

## 71，**synchronized 和 volatile 的区别是什么？** ##

*  volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
 *  volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
 *  volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
 *  volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
 *  volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化

## 72，** 什么是反射？** ##

*  Java反射就是在运行状态中，**对于任意一个类，都能够知道这个类的所有属性和方法**；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性
 *  根据类名类名获取该类的信息，实现解耦降低程序间的依赖关系。

## 73，**什么是 java 序列化？什么情况下需要序列化？** ##

*  **序列化：将对象转成字节流的过程**
 *  **反序列化：将字节流转成对象的过程**
 *  **实现：要序列化的类实现Serializable 接口，该接口没有方法，只是用于告诉虚拟机该类可以序列化。**
 *  **应用场景：网络传输数据，将数据数据持久化到硬盘**
 *  **注意：static变量是类变量，transient变量是临时变量。不能被序列化。父类可以序列化，子类也可以**

## **74，动态代理是什么？有哪些应用？** ##

*  是一种设计模式：主要用来做方法的增强，让你可以在不修改源码的情况下，对源码进行增强。
 *  应用：Spring的AOP，加事务，加权限，加日志。
 *  动态代理的实现：[https://blog.csdn.net/ljt2724960661/article/details/52507314][https_blog.csdn.net_ljt2724960661_article_details_52507314]

## 75，java的克隆机制 ##

*  浅拷贝：只是复制了对象的引用地址，**两个对象指向同一个内存地址**，所以修改其中任意的值，另一个值都会随之变化。
 *  浅拷贝实现：对象实现Cloneable接口并重写Object类中的clone()方法
 *  深拷贝：是将**对象及值复制**过来，两个对象修改其中任意的值另一个值不会改变。实现cloneable接口，
 *  深拷贝实现：对象实现Serializable接口，通过对象的序列化和反序列化实现克隆

## 76，Servlet处理请求的过程是什么？ ##

*  Web Client 向Servlet容器（Tomcat）发出Http请求
 *  Servlet容器接收Web Client的请求
 *  Servlet容器创建一个HttpRequest对象，将Web Client请求的信息封装到这个对象中。
 *  Servlet容器创建一个HttpResponse对象
 *  Servlet容器调用HttpServlet对象的service方法，把HttpRequest对象与HttpResponse对象作为参数传给HttpServlet 对象。
 *  HttpServlet调用HttpRequest对象的有关方法，获取Http请求信息。
 *  HttpServlet调用HttpResponse对象的有关方法，生成响应数据。
 *  Servlet容器把HttpServlet的响应结果传给Web Client

## 77，**jsp 九大内置对象的作用是什么？** ##

*  request：封装客户端的请求，其中包含来自GET或POST请求的参数；
 *  response：封装服务器对客户端的响应；
 *  pageContext：通过该对象可以获取其他对象；
 *  session：封装用户会话的对象；
 *  application：封装服务器运行环境的对象；
 *  out：输出服务器响应的输出流对象；
 *  config：Web应用的配置对象；
 *  page：JSP页面本身（相当于Java程序中的this）；
 *  exception：封装页面抛出异常的对象。

## 78，**说一下 jsp 的 4 种作用域？** ##

*  application：作用域当前应用
 *  session：：作用域当前会话
 *  request：作用域当前请求
 *  page ：作用域当前页面

## 79，**session 和 cookie 有什么区别？** ##

*  Cookie和Session都是会话技术，Cookie是运行在客户端，Session是运行在服务器端
 *  Cookie有大小限制以及浏览器在存cookie的个数也有限制，Session是没有大小限制和服务器的内存大小有关。
 *  Cookie有安全隐患，通过拦截或本地文件找得到你的cookie后可以进行攻击
 *  Session是保存在服务器端上会存在一段时间才会消失，如果session过多会增加服务器的压力。

## 80，**说一下 session 的工作原理？** ##

*  生命周期：一般为30分钟没有访问session，用户关闭浏览器时，sessionId的信息会丢失。
 *  定义：session是服务器端的一个集合，可以存储任何东西（常用于识别客户）
 *  原理：如果是第一次取session，服务器会创建一个session对象（session本身是一个map集合），并且存入服务器的session集合中以sessionId为标识键，也就是根据sessionId即可取到对应session的引用。同时使用session Servlet还获得了一个sessionId,在响应时把这个sessionId以cookie的形式发给了客户端。如果客户访问其它同一域的Servlet，这个sessionId会跟着请求上传到服务器。那么如果请求的另一个Servlet也要使用session,会先检查有没有这个保存sessionId的Cookie,如果有则直接到session集合中取对应的session引用返回给要使用的Servlet,所以，只要客户端存在这个sessionId，不管请求哪个Servlet，都可以拿到同一个session。所以Session就可以给不同的请求存储数据。
 *  使用：
 *      HttpSession session = request.getSession();//取出session
        session.setAttribute("goods1","Scoat");//session存数据
        session.getAttribute("goods1");//session取数据
        
        
        
        session.setMaxInactiveInterval(20 *  60);//设置session过期时间
        session.invalidate();//销毁session的方法
        session.getCreationTime();//获得session的创建时间
        session.getLastAccessedTime();//获得session最后一次被使用的时间

================================================================================

### 1、short s1,s1=s1+1;是否有错？ ###

有错。s1=s1+1结果是int类型，而 s 是short类型，需要强制类型转换。

s1 += 1会自动强制类型转换为int类型。

### 2、是否可以继承String类。 ###

不可以，因为string被final修饰

### 3、给出一个常见的runtime exception。 ###

*  空指针异常
 *  算术异常
 *  数组下标越界异常
 *  类型转换异常

### 4、最有效率的方法算2\*8等于几 ###

2<<3

### 5，java中存在内存泄露吗？如果存在请举一个例子，如果处理内存泄露？ ###

具体参考：[https://blog.csdn.net/anxpp/article/details/51325838][https_blog.csdn.net_anxpp_article_details_51325838]

*  内存泄露：一些对象被使用一次，就长时间没被使用，而它因为有引用指向它而不能被gc回收器回收器。该对象长时间占用内存空间，就是内存泄露
 *  例如object对象只在method1中调用一次后，后就长时间不在调用它，需要类对象释放内存它才会释放内存
 *      public class Simple {
         
            Object object;
         
            public void method1(){
                object = new Object();
            //...其他代码
            }
        }
 *  解决方案：在使用完object对象，设置它的值为null

### 6，同步和异步的区别是什么？ ###

*  同步:发送一个请求,等待返回,然后再发送下一个请求  ，
 *  异步:发送一个请求,不等待返回,随时可以再发送下一个请求 
 *  同步可以避免出现死锁，读脏数据的发生，一般共享某一资源的时候用，如果每个人都有修改权限，同时修改一个文件，有可能使一个人读取另一个人已经删除的内容，就会出错，
 *  同步就会按顺序来修改。 异步则是可以提高效率了，现在cpu都是双核，四核，
 *  异步处理 的话可以同时做多项工作，当然必须保证是可以并发处理的。 这些都是对的。
 *  同步和异步最大的区别就在于。一个需要等待，一个不需要等待。 比如广播，就是一个异步例子。发起者不关心接收者的状态。不需要等待接收者的返回信息 电话，就是一个同步例子。发起者需要等待接收者，接通电话后，通信才开始。需要等待接收者的返回信息

### 7，请写出一个单例模式 ###

package cn.itcast.test.SingleTon;
    
    import java.io.*;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    public class HungrySingleTonTest {
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException, ClassNotFoundException {
            //内部类模式检测两个实例化对象是否一样，多线程情况下是否不安全
            new Thread(()->{
                InnerSingleTon instance1=InnerSingleTon.getInstance();
                System.out.println(instance1);
            }).start();
    
            new Thread(()->{
                InnerSingleTon instance2=InnerSingleTon.getInstance();
                System.out.println(instance2);
            }).start();
    
            //懒汉模式检测两个实例化对象是否一样，多线程情况下是否不安全
            new Thread(()->{
                LazySingleTon instance1=LazySingleTon.getInstance();
                System.out.println(instance1);
            }).start();
    
            new Thread(()->{
                LazySingleTon instance2=LazySingleTon.getInstance();
                System.out.println(instance2);
            }).start();
            
            //饿汉模式检测两个实例化对象是否一样，多线程情况下是否不安全
            new Thread(()->{
                HungrySingleTon instance1=HungrySingleTon.getInstance();
                System.out.println(instance1);
            }).start();
    
            new Thread(()->{
                HungrySingleTon instance2=HungrySingleTon.getInstance();
                System.out.println(instance2);
            }).start();
    
    
        }
    }
    
    class HungrySingleTon{
        /**
         * 饿汉模式
         * 静态成员什么时候被加载？
         * 当我们调用这个HungrySingleTon类的时候，jvm会判断这个类是否在内存中，
         */
       private static  HungrySingleTon instance=new HungrySingleTon();
       private HungrySingleTon(){
       }
       public static HungrySingleTon getInstance(){
           return instance;
       }
    }
    
    class InnerSingleTon implements Serializable {
        static final long serialVersionUID = 42L;
        /**
         * 静态内部类的形式的单例模式
         * 利用类的加载机制来确定线程的安全
         */
        private static class InnerSingleTonHolder {
            private static InnerSingleTon instance=new InnerSingleTon();
        }
        private InnerSingleTon(){
    
        }
        public static InnerSingleTon getInstance(){
            return  InnerSingleTonHolder.instance;//执行这条语句时导致，静态内部类创建，instance才被实例化
        }
    
    }
    
    /**
     * 懒汉模式的类
     */
    class LazySingleTon{
        private static volatile LazySingleTon instance;
        private LazySingleTon(){
        }
        //synchronized用来加锁，防止多线程创建对个实例，但是会对性能造成一些损耗
        
        public static synchronized LazySingleTon getInstance1(){//第一种实例化方法
            if(instance==null){
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                instance=new LazySingleTon();
            }
            return instance;
        }
        
        //上面的方法实例化在多线程下不安全，进行加锁
        public static  LazySingleTon getInstance(){//第二种实例化方法
            if(instance==null){
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(LazySingleTon.class){
                    if (instance==null){
                        instance=new LazySingleTon();
                        /**从字节码层面分析对象创建的过程(jit编译器，cpu对指令重排序问题）
                         * 1，分配空间,2，初始化,3，引用赋值。
                         * 初始化和引用赋值的顺序可能会调换，如果执行顺序调换在多线程下，第一个线程执行了引用赋值
                         * 第二个线程到达if(instance==null)发现实例存在直接返回对象，但对象还没有完成初始化，就可能造成空指针异常
                         * 解决：在要实例化的对象上加  volatile
                         */
    
                    }
                }
    
            }
            return instance;
        }
    }

### 8，写出一种11位手机号的正则表达式 ###

var myreg=/^[1][3,4,5,7,8][0-9]{9}$/;

1.  以1为开头；
2.  第二位可为3,4,5,7,8,中的任意一位；
3.  最后以0-9的9个整数结尾。

### 9，说出Servlet生命周期5个阶段 ###

1.  实例化：Servlet容器创建Servlet类的实例。
2.  初始化：该容器调用init()方法，通常会申请资源。
3.  服务：由容器调用service()方法，（也就是doGet()和doPost()）。
4.  破坏：在释放Servlet实例之前调用destroy()方法，通常会释放资源。
5.  不可用：释放内存的实例。

### 10，检查字符串回文，实现英文中单词个数和单词次数统计。 ###

1.  使用文件输出流读入字符串，去除标点符号，换行符号
2.  将字符串用“ ”分割成字符串数组
3.  对上一点中的字符串数组中每一个元素去掉首尾空格，如果得到的是空字符串则抛弃
4.  创建一个Map，存放字符串和出现次数，对字符串数组中每一个处理过后的字符串，首先判断Map中是否有，没有则加入Map，有则使对应的次数+1.

package model;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class Test1 {
        public static void main(String[] args) throws Exception {
            String words="";//存储完整的文章
            String[] stringArray=null;//存储单词的数组
            Map<String,Integer> wordMap=new HashMap<String,Integer>();//存储单词和对应出现的个数
    
    
            FileInputStream fileInputStream=new FileInputStream("C:\\Users\\建江\\Desktop\\English.txt");
            byte []bytes=new byte[1024];//为了快速读出数据，建立一个缓冲区
            int len;
            while ((len=fileInputStream.read(bytes))!=-1){
                String word=new String(bytes,0,len);//得到1024字节缓存区中存储的文章
                words=words+word;//得到完整的文章
            }
            fileInputStream.close();//关闭输出流
            words=words.toLowerCase();
            words=words.replaceAll("[\\pP\\p{Punct}]","");//去标点符号
            words= words.replaceAll("\r|\n", " ");//去除换行符号,替换成空格
            stringArray=words.split(" ");//将文章按空格分割，存储到数组里面
            System.out.println(words);
            for (String word:stringArray){//遍历数组，把单词存储到map集合中
                System.out.println(word);
                if (!word.equals("")){
                    if (!wordMap.containsKey(word)){//如果单词不在wordMap中,把单词加入集合中
                        wordMap.put(word,1);
                    }else {//如果单词在wordMap中,把单词数量加一
                        Integer number = wordMap.get(word);
                        number=number+1;
                        wordMap.put(word,number);
                    }
                }
            }
    
            //遍历集合
            System.out.println(wordMap);
            Set<String> keys = wordMap.keySet();//得到所有的key值
            Iterator<String> iterator = keys.iterator();//得到它的迭代器对象
            while (iterator.hasNext()){
                String key=iterator.next();//iterator.next()迭代器获取元素，只能使用一次
                Integer value=wordMap.get(key);
                System.out.println(key+"---->"+value);
            }
    
    
        }
    }

### 11，http协议有几种请求方式，他们之间的区别是什么？ ###

HTTP1.0定义了三种请求方法： get, pot 和 head方法。  
HTTP1.1新增了五种请求方法：put, delete,connect,options 和 trace 方法

### 12，一个http请求从开始到结束都经历了哪些过程，简写流程图 ###

详细过程：[https://blog.csdn.net/ailunlee/article/details/90600174][https_blog.csdn.net_ailunlee_article_details_90600174]

1.  浏览器根据域名解析ip地址（寻找ip：浏览器缓存——》操作系统缓存——》路由器缓存——》互联网服务提供商的DNS缓存）
2.  浏览器与服务器建立tcp连接（http协议是应用层协议，tcp协议是传输层协议）
3.  浏览器给WEB服务器发送一个HTTP请求（请求行，请求头部，空行和请求体4个部分组成）
4.  服务器端响应HTTP请求，浏览器得到HTML代码
5.   浏览器解析HTML代码，并继续请求HTML代码中的其它资源（图片，音频，视频等）
6.   关闭TCP连接，浏览器对页面进行渲染呈现给用户

### 13，Ajax请求是否可以实现同步 ###

*  可以： 设置  async: false
 *      $.ajax({
                                    url: "/api/goods-number-is-exist?number=" + number + "&goods_id=" + goods_id,
                                    type: 'get',
                                    contentType: 'application/json',
                                    dataType: 'text',
                                    async: false, // 同步
                                    success: function (result) {
                                        var resObj = JSON.parse(result);
                                        // console.log("ddd");
                                        switch (resObj.code) {
                                            case "-1":
                                                alert(resObj.message);
                                                break;
                                            case "1":
                                                number_exist = true;
                                                break;
                                            default:
                                                break;
                                        }
                                    },
                                    error: function (result) {
                                    }
                                });

### 15，Mybatis工作流程 ###

1.  读取配置文件，获取连数据库的相关信息
2.  有了这些信息就能创建SqlSessionFactory（SqlSessionFactory程序运行的时候建立起来,程序结束的时候消亡）
3.  SqlSessionFactory创建SqlSession对象,用来执行对应的dao层方法（一个方法中建立,方法结束应该关闭)
4.  调用MyBatis的statementHandler提供的Api执行Sql语句
5.  SQL语句放在Map配置文件里面
6.  执行SQl语句,不同的SQl语句返回不同的结果

### 16，Java创建对象的几种方式： ###

1.  用new语句创建对象，这是最常见的创建对象的方法。 （调用构造函数）
2.  运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。 （调用构造函数）
3.  调用对象的clone()方法。 
4.  运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。

### 17，mysql中的数据引擎有：MyISAM和InnoBD，他们之间的区别是什么？ ###

1.  构成区别：MyISAM有三个文件用来：存储表的定义，存储数据，存储索引。InnoBD有两个文件：存储表的空间数据，存储日志
2.  事物区别：MyISAM不支持事物，执行速度快。InnoBD支持事物，外键等功能
3.  CRUD操作区别：MyISAM适合查询操作，InnoBD适合更新操作。
4.  查询count区别：MyISAM数据库存储行数，只需要把行数值返回。InnoBD需要计算行数返回
5.  锁：MyISAM提供表锁，InnoBD提供行锁，不加锁读取，表锁

[https_blog.csdn.net_weixin_44841312_article_details_104966035]: https://blog.csdn.net/weixin_44841312/article/details/104966035
[https_blog.csdn.net_weixin_44841312_article_details_105191973]: https://blog.csdn.net/weixin_44841312/article/details/105191973
[https_blog.csdn.net_weixin_44841312_article_details_105339475]: https://blog.csdn.net/weixin_44841312/article/details/105339475
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70]: /images/20221023/e3993e73ba594bff9e6bbb3b250315b2.png
[https_www.cnblogs.com_jesonjason_p_5492208.html]: https://www.cnblogs.com/jesonjason/p/5492208.html
[https_blog.csdn.net_u010741032_article_details_81806762]: https://blog.csdn.net/u010741032/article/details/81806762
[https_blog.csdn.net_m0_37719047_article_details_89359996]: https://blog.csdn.net/m0_37719047/article/details/89359996
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 1]: /images/20221023/2d84fde1c4004fb88e93d326de819da0.png
[https_blog.csdn.net_star20100906_article_details_94405805]: https://blog.csdn.net/star20100906/article/details/94405805
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 2]: /images/20221023/625aea9259d949b9978fbbf25a033805.png
[https_www.cnblogs.com_zhengbin_p_5654805.html]: https://www.cnblogs.com/zhengbin/p/5654805.html
[8cea7c512766d081fd2719010a073d62.png]: /images/20221023/554c371109b14331a11af25566d544f5.png
[https_blog.csdn.net_ljt2724960661_article_details_52507314]: https://blog.csdn.net/ljt2724960661/article/details/52507314
[https_blog.csdn.net_anxpp_article_details_51325838]: https://blog.csdn.net/anxpp/article/details/51325838
[https_blog.csdn.net_ailunlee_article_details_90600174]: https://blog.csdn.net/ailunlee/article/details/90600174