面试总结

代表的是：该Controller的所有方法在调用前，先执行此@ModelAttribute方法，可用于注解和方法参数中，可以把这个@ModelAttribute特性，应用在BaseController当中，所有的Controller继承BaseController，即可实现在调用Controller时，先执行@ModelAttribute方法。

@SessionAttributes即将值放到session作用域中，写在class上面。

@requestParam

@requestParam主要用于在SpringMVC后台控制层获取参数，类似一种是request.getParameter("name")，它有三个常用参数：defaultValue = "0", required = false, value = "isApp"；defaultValue 表示设置默认值，required 铜过boolean设置是否是必须要传入的参数，value 值表示接受的传入的参数类型。

@ResponseBody

作用：该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。

使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用；

3、MySQL 的左连接、右连接、内连接的区别

先说左外连接和右外连接：

[[email protected]#16-12月-11] SQL>select * from t1;

ID NAME

---------- --------------------

1 aaa

2 bbb

[[email protected]#16-12月-11] SQL>select * from t2;

ID AGE

---------- ----------

1 20

3 30

左外连接：

[[email protected]#16-12月-11] SQL>select * from t1 left join t2 on t1.id=t2.id;

ID NAME ID AGE

---------- -------------------- ---------- ----------

1 aaa 1 20

2 bbb

右外连接：

[[email protected]#16-12月-11] SQL>select * from t1 right join t2 on t1.id=t2.id;

ID NAME ID AGE

---------- -------------------- ---------- ----------

1 aaa 1 20

3 30

从上面的显示你可以看出：左外连接是以左边的表为基准。通俗的讲，先将左边的表全部显示出来，然后右边的表id与左边表id相同的记录就“拼接”上去，比如说id为1的记录。如果没有匹配的id，比如说t1中id为2的t2中就没有。那边就以null显示。

右外连接过程正好相反。

再看内连接：

[[email protected]#16-12月-11] SQL>select * from t1 inner join t2 on t1.id=t2.id;

ID NAME ID AGE

---------- -------------------- ---------- ----------

1 aaa 1 20

看到没有？只有一条记录。内连接就是只取出符合过滤条件的记录也就是t1.id=t2.id 那么符合t1.id=t2.id的记录只有id=1这一条，所以只显示一条。不像外连接，是将你作为基准的表（左外连接就是左边表为基准，右外连接就是右边表为基准）的所有行都显示出来。

4、通过Collections 比较List

//对于Comparator接口的重写

//这个接口就一个抽象函数，给出的参数与返回值都是定死的。

Collections.sort(studentArr, new Comparator<Object>() {

public int compare(Object o1, Object o2) {

//你首先设置你要比较的东西

//具体是把参数中的Object强制转换成你要比较的东西，这里是两个Student类

//这里的s1,s2与上面的s1,s2一点关系都没有，只是抽象的前者与后者的关系

Student s1 = (Student) o1;

Student s2 = (Student) o2;

//如果前者的学号大于后者的学号，就是前者大于后者，返回1系统就会识别是前者大于后者

if (s1.s_no > s2.s_no) {

return 1;

}

//小于同理

if (s1.s_no < s2.s_no) {

return -1;

}

//如果返回0则认为前者与后者相等

return 0;

}

});

5、Servlet 生命周期

Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程：

Servlet 通过调用 init () 方法进行初始化。

Servlet 调用 service() 方法来处理客户端的请求。

Servlet 通过调用 destroy() 方法终止（结束）。

最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

init() 方法

init 方法被设计成只调用一次。它在第一次创建 Servlet 时被调用，在后续每次用户请求时不再调用。因此，它是用于一次性初始化，就像 Applet 的 init 方法一样。

service() 方法

service() 方法是执行实际任务的主要方法。Servlet 容器（即 Web 服务器）调用 service() 方法来处理来自客户端（浏览器）的请求，并把格式化的响应写回给客户端。

doGet() 方法

GET 请求来自于一个 URL 的正常请求，或者来自于一个未指定 METHOD 的 HTML 表单，它由 doGet() 方法处理。

doPost() 方法

POST 请求来自于一个特别指定了 METHOD 为 POST 的 HTML 表单，它由 doPost() 方法处理。

destroy() 方法

destroy() 方法只会被调用一次，在 Servlet 生命周期结束时被调用。destroy() 方法可以让您的 Servlet 关闭数据库连接、停止后台线程、把 Cookie 列表或点击计数器写入到磁盘，并执行其他类似的清理活动。

6、HTTP协议

HTTP协议（HyperText Transfer Protocol，超文本传输协议）是因特网上应用最为广泛的一种网络传输协议，所有的WWW文件都必须遵守这个标准。

HTTP是一个基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件, 查询结果等）。

http请求由三部分组成，分别是：请求行、消息报头、请求正文

HTTP 工作原理

HTTP协议工作于客户端-服务端架构上。浏览器作为HTTP客户端通过URL向HTTP服务端即WEB服务器发送所有请求。

HTTP 消息结构

HTTP是基于客户端/服务端（C/S）的架构模型，通过一个可靠的链接来交换信息，是一个无状态的请求/响应协议。

一个HTTP"客户端"是一个应用程序（Web浏览器或其他任何客户端），通过连接到服务器达到向服务器发送一个或多个HTTP的请求的目的。

客户端请求消息

客户端发送一个HTTP请求到服务器的请求消息包括以下格式：请求行（request line）、请求头部（header）、空行和请求数据四个部分组成，下图给出了请求报文的一般格式。

面试总结

服务器响应消息

HTTP响应也由四个部分组成，分别是：状态行、消息报头、空行和响应正文。

面试总结

7、MySQL索引(单个索引和联合索引的区别)

如果我们创建了(area, age,salary)的复合索引，那么其实相当于创建了：

(area,age,salary)，(area,age)、(area)三个索引，这被称为最佳左前缀

特性。因此我们在创建复合索引时应该将最常用作限制条件的列放在最左边，依次递减。

8、TCP、UDP(传输层) IP(网络层)

网际互联及OSI七层模型：

物理层、数据链路层、网络层、传输层、表示层、会话层、应用层

物理层

作用：定义一些电器，机械，过程和规范，如集线器；

PDU(协议数据单元)：bit/比特

设备：集线器HUB;

注意：没有寻址的概念；

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

数据链路层

作用：定义如何格式化数据，支持错误检测；

典型协议：以太网，帧中继（古董级v*n）

PDU：frame（帧）设备：以太网交换机；

备注：交换机通过MAC地址转发数据，逻辑链路控制；

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

网络层

作用：定义一个逻辑的寻址，选择最佳路径传输，路由数据包；

典型协议：IP，IPX，ICMP,ARP(IP->MAC),IARP;

PDU:packet/数据包；

设备：路由器

备注：实现寻址

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

传输层：

作用：提供可靠和尽力而为的传输；

典型协议：TCP,UDP,SPX,port(65535个端口),EIGRP,OSPF,

PDU:fragment 段；

无典型设备；

备注：负责网络传输和会话建立；

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

会话层：

作用：控制会话，建立管理终止应用程序会话；

典型协议：NFS, SQL, ASP, PHP, JSP, RSVP(资源源预留协议), windows，

备注：负责会话建立；

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

表示层：

作用：格式化数据；

典型协议：ASCII, JPEG. PNG, MP3. WAV, AVI,

备注：可以提供加密服务；

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

应用层：

作用：控制应用程序；

典型协议：telant, ssh, http, ftp, smtp, rip, BGP, (未完待续)

备注：为应用程序提供网络服务；

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

9、TCP/IP协议

您的 E-Mail 使用 TCP/IP 协议

您的电子邮件也通过 TCP/IP 协议来发送和接收邮件。

因特网地址是 TCP/IP 协议

因特网地址比如 "42.120.45.233" 就是一个 TCP/IP 协议。

10、在 TCP/IP 内部

在 TCP/IP 中包含一系列用于处理数据通信的协议：

TCP (传输控制协议) - 应用程序之间通信
UDP (用户数据报协议) - 应用程序之间的简单通信
IP (网际协议) - 计算机之间的通信
ICMP (因特网消息控制协议) - 针对错误和状态
DHCP (动态主机配置协议) - 针对动态寻址

HTTP

11、说一下什么是Http协议？

对器客户端和服务器端之间数据传输的格式规范，格式简称为“超文本传输协议”。

12、什么是Http协议无状态协议？怎么解决Http协议无状态协议？（曾经去某创业公司问到）

无状态协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息
无状态协议解决办法：通过1、Cookie 2、通过Session会话保存。

13、说一下Http协议中302状态(阿里经常问)

http协议中，返回状态码302表示重定向。
这种情况下，服务器返回的头部信息中会包含一个 Location 字段，内容是重定向到的url。

14、Http协议有什么组成？

请求报文包含三部分：

请求行：包含请求方法、URI、HTTP版本信息
请求首部字段
请求内容实体

响应报文包含三部分：

状态行：包含HTTP版本、状态码、状态码的原因短语
响应首部字段
响应内容实体

说一下网络传输的过程

面试总结

15、Http协议中有那些请求方式？

GET：用于请求访问已经被URI（统一资源标识符）识别的资源，可以通过URL传参给服务器
POST：用于传输信息给服务器，主要功能与GET方法类似，但一般推荐使用POST方式。
PUT：传输文件，报文主体中包含文件内容，保存到对应URI位置。
HEAD：获得报文首部，与GET方法类似，只是不返回报文主体，一般用于验证URI是否有效。
DELETE：删除文件，与PUT方法相反，删除对应URI位置的文件。
OPTIONS：查询相应URI支持的HTTP方法。

16、Http协议中Http1.0与1.1区别？

在http1.0中，当建立连接后，客户端发送一个请求，服务器端返回一个信息后就关闭连接，当浏览器下次请求的时候又要建立连接，显然这种不断建立连接的方式，会造成很多问题。
在http1.1中，引入了持续连接的概念，通过这种连接，浏览器可以建立一个连接之后，发送请求并得到返回信息，然后继续发送请求再次等到返回信息，也就是说客户端可以连续发送多个请求，而不用等待每一个响应的到来。

17、get与post请求区别？（初级程序员必备问题）

区别一：

get重点在从服务器上获取资源。
post重点在向服务器发送数据。

区别二：

get传输数据是通过URL请求，以field（字段）= value的形式，置于URL后，并用"?"连接，多个请求数据间用"&"连接，如http://127.0.0.1/Test/login.action?name=admin&password=admin，这个过程用户是可见的。
post传输数据通过Http的post机制，将字段与对应值封存在请求实体中发送给服务器，这个过程对用户是不可见的。

区别三：

Get传输的数据量小，因为受URL长度限制，但效率较高。
Post可以传输大量数据，所以上传文件时只能用Post方式。

区别四：

get是不安全的，因为URL是可见的，可能会泄露私密信息，如密码等。
post较get安全性较高。

区别五：

get方式只能支持ASCII字符，向服务器传的中文字符可能会乱码。
post支持标准字符集，可以正确传递中文字符。

18、常见Http协议状态？

200：请求被正常处理

204：请求被受理但没有资源可以返回

206：客户端只是请求资源的一部分，服务器只对请求的部分资源执行GET方法，相应报文中通过Content-Range指定范围的资源。

301：永久性重定向

302：临时重定向

303：与302状态码有相似功能，只是它希望客户端在请求一个URI的时候，能通过GET方法重定向到另一个URI上

304：发送附带条件的请求时，条件不满足时返回，与重定向无关

307：临时重定向，与302类似，只是强制要求使用POST方法

400：请求报文语法有误，服务器无法识别

401：请求需要认证

403：请求的对应资源禁止被访问

404：服务器无法找到对应资源

500：服务器内部错误

503：服务器正忙

19、Http协议首部字段？

a、通用首部字段（请求报文与响应报文都会使用的首部字段）

Date：创建报文时间
Connection：连接的管理
Cache-Control：缓存的控制
Transfer-Encoding：报文主体的传输编码方式

b、请求首部字段（请求报文会使用的首部字段）

Host：请求资源所在服务器
Accept：可处理的媒体类型
Accept-Charset：可接收的字符集
Accept-Encoding：可接受的内容编码
Accept-Language：可接受的自然语言

c、响应首部字段（响应报文会使用的首部字段）

Accept-Ranges：可接受的字节范围
Location：令客户端重新定向到的URI
Server：HTTP服务器的安装信息

d、实体首部字段（请求报文与响应报文的的实体部分使用的首部字段）

Allow：资源可支持的HTTP方法
Content-Type：实体主类的类型
Content-Encoding：实体主体适用的编码方式
Content-Language：实体主体的自然语言
Content-Length：实体主体的的字节数
Content-Range：实体主体的位置范围，一般用于发出部分请求时使用

20、Http与Https优缺点？

通信使用明文不加密，内容可能被窃听，也就是被抓包分析。
不验证通信方身份，可能遭到伪装
无法验证报文完整性，可能被篡改
HTTPS就是HTTP加上加密处理（一般是SSL安全通信线路）+认证+完整性保护

21、Http优化

利用负载均衡优化和加速HTTP应用
利用HTTP Cache来优化网站

22、Http协议有那些特征？

1、支持客户/服务器模式；2、简单快速；3、灵活；4、无连接；5、无状态。

多台服务器共享session

多台服务器session同步解决方案

1.用redis保存session，所有服务器共享这个redis服务器

HttpSession session = request.getSession();

Jedis redis = new Jedis("127.0.0.1");

String sessionJson = redis.get(session.getId());

if(StringUtils.isNotBlank(sessionJson)){

session=JSON.parseObject(sessionJson, HttpSession.class);

}else{

redis.set(session.getId(), JSON.toJSONString(session));

Cookie cookie = new Cookie("redisCookieId", session.getId());

response.addCookie(cookie);

}

2.使用浏览器cookie储存session信息

HttpSession session =request.getSession() ;

Cookie[] cookies = request.getCookies();

boolean isHasSession = false ;

String key = DESUtil.genDESKey();

for(Cookie cookie:cookies){

if(cookie.getName().equals("sessionInfo")){

session = JSON.parseObject(cookie.getValue(),HttpSession.class);

isHasSession=true;

}

}if(!isHasSession){

String desSession = DESUtil.encode(JSON.toJSONString(session), key);

Cookie cookie = new Cookie("sessionInfo", desSession );

response.addCookie(cookie);

}

3.与使用redis类类似，使用一个共享数据库，里面新建一个专门保存session信息的表。
所有的服务器要是使用session的话，直接从这个数据库里取session信息。不过这种方式效率很低，并且需要隔断时间去清理一些过期的session数据，高并发时，会有大量session进来，对数据库性能要求较高。

4。对负载均衡服务器分配服务器算法进行改进，同一用户（即同一个sessionId）经过负载均衡分配服务器时，默认分配上次访问的服务器。

Spring 注解

23、基于注解的声明式事务管理配置
spring-servlet.xml

1 2 3 <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">4 <property name="dataSource" ref="dataSource" />5 </bean>6 7 <tx:annotation-driven transaction-manager="txManager" />

还要在spring-servlet.xml中添加tx名字空间

1 ... 2 xmlns:tx="http://www.springframework.org/schema/tx" 3 xmlns:aop="http://www.springframework.org/schema/aop" 4 xsi:schemaLocation=" 5 ... 6 7 http://www.springframework.org/schema/tx 8 9 10 http://www.springframework.org/schema/tx/spring-tx.xsd

@Transactional注解中常用参数说明

参数名称	功能描述
readOnly	该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读写，默认值为false。例如：@Transactional(readOnly=true)
rollbackFor	该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚。例如：指定单一异常类：@Transactional(rollbackFor=RuntimeException.class) 指定多个异常类：@Transactional(rollbackFor={RuntimeException.class, Exception.class})
rollbackForClassName	该属性用于设置需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，则进行事务回滚。例如：指定单一异常类名称：@Transactional(rollbackForClassName="RuntimeException") 指定多个异常类名称：@Transactional(rollbackForClassName={"RuntimeException","Exception"})
noRollbackFor	该属性用于设置不需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，不进行事务回滚。例如：指定单一异常类：@Transactional(noRollbackFor=RuntimeException.class) 指定多个异常类：@Transactional(noRollbackFor={RuntimeException.class, Exception.class})
noRollbackForClassName	该属性用于设置不需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，不进行事务回滚。例如：指定单一异常类名称：@Transactional(noRollbackForClassName="RuntimeException") 指定多个异常类名称： @Transactional(noRollbackForClassName={"RuntimeException","Exception"})
propagation	该属性用于设置事务的传播行为，具体取值可参考表6-7。例如：@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)
isolation	该属性用于设置底层数据库的事务隔离级别，事务隔离级别用于处理多事务并发的情况，通常使用数据库的默认隔离级别即可，基本不需要进行设置
timeout	该属性用于设置事务的超时秒数，默认值为-1表示永不超时

24、数组、链表的内存问题

数组,在内存上给出了连续的空间.链表,内存地址上可以是不连续的,每个链表的节点包括原来的内存和下一个节点的信息(单向的一个,双向链表的话,会有两个).

内存地址的利用率方面.不管你内存里还有多少空间,如果没办法一次性给出数组所需的要空间,那就会提示内存不足,磁盘空间整理的原因之一在这里.而链表可以是分散的空间地址.

数组与链表的优缺点；
数组:

优点：使用方便，查询效率比链表高，内存为一连续的区域

缺点：大小固定，不适合动态存储，不方便动态添加
链表：

优点：可动态添加删除大小可变
缺点：只能通过顺次指针访问，查询效率低

补充：

顺序表的优点:查找方便,适合随机查找
顺序表的缺点:插入、删除操作不方便，因为插入、删除操作会导致大量元素的移动

链接表的优点:插入、删除操作方便，不会导致元素的移动，因为元素增减，只需要调整指针。
顺序表的缺点:查找方便，不适合随机查找

25、数组的优点

随机访问性强
查找速度快

26、数组的缺点

插入和删除效率低
可能浪费内存
内存空间要求高，必须有足够的连续内存空间。
数组大小固定，不能动态拓展

27、链表的优点

插入删除速度快
内存利用率高，不会浪费内存
大小没有固定，拓展很灵活。

28、链表的缺点

不能随机查找，必须从第一个开始遍历，查找效率低

29、依赖注入(Ioc)和控制反转(DI)

IoC:对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

DI:DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。

控制的什么被反转了？ 就是：获得依赖对象的方式反转了。

30、Springmvc运行步骤

面试总结

1. 用户向服务器发送请求，请求被Spring 前端控制Servelt DispatcherServlet捕获；

2. DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI）。然后根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain对象的形式返回；

3. DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter。（附注：如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(...)方法）

4. 提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：

HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息

数据转换：对请求消息进行数据转换。如String转换成Integer、Double等

数据根式化：对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等

数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中

5. Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象；

6. 根据返回的ModelAndView，选择一个适合的ViewResolver（必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet ；

7. ViewResolver 结合Model和View，来渲染视图

8. 将渲染结果返回给客户端。

Spring工作流程描述

为什么Spring只使用一个Servlet(DispatcherServlet)来处理所有请求？

详细见J2EE设计模式-前端控制模式

Spring为什么要结合使用HandlerMapping以及HandlerAdapter来处理Handler?

符合面向对象中的单一职责原则，代码架构清晰，便于维护，最重要的是代码可复用性高。如HandlerAdapter可能会被用于处理多种Handler。

31、集合

面试总结

1. Interface Iterable

迭代器接口，这是Collection类的父接口。实现这个Iterable接口的对象允许使用foreach进行遍历，也就是说，所有的Collection集合对象都具有"foreach可遍历性"。这个Iterable接口只
有一个方法: iterator()。它返回一个代表当前集合对象的泛型<T>迭代器，用于之后的遍历操作1.1 Collection

Collection是最基本的集合接口，一个Collection代表一组Object的集合，这些Object被称作Collection的元素。Collection是一个接口，用以提供规范定义，不能被实例化使用

1) Set

Set集合类似于一个罐子，"丢进"Set集合里的多个对象之间没有明显的顺序。Set继承自Collection接口，不能包含有重复元素(记住，这是整个Set类层次的共有属性)。

Set判断两个对象相同不是使用"=="运算符，而是根据equals方法。也就是说，我们在加入一个新元素的时候，如果这个新元素对象和Set中已有对象进行注意equals比较都返回false，　　
则Set就会接受这个新元素对象，否则拒绝。

因为Set的这个制约，在使用Set集合的时候，应该注意两点：1) 为Set集合里的元素的实现类实现一个有效的equals(Object)方法、2) 对Set的构造函数，传入的Collection参数不能包
　　含重复的元素

1.1) HashSet

