java面试题

1：Arraylist和Linkedlist的区别？

区别：

1. ArrayList是有Array所支持的基于一个索引的数据结构,所以它提供对元素的随机访问,但LinkedList存储一系列的节点数据,每个节点都与前一个和下一个节点相连接.所以尽管有使用索引获取元素的方法,内部实现是从起始点开始遍历,遍历到索引的节点然后返回元素,比ArrayList要慢
2. 与ArrayList相比,在LinkedList中插入,添加和删除一个元素会更快,因为在一个元素被插入到中间的时候,不会涉及改变数组的大小,或更新索引.
3. LinkedList比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操作数据库的步骤？

package cn.tedu.jdbc;
 

import java.sql.*;

   //测试 jdbc
//需求：查询cgb2104库里的students表里的所有数据
   
public class Test1 {
  
      public static void main(String[] args) throws Exception {
   
           //1,注册驱动
     
              Class.forName("com.mysql.jdbc.Driver");
     
                 //2,获取和数据库的连接
//String url= "jdbc:mysql://localhost:3306/cgb2104?characterEncoding=utf8";//指定要连接哪个数据库
                String url= "jdbc:mysql:///cgb2104?characterEncoding=utf8";//指定要连接哪个数据库
      
                String user= "root" ; //使用的用户名
    
                 String pwd= "root" ; //使用的密码
    
                   Connection conn = DriverManager.getConnection(url, user, pwd);
    
                    //3,获取传输器,执行SQL
      
                     Statement st = conn.createStatement();
     
                        //4,执行SQL
     
                        ResultSet rs = st.executeQuery("select * from students");
  
                              //5,解析结果集
       
                          while( rs.next() ){//next()判断结果集中是否有数据
     
                                 for (int i = 1; i <= 5 ; ++) {
             
                                            //获取每列的值并打印
                
                                    System.out.println( rs.getString(i) );
                                     }
                                       }
                             //6,释放资源
                  rs.close(); //关闭结果集
                  st.close();//关闭传输器
                  conn.close();//关闭连接
                  }
              }     

6：HashTable和HashMap有什么区别？

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

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

