Java 100道面试题及答案详解

刺骨的言语ヽ痛彻心扉 2022-05-24 02:30 337阅读 0赞

1：Arraylist和Linkedlist的区别？
    2：重载与重写有什么区别？
    3：&和&&有什么区别？
    4：接口和抽象类有什么区别？
    5：写出JDBC操作数据库的步骤？
    6：HashTable和HashMap有什么区别？
    7：创建多线程的方式有几种？分别是什么？线程死锁是如何产生的？如何防止线程死锁现象？
    8：String， StringBuffer， StringBuilder 的区别？
    9：TCP和UDP的区别？哪个是三次握手协议？
    10：JSP的常用指令有哪些？
    11：DI有几种方式、分别是什么，你常用的是哪种方式？
    12：Mybatis中$和#在xml中取值有什么不同？
    13：Session和Cookie有什么区别？
    14：GET和POST请求的区别？
    15：转发（forward）和重定向（redirect）的区别？
    16：Hibernate与Mybatis区别？
    17：列举struts2常见的组件有哪些？常见的配置标签有哪些？返回值类型有哪些？
    18：用最有效率的方法算出2乘以8等于多少？
    19：Spring常见的注解有哪些？
    20：Debug模式下，快捷键有哪些，分别代表什么？
    21：Tomcat如何修改端口号，如何清除项目缓存，默认并发量是多少？
    22：final, finally, finalize的区别？
    23：一个汉字几个字节，一个char类型的变量，可以储存一个汉字吗，为什么可以或者不可以？
    24：谈谈Spring AOP的原理？
    25：简要说明SSH框架搭建步骤？
    26：简要说明SSM框架搭建步骤？
    27：多线程中run和start方法有什么区别？
    28：静态变量和实例变量有什么区别？
    29：前后台数据交互的方式有哪些？
    30：字节流和字符流有什么区别？
    31：Redis支持哪些数据类型的存储？
    32：Java如何调用Redis进行数据操作，并列举增删改查操作？
    33：Nosql主要支持哪两种数据存储系统？
    34：MongoDB的体系逻辑结构，主要有什么组成？
    35：Redis和MongoDB分别应用于哪些应用场景？
    36：Java如何链接MongoDB，写出逻辑代码？
    37：如何给一张表增加一个字段，写出sql语句？
    38：==与equals有什么区别？
    39：++i与i++的区别？
    40：List和Map有什么区别？
    41：Integer与int的区别？
    42：分别写出oracle、mysql的分页关键词？
    43：谈谈你对MVC的理解？
    44：如果equals方法比较为true，那么它们的Hashcode值一定相同吗？ 如
    果hashcode相同，那么equals方法比较一定为true吗？
    45：简述servlet 生命周期？
    46：进程和线程的区别是什么？
    47：进程的几种状态分别是什么？
    48：JDK和JRE的关系区别是什么？
    49：SpringMVC运行原理是什么？
    50：用户在浏览器中输入URL之后，发什么了什么？写出请求和响应的流程
    51：响应结果状态码有哪些，并给出中文含义？
    52：什么是ORM？
    53：什么是IOC？
    54：jsp的作用域有哪些？
    55：sleep 和 wait 有什么区别？
    56：Java 中的final关键字有哪些用法？
    57：Error和Exception有什么区别？什么时候需要捕获异常，什么时候需要抛出异常？
    58：写出冒泡排序的程序代码？
    59：数据库集群模式下，如何保证主从数据库的数据一致性？以mysql数据库为例进行说明配置步骤？
    60：简述JAVA中I/O和NIO的区别？
    61：简述单例模式的特征和应用场景？
    62：写出将1000个存在重复手机号的号码池去重的JAVA代码？
    63：Java接口的修饰符有哪些？
    64：Java支持的数据类型有哪些？什么是自动拆装
    65：Math.round(11.5)等于多少? Math.round(-11.5)等于多少?
    66：写一单实例类要求精简、清晰？（单例模式）
    67：构造器（constructor）是否可被重写（override）?是否可被重载？是否可被继承？
    68：JSP和Servlet有哪些相同点和不同点，他们之间的联系是什么？
    69：简述synchronized和java.util.concurrent.locks.Lock的异同 ？
    70：解析xml和excel分别使用什么技术？
    71：如何发布spring boot项目，简述步骤？
    72：什么是java序列化，如何实现java序列化？
    73：在JAVA中，如何跳出当前的多重嵌套循环？
    74：面向对象的特征有哪些方面？
    75：Collection 和 Collections的区别？
    76：同步和异步有何异同，在什么情况下分别使用他们？举例说明。
    77：abstract class和interface有什么区别?
    78：GC是什么? 为什么要有GC?
    79：请说出你所知道的线程同步的方法？
    80：JSP的内置对象及方法？
    81：如何现实servlet的单线程模式？
    82：页面间对象传递的方法？
    83：Request对象的主要方法？
    84：J2ee常用的设计模式？说明工厂模式?
    85：List、Map、Set三个接口，存取元素时，各有什么特点？
    86：如何对数据库做优化？
    87：如何对JVM进行性能调优？
    88：如何实现集群模式下，session共享？
    89：程序员如果想换行，应该怎么处理？
    90：公司如果想换一个灯泡,请问需要几个java工程师？
    91：Hibernate一级缓存和二级缓存的区别？
    92：Hibernate有几种查询方式？
    93：你对加班怎么看？能接受出差吗？
    94：谈谈个人3-5年的职业规划？
    95：在项目开发中，曾经遇到什么困难、难解的问题？
    96：为什么从上家公司离职？
    97：你喜欢在什么样的团队进行工作？
    98：做一个简单的自我介绍？
    99：工作中，如果你和项目组长或者领导的意见不一样，应该怎么处理？
    100：遇到需求变更如何处理？