HashSet是Set接口的典型实现，HashSet使用HASH算法来存储集合中的元素，因此具有良好的存取和查找性能。当向HashSet集合中存入一个元素时，HashSet会调用该对象的
hashCode()方法来得到该对象的hashCode值，然后根据该HashCode值决定该对象在HashSet中的存储位置。

值得主要的是，HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法的返回值相等

1.1.1) LinkedHashSet

LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置，但和HashSet不同的是，它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。
　　　　　　　当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。

LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet的性能，但在迭代访问Set里的全部元素时(遍历)将有很好的性能(链表很适合进行遍历)

1.2) SortedSet

此接口主要用于排序操作，即实现此接口的子类都属于排序的子类

1.2.1) TreeSet

TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态

1.3) EnumSet

EnumSet是一个专门为枚举类设计的集合类，EnumSet中所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显式、或隐式地指定。EnumSet的集合元素也是有序的，
它们以枚举值在Enum类内的定义顺序来决定集合元素的顺序

2) List

List集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List集合允许加入重复元素，因为它可以通过索引来访问指定位置的集合元素。List集合默认按元素
的添加顺序设置元素的索引

2.1) ArrayList

ArrayList是基于数组实现的List类，它封装了一个动态的增长的、允许再分配的Object[]数组。

2.2) Vector