创建多线程的方式有4种 1.继承Thread类创建线程类2.通过Runnable接口创建线程类
3.通过Callable接口创建线程 4.通过线程池创建
产生:
- 一个资源每次只能被一个进程使用
- 一个进程因请求发生阻塞时，依然对已获得的资源保持不放
- 进程已经获得资源使用权，但是一直未使用
- 同一个进程，频繁的获取资源的优先使用权，一直未释放

 - /** * 演示死锁的产生 */public class DeadLock implements Runnable {    private String mutex1;    private String mutex2;    public DeadLock(String mutex1, String mutex2) {        this.mutex1 = mutex1;        this.mutex2 = mutex2;    }    @Override    public void run() {        synchronized (mutex1) {            System.out.println(Thread.currentThread().getName() + ": 持有" + mutex1 + ", 尝试获取" + mutex2);            try {                // 睡眠一定时间，给别的线程获取资源，产生冲突                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            synchronized (mutex2) {                System.out.println(Thread.currentThread().getName() + "：持有" + mutex2 + ", 尝试获取" + mutex1);            }        }    }    public static void main(String[] args) {        String mutex1 = "mutex1";        String mutex2 = "mutex2";        new Thread(new DeadLock(mutex1, mutex2), "AAA").start();        new Thread(new DeadLock(mutex2, mutex1), "BBB").start();    }}

防止：
加锁顺序（线程按照一定的顺序加锁）
加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）
死锁检测（一般是将所有的锁存放于map对象中，检测map中的锁）

8：String， StringBuffer， StringBuilder 的区别？

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

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

Tcp和udp是OSI模型中的传输层协议 TCP提供可靠的通信传输,而UDP则长被用于让广播和细节控制交给应用的通信传输
TCP面向连接 UDP面向非连接即发送数据前不需要建立连接
TCP提供可靠的服务(数据传输) UDP无法保证
TCP面向字节流,UDP面向报文
TCP数据传输慢,UDP数据传输快
TCP是三次握手协

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.#{ }是预编译处理 在处理时会将sql中的#{ } 替换成? 然后调用preparedStatement的set方法赋值
2.$是字符串替换在处理时将${ }替换成变量的值,传入的数据不会两边加单引号,所以使用${ }会导致sql注入 不利于系统的安全性

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.请求次数 :重定向是浏览器想服务器发送一次请求并收到响应后再次想一个新地址发出请求, 转发是服务器收到请求后为了完成响应跳转到新的地址, 重定向至少请求2次 转发请求一次
2.地址栏 :重定向地址栏会发生变化,转发地址栏不变
3.数据共享 :重定向两次请求不共享数据 ,转发一次请求共享数据(早request级别使用信息共享,使用重定向必然出错)
4.跳转限制 :重定向可以跳转到任意url,转发只能跳转本站点资源
5.行为 : 重定向是客户端行为, 转发是服务器行为

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

2 << 3 (位运算左移3位相当于乘以2的3次方,右移3位相当于除以2的3次方) 因为位运算是cpu直接支持的 效率最高的

17：Spring常见的注解有哪些？

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

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

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

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

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

19：final, finally, finalize的区别？

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

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

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

21：谈谈Spring AOP的原理？

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

22：简要说明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中进行引用和配置

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

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

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

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

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

json、file、xml、jsonp等

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

字节流：按字节读写
字符流：按字符

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

27：正向代理和反向代理的区别?

反向代理:
a.反向代理服务器介于用户于目标服务器之间
b.用户以为反向代理服务器就是目标服务器
c.用户无需关心真实的服务器地址,反向代理机制保护了目标服务器的信息.
正向代理:
a.代理的服务器介于用户和目标服务器之间
b.用户发送请求时,明确告知代理服务器访问的真实地址是谁?
c.正向代理保护了客户信息,服务器无需了解真实的访问者到底是谁.
正向代理通常用在网络请求中(路由器.)

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

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

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

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

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

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

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

Redis：数据量较小的更性能操作和运算上
MongoDB:主要解决海量数据的访问效率问题

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

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

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

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

34：==与equals有什么区别？

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

35：++i与i++的区别？

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

36：List和Map有什么区别？

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

37：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

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

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

39：你怎么理解负载均衡?

负载均衡 就是将请求分配到多个服务器上运行,加强网络的数据处理能力,从而提高应用的吞吐能力,也提高了应用的性能.

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

不一定相同
一定

41：简述servlet 生命周期？

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

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

进程是资源的分配和调度的一个独立单元，而线程是CPU调度的基本单元

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

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

就绪状态：

当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态

运行状态：

当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为运行状态

阻塞状态：

正在运行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种，例如，等待I/O完成、申请缓冲区不能满足、等待信件(信号)等

状态转换：

就绪→运行：处于就绪状态的进程，当进程调度程序为之分配了处理机后，该进程便由就绪状态转变成运行状态

运行→就绪：处于运行状态的进程在其运行过程中，因分配给它的一个时间片已用完而不得不让出处理机，于是进程从运行状态转变成就绪状态

运行→阻塞：正在运行的进程因等待某种事件发生而无法继续运行时，便从运行状态变成阻塞状态

阻塞→就绪：处于阻塞状态的进程，若其等待的事件已经发生，于是进程由阻塞状态转变为就绪状态

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

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

45：SpringMVC运行原理是什么？

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

46：Nginx负载均衡算法有哪些?

1. 轮询(默认): 每次请求按时间顺序逐一分配到不同的后端服务器,如果后端服务器down掉,能自动剔除.
2. 权重 (weight): 指定轮询几率 ,weight和访问比率成正比,用于后端服务器性能不均的情况.
3. ip-hash(IP绑定): 每个请求按访问IP哈希分配,同一个IP的请求转发发到同一台服务器
4. fair(第三方): 按后端服务器的响应时间来分配请求,响应时间短的优先分配

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

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

48：什么是ORM？

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

49：什么是IOC？

(Inversion of Control,简称IOC)，即控制反转指的是将创建对象的控制权进行转移,由SpingIOC进行负责创建对象,装配对象,配置对象,管理对象(通多依赖注入之间的依赖关系),并且管理这些对象的整个生命周期.
IOC的好处: 减少代码侵入,实现松耦合 . 减少冗余代码量 .减少内存开销

50：jsp的作用域有哪些？

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

51：sleep 和 wait 有什么区别？

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

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

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

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

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

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

`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;
                }
            }
        }
    }
}

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

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

56：简述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操作线程，必须等待。

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

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

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

public、final、abstract

59：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可以自动转换

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

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

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

饿汉式单例：

 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;
        }
    }

实现一个单例有两点注意事项：
- 将构造器私有，不允许外界通过构造器创建对象
- 通过公开的静态方法向外界返回类的唯一实例

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

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

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

jsp本质就是servlet

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

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

Lock能完成几乎所有synchronized的功能，并有一些后者不具备的功能，如锁投票、定时锁等候、可中断锁等候等

• synchronized 是Java内置的关键字，Lock 则是JDK 5中出现的一个包
• synchronized 同步的代码块可以由JVM自动释放；Lock 需要程序员在finally块中手工释放

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

xml-dom4j
excel-poi、jxl

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

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

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

用break; return 方法。

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

抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

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

69：Collection 和 Collections的区别？

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

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

同步 : 即调用方法开始,一旦调用就必须等待方法执行完返回才能继续下面的操作
举例:去银行取钱你必须等ATM吐完钱你拿到钱 取完卡你才能离开
异步: 即不关心方法执行的过程,触发要调用的方法就继续执行下边的操作,不会像同步那样阻塞直到方法完成才继续.

71：abstract class和interface有什么区别?

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

72：GC是什么? 为什么要有GC?

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

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

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

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

<%@ page isThreadSafe=”false”%>

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

request，session，application，cookie等

76：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（责任链模式）
工厂模式：工厂模式是一种经常被使用到的模式，
根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，
通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。
首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。
然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。
当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

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

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

78：如何对数据库做优化？

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

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

一：Tomcat本身配置
1：登录成功之后，将session信息存放到redis中，利用拦截器来过滤查找session（推荐）
2：配置tomcat文件server.xml


如果还没有session信息同步，则需要在项目的启动容器web.xml中，在display-name标签下面，添加
二：使用redis服务器

80：Redis支持那些数据类型的存储？

字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets)， bitmaps(判断状态)， hyperloglogs (求基数) 地理空间（geospatial)

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

1.文档型数据库
MongoDB
(一般必须掌握)
MongoDB是一个基于分布式文件存储的数据库,C++编写,主要来处理大量的文档!
MongoDB是一个介于关系型数据库和非关系型数据中中间的产品! MongoDB 是非关系型数据库中功能最丰富的,最像关系型数据库的!
2.列存储数据库
HBase
分布式文件系统

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

83: 如何给一张表增加一个字段，写出sql语句？

 alter table 表名 add column 字段名 字段类型(字段长度);

84: 谈谈Spring AOP的原理？

AOP是一个切面编程的思想，AOP吧软件的功能模块分为了"核心关注点’'和"横切关注点",业务处理的主要功能关注点是核心关注点,需要扩展的功能为横切关注点,就是能够让我们在不影响主业务功能的前提下，横切扩展新的功能。比如日志功能，在不影响主业务流程的情况下打印一些日志,权限控制等

85: 谈谈你对MVC的理解？

springmvc提供了模型-视图-控制器 架构和随时可用的组件,用于开发灵活且松耦合的web应用程序 .MVC模式有助于分离应用程序的不同方面,如输入逻辑,业务逻辑和UI逻辑,同时在所有这些元素之间提供松散耦合

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

1.URL解析
2.DNS解析：浏览器进行DNS域名解析，得到对应的IP地址
3.TCP连接：TCP三次握手
4.发送HTTP请求
5.服务器处理请求并返回HTTP报文
6.浏览器根据其请求得到的资源渲染页面
7.断开连接：TCP四次挥手

87: SpringMVC运行原理是什么？

1、用户发送请求至前端控制器DispatcherServlet。
2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。
3、处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给 DispatcherServlet。
4、DispatcherServlet调用HandlerAdapter处理器适配器。
5、HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
6、Controller执行完成返回ModelAndView。
7、andlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
9、ViewReslover解析后返回具体View。
10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。
11、DispatcherServlet响应用户

88: Springbean生命周期是怎么样的？

1. Spring容器根据配置中的bean定义中实例化bean
2. Spring使用依赖注入填充所有属性,如bean中所定义的配置
3. 如果bean实现BeanNameAware接口,则工厂通过传递bean的ID来调用setBeanName()
4. 如果bean实现BeanFactoryAware接口,工厂通过传递自身的实例来调用setBeanFactory()
5. 如果存在于bean关联的任何BeanPostProcessors,则调用preProcessBeforeInitialization()方法
6. 如果为bean指定了init方法(的init-method属性),name将调用它
7. 最后,如果存在与bean关联的任何BeanPostProcessors,则将调用pstProcessAfterIntialization()方法

89: 什么是数据库的事务?

事务是指一系列的数据库操作,是数据库应用的基本逻辑单位,如果事务中的任何一个语句操作失败,name整个事务中的操作就失败,所有操作就会回滚到操作前状态
事务就是为了保证要么全部执行成功,要么全部执行失败

90: sql JOIN连接及区别?

INNER JOIN: 两个表记录匹配时才返回匹配行.
LEFT JOIN : 以左表为参考匹配,返回左表中的所有行,右表中如有匹配行则返回,没有匹配项则返回null
RIGHT JOIN: 以右表为参考匹配,返回右表中的所有行,左表中如有匹配行则返回,没有匹配项则返回null

91: MYSQL如何实现分页查询?

92: MYSQL如何实现分页查询?

92: Ajax面试题

什么是ajax?

100: 数据库SQL语句练习？

https://blog.csdn.net/a19980115/article/details/83660950