![640_wx_fmt_jpeg_tp_webp_wxfrom_5_wx_lazy_1][]

详情解答

### 1：Arraylist和Linkedlist的区别？ ###

ArrayList、LinkedList、Vector和Stack是List的四个实现类，其中Vector是基于JDK1.0，虽然实现了同步，但是效率低，已经不用了，Stack继承Vector
    区别：
       1. ArrayList是实现了基于动态数组的数据结构，而LinkedList是基于链表的数据结构
       2. 对于随机访问get和set，ArrayList要优于LinkedList，LinkedList不支持高效的随机访问
       3. ArrayList适合查找，LinkedList适合增删

### 2：重载与重写有什么区别？ ###

override（重写）
    　　 1.方法名、参数、返回值相同。
    　　 2.子类方法不能缩小父类方法的访问权限。
    　　 3.子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
    　　 4.存在于父类和子类之间。
    　　 5.方法被定义为final不能被重写。
    　overload（重载）
    　 　1.参数类型、个数、顺序至少有一个不相同。 
    　 　2.不能重载只有返回值不同的方法名。
    　　 3.存在于父类和子类、同类中。

### 3：&和&&有什么区别？ ###

&按位与:
        1.a&b是把a和b都转换成二进制数然后再进行与的运算
        2.不管前面的条件是否正确，后面都执行
    &&逻辑与（短路功能）:
        1.a&&b就是当且仅当两个操作数均为 true时，其结果才为 true；
        2.前面条件正确时，才执行后面，不正确时，就不执行，效率高

### 4：接口和抽象类有什么区别？ ###

抽象类（abstract class）：
        1：abstract 关键字修饰，并且没有方法体
        2：抽象类不能直接创建实例
        3：抽象类只能被继承，一个具体类继承一个抽象类，必须实现所有抽象方法
    接口（interface）：
        1：实现接口的一定要实现接口里定义的所有方法
        2：接口可以实现多重继承
    区别：
        1：抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用
        2：一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类
        3：接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法
        4：抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的
        5：抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法

### 5：写出JDBC操作数据库的步骤？ ###

1：加载驱动
        Class.forName("oracle.jdbc.driver.OracleDriver");
    2：创建连接
        Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "1111", "1111");
    3：创建语句
        PreparedStatement ps = con.prepareStatement("select * from user");
    4：执行语句
        ResultSet rs = ps.executeQuery();
    5：处理结果
        while(rs.next()) {
       
            rs.get.....（“”）；
        }
    6：关闭资源
        finally {
       
            if(con != null) {
       
                try {
       
                    con.close();
                } catch (SQLException e) {
       
                    e.printStackTrace();
                }
            }
        }

### 6：HashTable和HashMap有什么区别？ ###

1.HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口
    2.主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高Hashtable
    3.HashMap允许将null作为一个entry的key或者value，而Hashtable不允许
    4.最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是

### 7：创建多线程的方式有几种？分别是什么？线程死锁是如何产生的？如何防止线程死锁现象？ ###

方式：
        继承Thread、实现 Runnable 接口
    产生:
        - 一个资源每次只能被一个进程使用
        - 一个进程因请求发生阻塞时，依然对已获得的资源保持不放
        - 进程已经获得资源使用权，但是一直未使用
        - 同一个进程，频繁的获取资源的优先使用权，一直未释放
    防止：
        加锁顺序（线程按照一定的顺序加锁）
        加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）
        死锁检测（一般是将所有的锁存放于map对象中，检测map中的锁）

### 8：String， StringBuffer， StringBuilder 的区别？ ###

1.运行速度快慢为：StringBuilder > StringBuffer > String
        - （String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的）
    2.StringBuilder是线程不安全的，而String、StringBuffer是线程安全的

### 9：TCP和UDP的区别？哪个是三次握手协议？ ###

TCP稳定性较高，但效率低
    UDP通讯相反，效率较高，但稳定性较差

### 10：JSP的常用指令有哪些？ ###

三个编译指令为：page、include、taglib
    七个动作指令为：jsp:forward、jsp:param、jsp:include、jsp:plugin、jsp:useBean、jsp:setProperty、jsp:getProperty

### 11：DI有几种方式、分别是什么？ ###

1：Setter方法
    2：构造器
    3：接口注入
    
    注解实现注入(常用)

### 12：Mybatis中$和\#在xml中取值有什么不同？ ###

1.mybatis 为我们提供了两种支持动态 sql 的语法：#{} 以及 ${}
    2.#方式能够很大程度防止sql注入，$方式无法防止Sql注入
    3.$方式一般用于传入数据库对象，例如传入表名
    4.＃{}将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号
    5.一般能用#的就别用$

### 13：Session和Cookie有什么区别？ ###

Cookie存在客户端、session数据放在服务器上
    cookie不是很安全，别人可以分析存放在本地的COOKIE并进行修改
    session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能 
    单个cookie在客户端的限制是3K，就是说一个站点在客户端存放的COOKIE不能大于3K

### 14：GET和POST请求的区别？ ###

GET：
        1：从服务器上获取数据，一般不能使用在写操作接口
        2：由URL所限制，GET方式传输的数据大小有所限制，传送的数据量不超过2KB
        3：请求的数据会附加在URL之后，以？分隔URL和传输数据，多个参数用&连接
        4：安全性差
    POST:
        1：向服务器提交数据,一般处理写业务
        2：POST方式传送的数据量比较大，一般被默认为没有限制
        3：安全性高
        4：请的求的数据内容放置在HTML HEADER中

### 15：转发（forward）和重定向（redirect）的区别？ ###