Vector和ArrayList在用法上几乎完全相同，但由于Vector是一个古老的集合，所以Vector提供了一些方法名很长的方法，但随着JDK1.2以后，java提供了系统的集合框架，就将
Vector改为实现List接口，统一归入集合框架体系中

2.2.1) Stack

Stack是Vector提供的一个子类，用于模拟"栈"这种数据结构(LIFO后进先出)

2.3) LinkedList

implements List<E>, Deque<E>。实现List接口，能对它进行队列操作，即可以根据索引来随机访问集合中的元素。同时它还实现Deque接口，即能将LinkedList当作双端队列
使用。自然也可以被当作"栈来使用"

3) Queue

Queue用于模拟"队列"这种数据结构(先进先出 FIFO)。队列的头部保存着队列中存放时间最长的元素，队列的尾部保存着队列中存放时间最短的元素。新元素插入(offer)到队列的尾部，
访问元素(poll)操作会返回队列头部的元素，队列不允许随机访问队列中的元素。结合生活中常见的排队就会很好理解这个概念

3.1) PriorityQueue

PriorityQueue并不是一个比较标准的队列实现，PriorityQueue保存队列元素的顺序并不是按照加入队列的顺序，而是按照队列元素的大小进行重新排序，这点从它的类名也可以
看出来