1：效率上
        转发（forward） > 重定向（redirect）
    2：显示上
        重定向（redirect）：显示新的URL
        转发（forward）：地址栏不变
    3：数据上
        转发（forward）：可以共享request里面的数据
        重定向（redirect）：不能
    4：请求次数
        重定向（redirect）是两次
        转发（forward）是一次

### 16：Hibernate与Mybatis区别？ ###

1：hibernate的扩展性和移植性比mybatis强
    2：hibernate不需要写sql语句，会自动生成，而mybatis则需要写sql语句
    3：hibernate支持事务、一级缓存、二级缓存、查询缓存等
    4：hibernate自己提供分页功能，mybatis需要配置分页插件

### 17：列举struts2常见的组件有哪些？常见的配置标签有哪些？返回值类型有哪些？ ###

组件：
        strutsParperAndExecuteFilter
        Action
        Result
        Interceptor
    标签：
        package
        action
        result
        param
        interceptor
    返回值类型：
        dispatcher
        redirect
        redirectAction
        stream
        json

### 18：用最有效率的方法算出2乘以8等于多少？ ###

2 << 3

### 19：Spring常见的注解有哪些？ ###

@Autowired--自动装配
    @Component--自动支持自动装配
    @Repository--DAO层实现
    @Service--Service层实现
    @Controller--Web层实现

### 20：Debug模式下，快捷键有哪些，分别代表什么？ ###

F5：进入方法内
    F6：执行下一步
    F7：跳出方法外
    F8：执行到下一个断点

### 21：Tomcat如何修改端口号，如何清除项目缓存，默认并发量是多少？ ###

端口：server.xml
    项目缓存：删除work文件夹下的文件
    并发：150-200

### 22：final, finally, finalize的区别？ ###

final—修饰符（关键字）
        如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。
        一个类不能既被声明为 abstract的，又被声明为final的
        被声明为final的方法也同样只能使用，不能重载
    finally—异常处理时提供 finally 块来执行操作
        finally块则是无论异常是否发生，都会执行finally块的内容
    finalize—方法名
        finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的
        它是在object类中定义的，所有的类都继承了它

### 23：一个汉字几个字节，一个char类型的变量，能储存一个汉字吗？ ###

两个字节，可以存储，前提是汉字必须是Unicode编码

### 24：谈谈Spring AOP的原理？ ###

AOP称为面向切面编程
    用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等
    实现AOP功能关键是采用代理技术，主要分为静态代理(AspectJ)和动态代理
    JDK中采用Proxy类产生动态代理的方式为某个接口生成实现类，如果要为某个类生成子类，则可以用CGLIB

### 25：简要说明SSH框架搭建步骤？ ###

1：Struts2
        - 导包
        - 加载struts.xml
        - 配置web.xml
            - filter
    2：Struts2+Spring
        - 导中间包、Spring包
        - 增加Spring的配置文件Applicationcontext.xml
        - 配置web.xml
            - context和监听
    3：Hibernate
        - 导包
        - 增加hibernate的配置文件hibernate.hbm.cfg和表的映射文件
            - 配置数据库的方言和连接、加载映射文件
    4：Hibernate+Spring
        - 导中间包
        - 在spring的配置文件中加载hibernate的配置信息

### 26：简要说明SSM框架搭建步骤？ ###

1：Spring
        - 导包
        - 增加Spring的配置文件Applicationcontext.xml
        - 配置web.xml
    2：springMVC
        - 导包
        - 增加springMVC的配置文件context-dispatcher.xml
        - 配置web.xml
    3：mybatis
        - 导包
        - 增加mybatis的配置文件mybatis-config.xml
        - 将mybatis的配置文件在spring和springMVC中进行引用和配置

### 27：多线程中run和start方法有什么区别？ ###

Thread的start才是正在开启线程
    Run只是调用了一个普通方法，并没有启动另一个线程，程序还是会按照顺序执行相应的代码
    Start则表示，重新开启一个线程，不必等待其他线程运行完，只要得到cup就可以运行该线程

### 28：静态变量和实例变量有什么区别？ ###

静态变量前面要加static，实例变量不用
    实例变量属于对象的属性，必须创建了实例对象，才可以被使用
    静态变量不属于某个实例对象，而是属于类，也叫类变量，不用创建任何实例对象就会被使用

### 29：前后台数据交互的方式有哪些？ ###

json、file、xml、jsonp等

### 30：字节流和字符流有什么区别？ ###

字节流：按字节读写
    字符流：按字符
    
    通常在处理文本时优先使用字符流，其他的用字节流
    字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件

### 31：Redis支持哪些数据类型的存储？ ###

string、list、set、zset、hash

### 32：Java如何调用Redis进行数据操作，并列举增删改查操作？ ###

1. 导包
    2. Jedis jd = new Jedis(IP);
    3. jd.ping();//PONG

### 33：Nosql主要支持哪两种数据存储系统？ ###

key-value---Redis
    文档存储-----MongoDB

### 34：MongoDB的体系逻辑结构，主要有什么组成？ ###

文档(document)、集合(collection)、数据库(database)

### 35：Redis和MongoDB分别应用于哪些应用场景？ ###

Redis：数据量较小的更性能操作和运算上
    MongoDB:主要解决海量数据的访问效率问题
    - 参考资料：
    https://mp.weixin.qq.com/s?__biz=MzIxMjg4NDU1NA==&mid=2247484268&idx=1&sn=5431c00c451ebeca8aa99ae59f05a3a2&chksm=97be0e49a0c9875fa918412aa0d2544c8dbb02b8875382b08217b1e7818e7ae913d72ae4107c&scene=21#wechat_redirect

### 36：Java如何链接MongoDB，写出逻辑代码？ ###

导包
    //建立连接
    MongoClient mc =  new MongoClient("192.168.168.220", 27017);
    MongoDatabase db = mc.getDatabase("db1");//数据库名称

### 37：如何给一张表增加一个字段，写出sql语句？ ###

alter table 表名 add 字段 类型 NOT NULL Default 0;

### 38：==与equals有什么区别？ ###

==：比较两个数据内存地址是否相同
    equals：比较两个数据值是否一样

### 39：++i与i++的区别？ ###

++i:先赋值，后运算
    i++：先运算，后赋值

### 40：List和Map有什么区别？ ###

list：
        - 链表
        - 有序
        - 继承Collection(set也是)
        - 可以有重复的对象值，但是对象下标不能重复
    Map：
        - key-value
        - 无序
        - 键不能有重复的 值可以用

### 41：Integer与int的区别？ ###

int 是基本数据类型，初值为0
    Integer是int的包装类，初值为null
    Integer缓存：注意拆箱和装箱（-128-127之间）
    原始类型：boolean，char，byte，short，int，long，float，double
    包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

### 42：分别写出oracle、mysql的分页关键词？ ###

oracle：rownum关键词、row_number()函数
    mysql：limit 0,5    /    limit 5;

### 43：谈谈你对MVC的理解？ ###

MVC：是一个框架设计模式，其中M（模型）、V（视图）、C（控制器）
    视图：视图向用户显示相关的数据，并接受用户的输入。视图不进行任何业务逻辑处理。如：jsp、html等
    模型：表示业务数据和业务处理。属于数据模型，如:entity、jdbc、hibernate、mybatis等
    控制器：接收、响应用户请求，servlet、action、controller等

### 44：如果equals方法比较为true，那么它们的Hashcode值一定相同吗？如果hashcode相同，那么equals方法比较一定为true吗？ ###

不一定相同
    一定

### 45：简述servlet 生命周期？ ###

通过调用 init () 方法进行初始化
    调用 service() 方法来处理客户端的请求
    通过调用 destroy() 方法终止（结束）
    Servlet 是由 JVM 的垃圾回收器进行垃圾回收的

### 46：进程和线程的区别是什么？ ###

- 进程是资源的分配和调度的一个独立单元，而线程是CPU调度的基本单元
    - 同一个进程中可以包括多个线程
    - 进程结束后它拥有的所有线程都将销毁，而线程的结束不会影响同个进程中的其他线程的结束
    - 线程共享整个进程的资源（寄存器、堆栈、上下文），一个进行至少包括一个线程
    - 进程的创建调用fork或者vfork，而线程的创建调用pthread_create
    - 线程中执行时一般都要进行同步和互斥，因为他们共享同一进程的所有资源

### 47：进程的几种状态分别是什么？ ###

就绪状态：
    
        当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态
    
    运行状态：
    
        当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为运行状态
    
    阻塞状态：
    
        正在运行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种，例如，等待I/O完成、申请缓冲区不能满足、等待信件(信号)等
    
    
    状态转换：
    
        就绪→运行：处于就绪状态的进程，当进程调度程序为之分配了处理机后，该进程便由就绪状态转变成运行状态
    
        运行→就绪：处于运行状态的进程在其运行过程中，因分配给它的一个时间片已用完而不得不让出处理机，于是进程从运行状态转变成就绪状态
    
        运行→阻塞：正在运行的进程因等待某种事件发生而无法继续运行时，便从运行状态变成阻塞状态
    
        阻塞→就绪：处于阻塞状态的进程，若其等待的事件已经发生，于是进程由阻塞状态转变为就绪状态

### 48：JDK和JRE的关系区别是什么？ ###

JDK是Java的开发工具，JDK包含JRE
    JRE只是Java程序的运行环境，它最核心的内容就是JVM（Java虚拟机）及核心类库

### 49：SpringMVC运行原理是什么？ ###

1.客户端请求提交到DispatcherServlet 
    2.由DispatcherServlet控制器查询一个或多个HandlerMapping，找到处理请求的Controller 
    3.DispatcherServlet将请求提交到Controller 
    4.Controller调用业务逻辑处理后，返回ModelAndView 
    5.DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图 
    6.视图负责将结果显示到客户端 
    DispatcherServlet是整个Spring MVC的核心。它负责接收HTTP请求组织协调Spring MVC的各个组成部分

### 50：用户在浏览器中输入URL之后，发什么了什么？写出请求和响应的流程 ###

1：域名解析
    2：TCP三次握手
    3：浏览器向服务器发送http请求
    4：浏览器发送请求头信息
    5：服务器处理请求
    6：服务器做出应答
    7：服务器发送应答头信息
    8：服务器发送数据
    9：TCP连接关闭

### 51：响应结果状态码有哪些，并给出中文含义？ ###

1**：信息性状态码
    2**：成功状态码
        200：请求正常成功
        204：指示请求成功但没有返回新信息
        206：指示服务器已完成对资源的部分 GET 请求
    3**：重定向状态码
        301：永久性重定向
        302：临时性重定向
        304：服务器端允许请求访问资源，但未满足条件
    4**：客户端错误状态码
        400：请求报文中存在语法错误
        401：发送的请求需要有通过HTTP认证的认证信息
        403：对请求资源的访问被服务器拒绝了
        404：服务器上无法找到请求的资源
    5**：服务器错误状态码
        500：服务器端在执行请求时发生了错误
        503：服务器暂时处于超负载或正在进行停机维护，现在无法处理请求

### 52：什么是ORM？ ###