3.2) Deque

Deque接口代表一个"双端队列"，双端队列可以同时从两端来添加、删除元素，因此Deque的实现类既可以当成队列使用、也可以当成栈使用

3.2.1) ArrayDeque

是一个基于数组的双端队列，和ArrayList类似，它们的底层都采用一个动态的、可重分配的Object[]数组来存储集合元素，当集合元素超出该数组的容量时，系统会在底层重
　　　　　　　新分配一个Object[]数组来存储集合元素

3.2.2) LinkedList

1.2 Map

Map用于保存具有"映射关系"的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value。key和value都可以是任何引用类型的数据。Map的key不允
许重复，即同一个Map对象的任何两个key通过equals方法比较结果总是返回false。

关于Map，我们要从代码复用的角度去理解，java是先实现了Map，然后通过包装了一个所有value都为null的Map就实现了Set集合

Map的这些实现类和子接口中key集的存储形式和Set集合完全相同(即key不能重复)

Map的这些实现类和子接口中value集的存储形式和List非常类似(即value可以重复、根据索引来查找)

1) HashMap

和HashSet集合不能保证元素的顺序一样，HashMap也不能保证key-value对的顺序。并且类似于HashSet判断两个key是否相等的标准也是: 两个key通过equals()方法比较返回true、
同时两个key的hashCode值也必须相等

1.1) LinkedHashMap

LinkedHashMap也使用双向链表来维护key-value对的次序，该链表负责维护Map的迭代顺序，与key-value对的插入顺序一致(注意和TreeMap对所有的key-value进行排序进行区
分)

2) Hashtable

是一个古老的Map实现类

2.1) Properties

Properties对象在处理属性文件时特别方便(windows平台上的.ini文件)，Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入到属性文
　　　　　件中，也可以把属性文件中的"属性名-属性值"加载到Map对象中

3) SortedMap

正如Set接口派生出SortedSet子接口，SortedSet接口有一个TreeSet实现类一样，Map接口也派生出一个SortedMap子接口，SortedMap接口也有一个TreeMap实现类

3.1) TreeMap

TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对(节点)时，需要根据key对节点进行排序。TreeMap可以保证所有的
key-value对处于有序状态。同样，TreeMap也有两种排序方式: 自然排序、定制排序

4) WeakHashMap

WeakHashMap与HashMap的用法基本相似。区别在于，HashMap的key保留了对实际对象的"强引用"，这意味着只要该HashMap对象不被销毁，该HashMap所引用的对象就不会被垃圾回收。
　　但WeakHashMap的key只保留了对实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，当垃
　　圾回收了该key所对应的实际对象之后，WeakHashMap也可能自动删除这些key所对应的key-value对