对象关系映射（Object Relational Mapping，简称ORM）
    为了解决面向对象与关系数据库存在的互不匹配的现象的技术
    ORM是通过使用描述对象和数据库之间映射的元数据(元数据一般采用XML格式)，将程序中的对象自动持久化到关系数据库中
    Java典型的ORM中间件有:Hibernate,ibatis,speedframework,mybatis

### 53：什么是IOC？ ###

(Inversion of Control,简称IOC)，即控制反转，是一种设计模式，是spring的核心
    可以解决代码耦合，由IOC容器来管理对象的生命周期、依赖关系等。
    举个栗子：
        我们是如何找女朋友的？
        常见的情况是，我们到处去看哪里有长得漂亮的mm，然后打听她们的兴趣爱好、微信号、手机号、ip号、………，想办法认识她们，投其所好送其所要，然后....,这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁，耦合度比较高。
        IOC：相当于第三方“婚姻介绍所”，手里有许多mm的资料，只需要你告诉介绍所，你需要什么样的女朋友，然后介绍所会自动匹配适合你的mm，然后给你，你只需要去和她谈恋爱、结婚就行了。简单明了，如果不符合你的要求，你可以抛出异常啊......虽有的对象都有你自己决定，spring也是如此，所有的对象都被spring控制。
    当前比较知名的IOC容器有：Spring、JBoss、EJB等。

### 54：jsp的作用域有哪些？ ###

page：当前页面有效
    request：一次会话请求有效
    session：浏览器进程，只要浏览器不关闭，则一直有效
    application：服务器只要运行，则有效

### 55：sleep 和 wait 有什么区别？ ###

sleep：
        1：属于Thread类，表示让一个线程进入睡眠状态，等待一定的时间之后，自动醒来进入到可运行状态，不会马上进入运行状态
        2：sleep方法没有释放锁
        3：sleep必须捕获异常
    wait：
        1：属于Object，一旦一个对象调用了wait方法，必须要采用notify()和notifyAll()方法唤醒该进程
        2：wait方法释放了锁
        3：wait不需要捕获异常

### 56：Java 中的final关键字有哪些用法？ ###

1：修饰类：表示该类不能被继承
    2：修饰方法：表示方法不能被重写
    3：修饰变量：表示变量只能一次赋值以后值不能被修改（常量）

### 57：Error和Exception有什么区别？什么时候需要捕获异常，什么时候需要抛出异常？ ###

1:Error表示系统级的错误和程序不必处理的异常,有可能恢复，但是恢复比较困难的严重问题。
    2：Exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况
    异常处理的原则：
        1：System.out.println是高代价的。调用System.out.println会降低系统吞吐量
        2：在生产环境中别用异常的printStackTrace()方法。
        3：如果你不能处理异常，不要捕获该异常
        4：如果要捕获，应在离异常源近的地方捕获它
        5：捕获的异常一定要做处理
        6：可以自定义异常
        7：就近原则

### 58：写出冒泡排序的程序代码？ ###

高逼格的代码：
    接口：
    import java.util.Comparator;
    /**
     * 排序器接口(策略模式: 将算法封装到具有共同接口的独立的类中使得它们可以相互替换)
     */
    public interface Sorter {
       
       /**
        * 排序
        * @param list 待排序的数组
        */
       public <T extends Comparable<T>> void sort(T[] list);
       /**
        * 排序
        * @param list 待排序的数组
        * @param comp 比较两个对象的比较器
        */
       public <T> void sort(T[] list, Comparator<T> comp);
    }
    实现类：
    import java.util.Comparator;
    /**
     * 冒泡排序
     *
     */
    public class BubbleSorter implements Sorter {
        
        @Override
        public <T extends Comparable<T>> void sort(T[] list) {
       
            boolean swapped = true;
            for (int i = 1, len = list.length; i < len && swapped; ++i) {
       
                swapped = false;
                for (int j = 0; j < len - i; ++j) {
       
                    if (list[j].compareTo(list[j + 1]) > 0) {
       
                        T temp = list[j];
                        list[j] = list[j + 1];
                        list[j + 1] = temp;
                        swapped = true;
                    }
                }
            }
        }
        @Override
        public <T> void sort(T[] list, Comparator<T> comp) {
       
            boolean swapped = true;
            for (int i = 1, len = list.length; i < len && swapped; ++i) {
       
                swapped = false;
                for (int j = 0; j < len - i; ++j) {
       
                    if (comp.compare(list[j], list[j + 1]) > 0) {
       
                        T temp = list[j];
                        list[j] = list[j + 1];
                        list[j + 1] = temp;
                        swapped = true;
                    }
                }
            }
        }
    }

### 59：数据库集群模式下，如何保证主从数据库的数据一致性？以mysql数据库为例进行说明配置步骤？ ###

1：开启所有服务器的二进制文件
    2：开启所有从服务的IO和SQL线程
    3：配置主从连接的用户信息和主从信息
    4：开启3306端口号

### 60：简述JAVA中I/O和NIO的区别？ ###

NIO:是一种new IO，其目的是为了实现高速IO的代码，将IO操作并转换为操作系统，属于非阻塞型，java.nio.*，是以块（缓冲区）的形式就行数据的传输
    IO：是以流的方式就行数据的传输，属于阻塞型，影响程序的性能
    传统阻塞IO，如果你要read/write( byte[10M])一个10M的文件，一旦调用了read/write( byte[10M])这个方法，就得等10M全部read/write，方法底层才会返回。
    非阻塞线程，调用read/write( byte[10M])方法立即返回，当然这并不能代表10M已经read/write完成，你需要检测这个byte[10M]的缓冲区
    java BIO：同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善；
    java NIO：同步非阻塞，服务器实现模式为一个请求一个线程，NIO多线程对某资源进行IO操作时会先把资源先操作至内存缓冲区。然后询问是否IO操作就绪，是则进行IO操作，否则进行下一步操作，然后不断的轮询是否IO操作就绪，直到iIO操作就绪后进行相关操作
    java AIO：异步非阻塞，异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。
    BIO和NIO的异同：
        共同点：两者都是同步操作。即必须先进行IO操作后才能进行下一步操作。
        不同点：BIO多线程对某资源进行IO操作时会出现阻塞，即一个线程进行IO操作完才会通知另外的IO操作线程，必须等待。

### 61：简述单例模式的特征和应用场景？ ###

单例模式（Singleton），也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。
    单例模式只允许创建一个对象，因此节省内存，加快对象访问速度
    单例模式要素： 
        a.私有构造方法 
        b.私有静态引用指向自己实例 
        c.以自己实例为返回值的公有静态方法 
    饿汉式：单例实例在类装载时就构建，急切初始化。（预先加载法） 
        优点 
            1.线程安全 
            2.在类加载的同时已经创建好一个静态对象，调用时反应速度快 
        缺点 
             资源效率不高，可能getInstance()永远不会执行到，但执行该类的其他静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化 
    懒汉式：单例实例在第一次被使用时构建，延迟初始化。 
    应用场景：
        - 需要频繁实例化然后销毁的对象
        - 创建对象时耗时过多或者耗资源过多，但又经常用到的对象
        - 有状态的工具类对象
        - 频繁访问数据库或文件的对象
        - 网站计数器，一般是采用单例模式实现
        - 由于配置文件一般都是共享资源，即web应用的配置对象的读取，一般采用单例模式来实现。如：spring的配置文件的读取等
        - 多线程的线程池的设计一般也是采用单例模式
        - 数据库连接池的设计

### 62：写出将1000个存在重复手机号的号码池去重的JAVA代码？ ###

public class DemoPhone1 {
        
        public static void main(String[] args) {
       
            phoneDis();
            phoneDis2();
            phoneDis3();
            phoneDis4();
            phoneDis5();
            phoneDis6();
        }
        public static void phoneDis(){
       
            String[] array = {
       "18310141089","18310141089","18310141080","18310141083","18310141089","18310141489"};  
            List<String> result = new ArrayList<String>();  
            boolean flag;  
            for(int i=0;i<array.length;i++){  
                flag = false;  
                for(int j=0;j<result.size();j++){  
                    if(array[i].equals(result.get(j))){  
                        flag = true;  
                        break;  
                    }  
                }  
                if(!flag){  
                    result.add(array[i]);  
                }  
            }  
            String[] arrayResult = (String[]) result.toArray(new String[result.size()]);  
            System.out.println("方法1：" + Arrays.toString(arrayResult));  
        }
        public static void phoneDis2(){
       
            String[] array = {
       "18310141089","18310141089","18310141080","18310141083","18310141089","18310141489"};  
            List<String> list = new ArrayList<String>();  
            list.add(array[0]);  
            for(int i=1;i<array.length;i++){  
                if(list.toString().indexOf(array[i]) == -1){  
                   list.add(array[i]);  
                }  
            }  
            String[] arrayResult = (String[]) list.toArray(new String[list.size()]);  
            System.out.println("方法2：" + Arrays.toString(arrayResult));  
        }
        public static void phoneDis3(){
       
            String[] array = {
       "18310141089","18310141089","18310141080","18310141083","18310141089","18310141489"};  
            List<String> list = new ArrayList<String>();  
            for(int i=0;i<array.length;i++){  
                for(int j=i+1;j<array.length;j++){  
                    if(array[i] == array[j]){  
                        j = ++i;  
                    }  
                }  
                list.add(array[i]);  
            }  
            String[] arrayResult = (String[]) list.toArray(new String[list.size()]);  
            System.out.println("方法3：" + Arrays.toString(arrayResult));
        }
        public static void phoneDis4(){
       
            String[] array = {
       "18310141089","18310141089","18310141080","18310141083","18310141089","18310141489"};  
            Arrays.sort(array);  
            List<String> list = new ArrayList<String>();  
            list.add(array[0]);  
            for(int i=1;i<array.length;i++){  
              if(!array[i].equals(list.get(list.size()-1))){  
                 list.add(array[i]);  
              }  
            }  
           String[] arrayResult = (String[]) list.toArray(new String[list.size()]);  
           System.out.println("方法4：" + Arrays.toString(arrayResult));
        }
        public static void phoneDis5(){
       
            String[] array = {
       "18310141089","18310141089","18310141080","18310141083","18310141089","18310141489"};  
            Set<String> set = new HashSet<String>();  
            for(int i=0;i<array.length;i++){  
                set.add(array[i]);  
            }  
            String[] arrayResult = (String[]) set.toArray(new String[set.size()]);  
            System.out.println("方法5：" + Arrays.toString(arrayResult)); 
        }
        public static void phoneDis6() {
       
            String[] array = { "18310141089", "18310141089", "18310141080","18310141083", "18310141089", "18310141489" };
            SortedSet<String> sset = new TreeSet<String>();
            for (int i = 0; i < array.length; i++) {
       
                sset.add(array[i]);
            }
            String[] arrayResult2 = (String[]) sset.toArray(new String[sset.size()]);
            System.out.println("方法6：" + Arrays.toString(arrayResult2));
        }
    }

### 63：Java接口的修饰符有哪些？ ###

public、final、abstract

### 64：Java支持的数据类型有哪些？什么是自动拆装 ###