5) IdentityHashMap

IdentityHashMap的实现机制与HashMap基本相似，在IdentityHashMap中，当且仅当两个key严格相等(key1 == key2)时，IdentityHashMap才认为两个key相等

6) EnumMap

EnumMap是一个与枚举类一起使用的Map实现，EnumMap中的所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它对应的枚举类。EnumMap根据key的自然顺序
(即枚举值在枚举类中的定义顺序)

32、ＭyBatis 中#与$的区别

1、＃{}将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。如：order by #{id}，如果传入的值是111,那么解析成sql时的值为order by “111”, 如果传入的值是id，则解析成的sql为order by “id”。

2、${}将传入的数据直接显示生成在sql中。如：order by
${id}，如果传入的值是111,那么解析成sql时的值为order by 111, 如果传入的值是id，则解析成的sql为order
by id。

3、#方式能够很大程度防止sql注入。

4、$方式无法防止Sql注入。

5、$方式一般用于传入数据库对象，例如传入表名.

6、一般能用#的就别用$.

33、HashMap的工作原理以及存取方法过程

HashMap的工作原理：HashMap是基于散列法（又称哈希法hashing）的原理，使用put(key, value)存储对象到HashMap中，使用get(key)从HashMap中获取对象。当我们给put()方法传递键和值时，我们先对键调用hashCode()方法，返回的hashCode用于找到bucket（桶）位置来储存Entry对象。”HashMap是在bucket中储存键对象和值对象，作为Map.Entry。并不是仅仅只在bucket中存储值。

HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。

数组：存储区间连续，占用内存严重，寻址容易，插入删除困难；
链表：存储区间离散，占用内存比较宽松，寻址困难，插入删除容易；
Hashmap综合应用了这两种数据结构，实现了寻址容易，插入删除也容易。

面试总结

put方法
HashMap会对null值key进行特殊处理，总是放到table[0]位置
put过程是先计算hash然后通过hash与table.length取摸计算index值，然后将key放到table[index]位置，当table[index]已存在其它元素时，会在table[index]位置形成一个链表，将新添加的元素放在table[index]，原来的元素通过Entry的next进行链接，这样以链表形式解决hash冲突问题，当元素数量达到临界值(capactiy*factor)时，则进行扩容，是table数组长度变为table.length*2