8种基本数据类型：
        byte      8位         取值范围  -2^7 ~ 2^7 -1
        short     16位        取值范围  -2^15 ~ 2^15 - 1
        char      16位        取值范围  0 ~ 2 ^16 - 1
        boolean   位数不明确   取值范围  true false
        int       32位        取值范围  -2^31 ~ 2^31 - 1
        long      64位        取值范围  -2^63 ~ 2^ 63 - 1
        float     32位        取值范围  1.4e-45 ~ 3.40e38
        double    64位        取值范围  4.9e-324 ~ 1.79e308
    注意：
        需要注意的是，String不是基本数据类型，而是引用类型
    在jdk1.5中引入了自动拆装箱的新特性，自动拆装箱，是指基本数据类型和引用数据类型之间的自动转换
        基本类型转换成包装类型，称为装箱  
        Integer intObjct = new Integer(2); //装箱 
        //Integer intObjct = 2 //自动装箱  
        //自动装箱，如果一个基本类型值出现在需要对象的环境中，会自动装箱  
        如Integer 和 int 可以自动转换； Float和float可以自动转换

### 65：Math.round(11.5)等于多少? Math.round(-11.5)等于多少? ###

round方法，他表示“四舍五入”，算法为Math.floor(x+0.5),即将原来的数字加上0.5后再向下取整
    12、-11

### 66：写一单实例类要求精简、清晰？（单例模式） ###

饿汉式单例：
        public class Singleton {
       
            private Singleton(){}
            private static Singleton instance = new Singleton();
            public static Singleton getInstance(){
       
                return instance;
            }
        }
    懒汉式单例：
        public class Singleton {
       
            private static Singleton instance = null;
            private Singleton() {}
            public static synchronized Singleton getInstance(){
       
                if (instance == null) 
                    instance ＝ new Singleton();
                return instance;
            }
        }
    实现一个单例有两点注意事项：
        - 将构造器私有，不允许外界通过构造器创建对象
        - 通过公开的静态方法向外界返回类的唯一实例

### 67：构造器（constructor）是否可被重写（override）?是否可被重载？是否可被继承？ ###

构造器不能被继承，因此不能重写Override，但可以被重载Overload

### 68：JSP和Servlet有哪些相同点和不同点，他们之间的联系是什么？ ###

- jsp本质就是servlet
    - jsp应用于页面显示，servlet应用于逻辑控制
    - setvlet中没有内置对象，jsp中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象及HttpServlet对象得到

### 69：简述synchronized和java.util.concurrent.locks.Lock的异同 ？ ###

- Lock能完成几乎所有synchronized的功能，并有一些后者不具备的功能，如锁投票、定时锁等候、可中断锁等候等
    - synchronized 是Java内置的关键字，Lock 则是JDK 5中出现的一个包
    - synchronized 同步的代码块可以由JVM自动释放；Lock 需要程序员在finally块中手工释放

### 70：解析xml和excel分别使用什么技术？ ###

xml-dom4j
    excel-poi、jxl

### 71：如何发布spring boot项目，简述步骤？ ###

参考之前的文章《SpringBoot项目发布到自动化容器Docker步骤》点击进入

### 72：什么是java序列化，如何实现java序列化？ ###

概念：
        序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化（将对象转换成二进制）。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题
    序列化：把Java对象转换为字节序列的过程。
    反序列化：把字节序列恢复为Java对象的过程。
    实现：
        将需要被序列化的类实现Serializable接口
    注意：
        被关键字static、transient修饰的变量不能被序列化。在被序列化后，transient修饰的变量会被设为初始值。如int型的是0、对象型的是null.

### 73：在JAVA中，如何跳出当前的多重嵌套循环？ ###

用break; return 方法。

### 74：面向对象的特征有哪些方面？ ###

- 抽象：
        抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
    - 继承：
        继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
    - 封装：
        封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
    - 多态性：
        多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

### 75：Collection 和 Collections的区别？ ###

Collection是集合类的上级接口
    继承与他的接口主要有Set 和List. 
    Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

### 76：同步和异步有何异同，在什么情况下分别使用他们？举例说明。 ###

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。 
    当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

### 77：abstract class和interface有什么区别? ###

声明方法的存在而不去实现它的类被叫做抽象类（abstract class）。
    它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。
    不能创建abstract 类的实例。
    然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。
    不能有抽象构造函数或抽象静态方法。
    Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。
    取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
    接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。
    多继承性可通过实现这样的接口而获得。
    接口中的所有方法都是抽象的，没有一个有程序体。
    接口只可以定义static final成员变量。
    接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。
    当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。
    然后，它可以在实现了该接口的类的任何对象上调用接口的方法。
    由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

### 78：GC是什么? 为什么要有GC? ###

GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，
    Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法

### 79：请说出你所知道的线程同步的方法？ ###

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
    sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。 notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
    Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

### 80：JSP的内置对象及方法？ ###

request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法。
    response表示HttpServletResponse对象，并提供了几个用于设置送回 浏览器的响应的方法（如cookies,头信息等）
    out对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。
    pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的API，并且包装了通用的servlet相关功能的方法。 session表示一个请求的javax.servlet.http.HttpSession对象。
    Session可以存贮用户的状态信息 applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息 config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。
    page表示从该页面产生的一个servlet实例

### 81：如何现实servlet的单线程模式？ ###

<%@ page isThreadSafe=”false”%>

### 82：页面间对象传递的方法？ ###

request，session，application，cookie等

### 83：Request对象的主要方法？ ###