public V put(K key, V value) {

if (key == null)

return putForNullKey(value); //处理null值

int hash = hash(key.hashCode());//计算hash

int i = indexFor(hash, table.length);//计算在数组中的存储位置

//遍历table[i]位置的链表，查找相同的key，若找到则使用新的value替换掉原来的oldValue并返回oldValue

for (Entry<K,V> e = table[i]; e != null; e = e.next) {

Object k;

if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {

V oldValue = e.value;

e.value = value;

e.recordAccess(this);

return oldValue;

}

//若没有在table[i]位置找到相同的key，则添加key到table[i]位置，新的元素总是在table[i]位置的第一个元素，原来的元素后移

modCount++;

addEntry(hash, key, value, i);

return null;

}

void addEntry(int hash, K key, V value, int bucketIndex) {

//添加key到table[bucketIndex]位置，新的元素总是在table[bucketIndex]的第一个元素，原来的元素后移

Entry<K,V> e = table[bucketIndex];

table[bucketIndex] = new Entry<K,V>(hash, key, value, e);

//判断元素个数是否达到了临界值，若已达到临界值则扩容，table长度翻倍

if (size++ >= threshold)

resize(2 * table.length);

}

get方法
同样当key为null时会进行特殊处理，在table[0]的链表上查找key为null的元素
get的过程是先计算hash然后通过hash与table.length取摸计算index值，然后遍历table[index]上的链表，直到找到key，然后返回

public V get(Object key) {

if (key == null)

return getForNullKey();//处理null值

int hash = hash(key.hashCode());//计算hash

//在table[index]遍历查找key，若找到则返回value，找不到返回null

for (Entry<K,V> e = table[indexFor(hash, table.length)];

e != null;

e = e.next) {

Object k;

if (e.hash == hash && ((k = e.key) == key || key.equals(k)))

return e.value;

}

return null;

}

remove方法
remove方法和put get类似，计算hash，计算index，然后遍历查找，将找到的元素从table[index]链表移除

resize方法
resize方法在hashmap中并没有公开，这个方法实现了非常重要的hashmap扩容，具体过程为：先创建一个容量为table.length*2的新table，修改临界值，然后把table里面元素计算hash值并使用hash与table.length*2重新计算index放入到新的table里面
这里需要注意下是用每个元素的hash全部重新计算index，而不是简单的把原table对应index位置元素简单的移动到新table对应位置

clear()方法
clear方法非常简单，就是遍历table然后把每个位置置为null，同时修改元素个数为0
需要注意的是clear方法只会清楚里面的元素，并不会重置capactiy

34、synchronized 与 Lock区别

synchronized :

使用synchronized 代码块相比方法有两点优势：

1、可以只对需要同步的使用

2、与wait()/notify()/nitifyAll()一起使用时，比较方便

wait() 与notify()/notifyAll()

这三个方法都是Object的方法，并不是线程的方法！

public void test() {}

// 同步的方法

pubilc synchronized void test() {}

synchronized 也可以用在一个代码块上，看

public void test() {

synchronized(obj) {

System.out.println("===");

}

Lock

public class Consumer implements Runnable {

private Lock lock;

public Consumer(Lock lock) {

this. lock = lock;

}

@Override

public void run() {

// TODO Auto-generated method stub

int count = 10;

while( count > 0 ) {

try {

lock.lock();

count --;

System. out.print( "B");

} finally {

lock.unlock(); //主动释放锁

try {

Thread. sleep(91L);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

使用建议：

在并发量比较小的情况下，使用synchronized是个不错的选择，但是在并发量比较高的情况下，其性能下降很严重，此时ReentrantLock是个不错的方案。

35、二叉树遍历

先序遍历：遍历顺序规则为【根左右】

中序遍历：遍历顺序规则为【左根右】

后序遍历：遍历顺序规则为【左右根】

面试总结

先序遍历：ABCDEFGHK

中序遍历：BDCAEHGKF

后序遍历：DCBHKGFEA

36、MySQL数据库引擎

（1）InnoDB：

定义：（默认的存储引擎）

InnoDB是一个事务型的存储引擎，有行级锁定和外键约束。

Innodb引擎提供了对数据库ACID事务的支持，并且实现了SQL标准的四种隔离级别，关于数据库事务与其隔离级别的内容请见数据库事务与其隔离级别这类型的文章。该引擎还提供了行级锁和外键约束，它的设计目标是处理大容量数据库系统，它本身其实就是基于MySQL后台的完整数据库系统，MySQL运行时Innodb会在内存中建立缓冲池，用于缓冲数据和索引。但是该引擎不支持FULLTEXT类型的索引，而且它没有保存表的行数，当SELECT COUNT(*) FROM TABLE时需要扫描全表。当需要使用数据库事务时，该引擎当然是首选。由于锁的粒度更小，写操作不会锁定全表，所以在并发较高时，使用Innodb引擎会提升效率。但是使用行级锁也不是绝对的，如果在执行一个SQL语句时MySQL不能确定要扫描的范围，InnoDB表同样会锁全表。

//这个就是select锁表的一种，不明确主键。增删改查都可能会导致锁全表，在以后我们会详细列出。SELECT * FROM products WHERE name='Mouse' FOR UPDATE;

适用场景：

1）经常更新的表，适合处理多重并发的更新请求。

2）支持事务。

3）可以从灾难中恢复（通过bin-log日志等）。

4）外键约束。只有他支持外键。

5）支持自动增加列属性auto_increment。

（2）MyIsam(了解)：

定义：

MyIASM是MySQL默认的引擎，但是它没有提供对数据库事务的支持，也不支持行级锁和外键，因此当INSERT(插入)或UPDATE(更新)数据时即写操作需要锁定整个表，效率便会低一些。

MyIsam 存储引擎独立于操作系统，也就是可以在windows上使用，也可以比较简单的将数据转移到linux操作系统上去。

意味着：引擎在创建表的时候，会创建三个文件，一个是.frm文件用于存储表的定义，一个是.MYD文件用于存储表的数据，另一个是.MYI文件，存储的是索引。操作系统对大文件的操作是比较慢的，这样将表分为三个文件，那么.MYD这个文件单独来存放数据自然可以优化数据库的查询等操作。有索引管理和字段管理。MyISAM还使用一种表格锁定的机制，来优化多个并发的读写操作，其代价是你需要经常运行OPTIMIZE TABLE命令，来恢复被更新机制所浪费的空间。

适用场景：

1）不支持事务的设计，但是并不代表着有事务操作的项目不能用MyIsam存储引擎，可以在service层进行根据自己的业务需求进行相应的控制。

2）不支持外键的表设计。

3）查询速度很快，如果数据库insert和update的操作比较多的话比较适用。

4）整天对表进行加锁的场景。

5）MyISAM极度强调快速读取操作。

6）MyIASM中存储了表的行数，于是SELECT COUNT(*) FROM TABLE时只需要直接读取已经保存好的值而不需要进行全表扫描。如果表的读操作远远多于写操作且不需要数据库事务的支持，那么MyIASM也是很好的选择。

缺点：

就是不能在表损坏后恢复数据。（是不能主动恢复）

37、MySQL查询优化

查询的开销指标：

执行时间检查的行数返回的行数

建立索引的几个准则：

1、合理的建立索引能够加速数据读取效率，不合理的建立索引反而会拖慢数据库的响应速度。 2、索引越多，更新数据的速度越慢。 3、尽量在采用MyIsam作为引擎的时候使用索引（因为MySQL以BTree存储索引），而不是InnoDB。但MyISAM不支持Transcation。 4、当你的程序和数据库结构/SQL语句已经优化到无法优化的程度，而程序瓶颈并不能顺利解决，那就是应该考虑使用诸如memcached这样的分布式缓存系统的时候了。 5、习惯和强迫自己用EXPLAIN来分析你SQL语句的性能。

1. count的优化

比如：计算id大于5的城市 a. select count(*) from world.city where id > 5; b. select (select count(*) from world.city) – count(*) from world.city where id <= 5; a语句当行数超过11行的时候需要扫描的行数比b语句要多， b语句扫描了6行，此种情况下，b语句比a语句更有效率。当没有where语句的时候直接select count(*) from world.city这样会更快，因为mysql总是知道表的行数。

2. 避免使用不兼容的数据类型。

例如float和int、char和varchar、binary和varbinary是不兼容的。数据类型的不兼容可能使优化器无法执行一些本来可以进行的优化操作。在程序中，保证在实现功能的基础上，尽量减少对数据库的访问次数；通过搜索参数，尽量减少对表的访问行数,最小化结果集，从而减轻网络负担；能够分开的操作尽量分开处理，提高每次的响应速度；在数据窗口使用SQL时，尽量把使用的索引放在选择的首列；算法的结构尽量简单；在查询时，不要过多地使用通配符如 SELECT * FROM T1语句，要用到几列就选择几列如：SELECT COL1,COL2 FROM T1；在可能的情况下尽量限制尽量结果集行数如：SELECT TOP 300 COL1,COL2,COL3 FROM T1,因为某些情况下用户是不需要那么多的数据的。不要在应用中使用数据库游标，游标是非常有用的工具，但比使用常规的、面向集的SQL语句需要更大的开销；按照特定顺序提取数据的查找。

3. 索引字段上进行运算会使索引失效。

尽量避免在WHERE子句中对字段进行函数或表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如： SELECT * FROM T1 WHERE F1/2=100 应改为: SELECT * FROM T1 WHERE F1=100*2

4. 避免使用!=或＜＞、IS NULL或IS NOT NULL、IN ，NOT IN等这样的操作符.

因为这会使系统无法使用索引,而只能直接搜索表中的数据。例如: SELECT id FROM employee WHERE id != “B%” 优化器将无法通过索引来确定将要命中的行数,因此需要搜索该表的所有行。在in语句中能用exists语句代替的就用exists.

5. 尽量使用数字型字段.

一部分开发人员和数据库管理人员喜欢把包含数值信息的字段设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接回逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。

6. 合理使用EXISTS,NOT EXISTS子句。如下所示：

1.SELECT SUM(T1.C1) FROM T1 WHERE (SELECT COUNT(*)FROM T2 WHERE T2.C2=T1.C2>0) 2.SELECT SUM(T1.C1) FROM T1WHERE EXISTS(SELECT * FROM T2 WHERE T2.C2=T1.C2) 两者产生相同的结果，但是后者的效率显然要高于前者。因为后者不会产生大量锁定的表扫描或是索引扫描。如果你想校验表里是否存在某条纪录，不要用count(*)那样效率很低，而且浪费服务器资源。可以用EXISTS代替。如： IF (SELECT COUNT(*) FROM table_name WHERE column_name = ‘xxx’)可以写成：IF EXISTS (SELECT * FROM table_name WHERE column_name = ‘xxx’)

7. 能够用BETWEEN的就不要用IN

8. 能够用DISTINCT的就不用GROUP BY

9. 尽量不要用SELECT INTO语句。SELECT INTO 语句会导致表锁定，阻止其他用户访问该表。

10. 必要时强制查询优化器使用某个索引

SELECT * FROM T1 WHERE nextprocess = 1 AND processid IN (8,32,45) 改成： SELECT * FROM T1 (INDEX = IX_ProcessID) WHERE nextprocess = 1 AND processid IN (8,32,45) 则查询优化器将会强行利用索引IX_ProcessID 执行查询。

11. 消除对大型表行数据的顺序存取

尽管在所有的检查列上都有索引，但某些形式的WHERE子句强迫优化器使用顺序存取。如： SELECT * FROM orders WHERE (customer_num=104 AND order_num>1001) OR order_num=1008 解决办法可以使用并集来避免顺序存取： SELECT * FROM orders WHERE customer_num=104 AND order_num>1001 UNION SELECT * FROM orders WHERE order_num=1008 这样就能利用索引路径处理查询。【jacking 数据结果集很多，但查询条件限定后结果集不大的情况下，后面的语句快】

12. 尽量避免在索引过的字符数据中，使用非打头字母搜索。这也使得引擎无法利用索引。

见如下例子： SELECT * FROM T1 WHERE NAME LIKE ‘%L%’ SELECT * FROM T1 WHERE SUBSTING(NAME,2,1)=’L’ SELECT * FROM T1 WHERE NAME LIKE ‘L%’ 即使NAME字段建有索引，前两个查询依然无法利用索引完成加快操作，引擎不得不对全表所有数据逐条操作来完成任务。而第三个查询能够使用索引来加快操作，不要习惯性的使用 ‘%L%’这种方式(会导致全表扫描)，如果可以使用`L%’相对来说更好;

13. 虽然UPDATE、DELETE语句的写法基本固定，但是还是对UPDATE语句给点建议：

a) 尽量不要修改主键字段。 b) 当修改VARCHAR型字段时，尽量使用相同长度内容的值代替。 c) 尽量最小化对于含有UPDATE触发器的表的UPDATE操作。 d) 避免UPDATE将要复制到其他数据库的列。 e) 避免UPDATE建有很多索引的列。 f) 避免UPDATE在WHERE子句条件中的列。

14. 能用UNION ALL就不要用UNION

UNION ALL不执行SELECT DISTINCT函数，这样就会减少很多不必要的资源在跨多个不同的数据库时使用UNION是一个有趣的优化方法，UNION从两个互不关联的表中返回数据，这就意味着不会出现重复的行，同时也必须对数据进行排序，我们知道排序是非常耗费资源的，特别是对大表的排序。 UNION ALL可以大大加快速度，如果你已经知道你的数据不会包括重复行，或者你不在乎是否会出现重复的行，在这两种情况下使用UNION ALL更适合。此外，还可以在应用程序逻辑中采用某些方法避免出现重复的行，这样UNION ALL和UNION返回的结果都是一样的，但UNION ALL不会进行排序。

15. 字段数据类型优化：

a. 避免使用NULL类型：NULL对于大多数数据库都需要特殊处理，MySQL也不例外，它需要更多的代码，更多的检查和特殊的索引逻辑，有些开发人员完全没有意识到，创建表时NULL是默认值，但大多数时候应该使用NOT NULL，或者使用一个特殊的值，如0，-1作为默认值。 b. 尽可能使用更小的字段，MySQL从磁盘读取数据后是存储到内存中的，然后使用cpu周期和磁盘I/O读取它，这意味着越小的数据类型占用的空间越小，从磁盘读或打包到内存的效率都更好，但也不要太过执着减小数据类型，要是以后应用程序发生什么变化就没有空间了。修改表将需要重构，间接地可能引起代码的改变，这是很头疼的问题，因此需要找到一个平衡点。 c. 优先使用定长型

16. 关于大数据量limit分布的优化见下面链接（当偏移量特别大时，limit效率会非常低）：

http://ariyue.iteye.com/blog/553541 附上一个提高limit效率的简单技巧，在覆盖索引(覆盖索引用通俗的话讲就是在select的时候只用去读取索引而取得数据，无需进行二次select相关表)上进行偏移，而不是对全行数据进行偏移。可以将从覆盖索引上提取出来的数据和全行数据进行联接，然后取得需要的列，会更有效率，看看下面的查询： mysql> select film_id, description from sakila.film order by title limit 50, 5; 如果表非常大，这个查询最好写成下面的样子： mysql> select film.film_id, film.description from sakila.film inner join(select film_id from sakila.film order by title liimit 50,5) as film usinig(film_id);

17. 程序中如果一次性对同一个表插入多条数据，比如以下语句：

insert into person(name,age) values(‘xboy’, 14); insert into person(name,age) values(‘xgirl’, 15); insert into person(name,age) values(‘nia’, 19); 把它拼成一条语句执行效率会更高. insert into person(name,age) values(‘xboy’, 14), (‘xgirl’, 15),(‘nia’, 19);

18. 不要在选择的栏位上放置索引，这是无意义的。应该在条件选择的语句上合理的放置索引，比如where，order by。

SELECT id,title,content,cat_id FROM article WHERE cat_id = 1;

上面这个语句，你在id/title/content上放置索引是毫无意义的，对这个语句没有任何优化作用。但是如果你在外键cat_id上放置一个索引，那作用就相当大了。

19. ORDER BY语句的MySQL优化： a. ORDER BY + LIMIT组合的索引优化。如果一个SQL语句形如：

SELECT [column1],[column2],…. FROM [TABLE] ORDER BY [sort] LIMIT [offset],[LIMIT];

这个SQL语句优化比较简单，在[sort]这个栏位上建立索引即可。

b. WHERE + ORDER BY + LIMIT组合的索引优化，形如：

SELECT [column1],[column2],…. FROM [TABLE] WHERE [columnX] = [VALUE] ORDER BY [sort] LIMIT [offset],[LIMIT];

这个语句，如果你仍然采用第一个例子中建立索引的方法，虽然可以用到索引，但是效率不高。更高效的方法是建立一个联合索引(columnX,sort)

c. WHERE + IN + ORDER BY + LIMIT组合的索引优化，形如：

SELECT [column1],[column2],…. FROM [TABLE] WHERE [columnX] IN ([value1],[value2],…) ORDER BY [sort] LIMIT [offset],[LIMIT];

这个语句如果你采用第二个例子中建立索引的方法，会得不到预期的效果（仅在[sort]上是using index，WHERE那里是using where;using filesort），理由是这里对应columnX的值对应多个。目前哥还木有找到比较优秀的办法，等待高手指教。

d.WHERE+ORDER BY多个栏位+LIMIT，比如:

SELECT * FROM [table] WHERE uid=1 ORDER x,y LIMIT 0,10;

对于这个语句，大家可能是加一个这样的索引:(x,y,uid)。但实际上更好的效果是(uid,x,y)。这是由MySQL处理排序的机制造成的。

38、MySQL查询结果的条数

COUNT(*) 函数返回表中的记录数：

SELECT COUNT(*) FROM user where username = '2';

count(*) 跟 count(1) 的结果一样，都包括对NULL的统计，而count(column) 是不包括NULL的统计

39、MySQL查询指定条数

SELECT * FROM user order by id limit 0,2;

从第0行开始，查询2条数据

Desc 倒序

Ajax的同步异步

jquery的async:false,这个属性
默认是true：异步，false：同步。

$.ajax({

type: "post",

url: "path",

cache:false,

async:false,

dataType: ($.browser.msie) ? "text" : "xml",

success: function(xmlobj){

}

});

40、什么是B/S架构？什么是C/S架构

B/S(Browser/Server)，浏览器/服务器程序

C/S(Client/Server)，客户端/服务端，桌面应用程序

41、什么是JVM？java虚拟机包括什么？

JVM：java虚拟机，运用硬件或软件手段实现的虚拟的计算机，Java虚拟机包括：寄存器，堆栈，处理器

42、什么是JDK？什么是JRE?

JDK：java development kit：java开发工具包，是开发人员所需要安装的环境

JRE：java runtime environment：java运行环境，java程序运行所需要安装的环境

43、Java的数据结构有那些？

线性表（ArrayList）

链表（LinkedList）

栈（Stack）

队列（Queue）

图（Map）

树（Tree）

44、Java中有几种数据类型、拆装箱

基本数据类型 : 整形：byte,short,int(Integer),long

浮点型：float,double

字符型：char(Character)

布尔型：boolean

引用数据类型 : String

45、什么是拆装箱？

拆箱：把包装类型转成基本数据类型

装箱：把基本数据类型转成包装类型

46、servlet的三大作用域对象和jsp的九大内置对象及其四大作用域对象

servlet的三大作用域对象：

request（HttpServletRequest）

session（HttpSession）：

application（ServletContext）：tomcat启动时创建，tomcat关闭时销毁，整个web的生命周期只有一个

括号内为其对应的类

jsp的九大内置对象：

pageContext（pageContext）也包含了另外八大对象的引用

request（HttpServletRequest）

session（HttpSession）

application（ServletContext）

response（HttpResponse）

config（ServletConfig）

out（JspWriter）

page（Object）

exception（Throwable）

括号内为其对应的类，这些对象都是存在于jsp中的，可以直接使用

jsp的四大作用域对象：

pageContext（pageContext）

request（HttpServletRequest）

session（HttpSession）

application（ServletContext）

括号内为其对应的类

47、Object类常用方法有那些？

Equals

Hashcode

toString

wait

notify

clone

getClass

48、Java中是值传递引用传递？

理论上说，java都是引用传递，对于基本数据类型，传递是值的副本，而不是值本身。对于对象类型，传递是对象的引用，当在一个方法操作操作参数的时候，其实操作的是引用所指向的对象。

49、多态

父类引用指向子类对象

50、JDBC操作的步骤

加载数据库驱动类

打开数据库连接

执行sql语句

处理返回结果

关闭资源

本人今年大三出来实习，在上海面试Java工程师(实习)

总结了一些面试问题（2018年6月20日--2018年7月1日）

期间面试了6家公司，只拿到了两家公司的Offer，只能说，还是太天真了。

技术面试的话，相对就好说一点，会就是会，直接说（如果会，可以尽量多说点），不会的话，就是不会。。。

最开始的一家公司，我还是很想去的，但是，奈何第一次面试，紧张不说，感觉自己可能有点被“套路”的感觉。

后来发现，还是少一点真诚，多一点emmm吧。。

废话不多说了，我面试时碰到的问题：

总结的方面就是：

Java基础（不用多说）、数据结构（集合、链表...）、Spring（机制和常用注解）、SQL的优化、Mybatis（注解、事务）......

1、Spring注解扫描开启配置

2、Spring control 常用注解

3、MySQL 的左连接、右连接、内连接的区别

4、通过Collections 比较List

5、Servlet 生命周期

6、HTTP协议

7、MySQL索引(单个索引和联合索引的区别)

8、TCP、UDP(传输层) IP(网络层)

9、TCP/IP协议

10、在 TCP/IP 内部

11、说一下什么是Http协议？

12、什么是Http协议无状态协议？怎么解决Http协议无状态协议？（曾经去某创业公司问到）

13、说一下Http协议中302状态(阿里经常问)

14、Http协议有什么组成？

15、Http协议中有那些请求方式？

16、Http协议中Http1.0与1.1区别？

17、get与post请求区别？（初级程序员必备问题）

18、常见Http协议状态？

19、Http协议首部字段？

20、Http与Https优缺点？

21、Http优化

22、Http协议有那些特征？

23、基于注解的声明式事务管理配置spring-servlet.xml

24、数组、链表的内存问题

25、数组的优点

26、数组的缺点

27、链表的优点

28、链表的缺点

29、依赖注入(Ioc)和控制反转(DI)

30、Springmvc运行步骤

31、集合

32、ＭyBatis 中#与$的区别

33、HashMap的工作原理以及存取方法过程

34、synchronized 与 Lock区别

35、二叉树遍历

36、MySQL数据库引擎

（1）InnoDB：

（2）MyIsam(了解)：

37、MySQL查询优化

38、MySQL查询结果的条数

39、MySQL查询指定条数

40、什么是B/S架构？什么是C/S架构

41、什么是JVM？java虚拟机包括什么？

42、什么是JDK？什么是JRE?

43、Java的数据结构有那些？

44、Java中有几种数据类型、拆装箱

45、什么是拆装箱？

46、servlet的三大作用域对象和jsp的九大内置对象及其四大作用域对象

47、Object类常用方法有那些？

48、Java中是值传递引用传递？

49、多态

50、JDBC操作的步骤

相关推荐

23、基于注解的声明式事务管理配置
spring-servlet.xml