setAttribute(String name,Object)：设置名字为name的request的参数值
    getAttribute(String name)：返回由name指定的属性值
    getAttributeNames()：返回request对象所有属性的名字集合，结果是一个枚举的实例
    getCookies()：返回客户端的所有Cookie对象，结果是一个Cookie数组
    getCharacterEncoding()：返回请求中的字符编码方式
    getContentLength()：返回请求的Body的长度
    getHeader(String name)：获得HTTP协议定义的文件头信息
    getHeaders(String name)：返回指定名字的request Header的所有值，结果是一个枚举的实例
    getHeaderNames()：返回所以request Header的名字，结果是一个枚举的实例
    getInputStream()：返回请求的输入流，用于获得请求中的数据 getMethod()：获得客户端向服务器端传送数据的方法
    getParameter(String name)：获得客户端传送给服务器端的有name指定的参数值
    getParameterNames()：获得客户端传送给服务器端的所有参数的名字，结果是一个枚举的实例
    getParameterValues(String name)：获得有name指定的参数的所有值
    getProtocol()：获取客户端向服务器端传送数据所依据的协议名称
    getQueryString()：获得查询字符串
    getRequestURI()：获取发出请求字符串的客户端地址
    getRemoteAddr()：获取客户端的IP地址
    getRemoteHost()：获取客户端的名字
    getSession([Boolean create])：返回和请求相关
    Session getServerName()：获取服务器的名字
    getServletPath()：获取客户端所请求的脚本文件的路径
    getServerPort()：获取服务器的端口号
    removeAttribute(String name)：删除请求中的一个属性

### 84：J2ee常用的设计模式？说明工厂模式? ###

Java中的23种设计模式： 
    Factory（工厂模式）， Builder（建造模式）， 
    Factory Method（工厂方法模式）， Prototype（原始模型模式），Singleton（单例模式）， Facade（门面模式），
    Adapter（适配器模式）， Bridge（桥梁模式）， 
    Composite（合成模式）， Decorator（装饰模式）， 
    Flyweight（享元模式）， Proxy（代理模式）， 
    Command（命令模式）， Interpreter（解释器模式）， 
    Visitor（访问者模式）， Iterator（迭代子模式）， 
    Mediator（调停者模式）， Memento（备忘录模式），
    Observer（观察者模式）， State（状态模式）， 
    Strategy（策略模式）， Template Method（模板方法模式）， 
    Chain Of Responsibleity（责任链模式）
    工厂模式：工厂模式是一种经常被使用到的模式，
    根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，
    通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。
    首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。
    然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。
    当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

### 85：List、Map、Set三个接口，存取元素时，各有什么特点？ ###

List 以特定次序来持有元素，可有重复元素。
    Set 无法拥有重复元素,内部排序。
    Map 保存key-value值，value可多值。

### 86：如何对数据库做优化？ ###

1：数据库设计
        数据库表：字段类型、字段长度、注释、字段命名规范
        数据库索引：外键、关联字段、查询频率比较高的字段、
                如果数据表字段>20，则最多支持16个索引
                如果数据表字段<20，则根据查询频率字段来定
        数据库视图：相当于一张临时表，业务中，尽量少使用
        数据库引擎：根据业务，选择对应的表引擎技术
        数据库存储过程：尽量少用
        数据库字符：UTF-8、或者和页面字符保持一致
        数据库监听器/触发器：一般用于调度任务或者备份还原
    2：业务调用的sql语句优化
        xml：
        尽量少关联表，效率最高关联4张表，如果多于4张表，则需要开启两个链接事务，但是这两个事务，必须在一个service当中。
        如果是查询语句，则不建议使用*
        如果是查询语句，where条件后面，最好使用索引字段进行关联
    3：数据库服务器的搭建（集群）
        主从配置：
        读写分离：
        自动化（容器）：

### 87：如何对JVM进行性能调优？ ###

参考图片

![640_wx_fmt_png_tp_webp_wxfrom_5_wx_lazy_1][]

### 88：如何实现集群模式下，session共享？ ###

一：Tomcat本身配置
    1：登录成功之后，将session信息存放到redis中，利用拦截器来过滤查找session（推荐）
    2：配置tomcat文件server.xml
        <Engine name="Catalina" defaultHost="localhost" jvmRoute="8081">
    <Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>
     如果还没有session信息同步，则需要在项目的启动容器web.xml中，在display-name标签下面，添加<distributable/>
    二：使用redis服务器

### 89：程序员如果想换行，应该怎么处理？ ###

回车

### 90：公司如果想换一个灯泡,请问需要几个java工程师？ ###

调用构造方法，或者调用换灯泡的方法即可

### 91：Hibernate一级缓存和二级缓存的区别？ ###

1.一级缓存是session独享，默认开启，无需配置
    2.二级缓存是session共享，需要在配置文件中开启，可以指定缓存区域块

### 92：Hibernate有几种查询方式？ ###

HQL查询、Criteria查询、NativeSQL查询

### 93：你对加班怎么看？能接受出差吗？ ###

可以接受加班，但是希望是有效率的加班，出差根据自身回答

### 94：谈谈个人3-5年的职业规划？ ###

从技术和管理两方面回答

### 95：在项目开发中，曾经遇到什么困难、难解的问题？ ###

至今没有，就是这么自信，这是为什么呢？

### 96：为什么从上家公司离职？ ###

自身回答

### 97：你喜欢在什么样的团队进行工作？ ###

自身回答

### 98：做一个简单的自我介绍？ ###

自身回答

### 99：工作中，如果你和项目组长或者领导的意见不一样，应该怎么处理？ ###

自身回答

### 100：遇到需求变更如何处理？ ###

实际情况回答

转载自：https://mp.weixin.qq.com/s/tvJUE9ACTIvEa0cnt4fE3Q

[640_wx_fmt_jpeg_tp_webp_wxfrom_5_wx_lazy_1]: /images/20220524/abb6f67bed02482ba6ff4f2acba0fa17.png
[640_wx_fmt_png_tp_webp_wxfrom_5_wx_lazy_1]: /images/20220524/93e018686634421da12281db2936c4d2.png