传智播客2014年JavaEE学员真实企业面试题总结

下面是传智播客2014年0228班学员真实企业面试简答题目总结

【1】Spring的优点是？Spring的IOC怎么调用？
 
 Spring的优点：

  1.降低了各层之间的耦合性
  2.依赖注入和IoC使得JDBC操作简单化
  3.更加容易做单元测试
  4.能够有效地整合主流框架
  5.提供了无侵略性的mvc实现模式
  6.可以自由选择所需要的层
  7.开源免费

 Spring的IOC怎么调用

  //加载配置文件
  ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  //获取资源
  Person person = (Person) ctx.getBean("person");

【2】Struts2和SpringMVC的区别是？

 

扩展：springmvc工作流程
 ①servlet容器初始化一个request请求
 ②DispatcherServlet分发器负责发送请求到映射器.
 ③despatcherServlet把请求交给处理器映射Mapping，mapping来寻找需要执行的control
 ④处理器映射把请求分发给控制器Controler。
 ⑤Controler执行完毕后返回ModelAndView(视图解析器)
 ⑥把ModelAndView返回给dispatcherServlet核心分发器
 ⑦由于DespatcherServlet不参与具体的处理，所以把modelAndView交给视图解析器。
 ⑧视图解析器解析成一个真正的视图，再发给view然后response。

 

 

【3】请对Jsp的9大内置对象进行说明
 (1)request  
  HttpServletRequest请求对象
 (2)response 
  HttpServletResponse响应对象
 (3)application 
  ServletContext在整个应用范围内共享数据
 (4)session  
  HttpSession  
 (5)out  
  JspWriter用来输出
 (6)config  
  ServletConfig配置对象
 (7)page  
  this页面对象，代表当前jsp对象本身
 (8)pageContext    
  页面上下文对象，JSP四个域对象之一
 (9)exception    
  异常对象

 JSP注释
  <%-- 这就是注释 --%>

 java代码片段：
  声明：<%! ...%>
  表达式：<%=...%>
  语句：<%...%>

【4】请概述MVC的体系结构

 M:模型(Model),V:视图(View)C:控制Controller)。 MVC模式的目的就是实现Web系统的职能分工。Model层实现系统中的业务逻辑。 View层用于与用户的交互。 Controller层是Model与View之间沟通的桥梁，它可以分派用户的请求并选择恰当的视图以用于显示，同时它也可以解释用户的输入并将它们映射为模型层可执行的操作。

【5】JSP如何获取HTML表单中的数据？

 <%
  request.setCharacterEncoding("UTF-8");
  
  String name = request.getParameter("username");
  String pwd = request.getParameter("password");
  String[] hobby = request.getParameterValues("hobby");
 %>

【6】简述JDBC调用数据库的基本步骤

  //【(1)加载驱动】
  String driverClassName = "com.mysql.jdbc.Driver";
  Class.forName(driverClassName);

  String url = "jdbc:mysql://127.0.0.1:3306/erpdb";
  String userName = "root";
  String password = "root";

  
  Connection con = null;
  Statement stmt = null;
  ResultSet rs = null;
  try { 
   //【(2)创建链接】
   DriverManager.getConnection(url,userName,password);

   //【(3)获取Statement对象】
   stmt = con.createStatement();

   //【(4)执行SQL语句】
   String sql = "select * from user";
   rs = stmt.executeQuery(sql);

   //【(5)处理结果集】
   while(rs.next()) {
    String username = rs.getString(1);
    String password = rs.getString(2);
    System.out.println(username + ", " + password);
   }
  } catch(Exception e) {
   throw new RuntimeException(e);
  } finally {
   try {

    //【(6)关闭连接】
    if(rs != null) rs.close();
    if(stmt != null) stmt.close();
    if(con != null) con.close();
   } catch(SQLException e) {}
  }

【7】用Java访问Oracle数据库，取得记录输出到界面

 public void testOracle()
 {
     Connection con = null;// 创建一个数据库连接
     PreparedStatement pre = null;// 创建预编译语句对象
     ResultSet result = null;// 创建一个结果集对象
     try
     {
  Class.forName("oracle.jdbc.driver.OracleDriver");// 加载Oracle驱动程序
  System.out.println("开始尝试连接数据库！");

  String url = "jdbc:oracle:thin:@127.0.0.1:1521:ORCL";// 127.0.0.1是本机地址，ORCL是默认数据库名
  String user = "system";// 用户名,系统默认的账户名
  String password = "147";// 你安装时选设置的密码

  con = DriverManager.getConnection(url, user, password);// 获取连接
  System.out.println("连接成功！");
  String sql = "select * from student where name=?";// 预编译语句，“？”代表参数
  pre = con.prepareStatement(sql);// 实例化预编译语句
  pre.setString(1, "史艳军");// 设置参数，前面的1表示参数的索引，而不是表中列名的索引
  result = pre.executeQuery();// 执行查询，注意括号中不需要再加参数
  while (result.next())
      // 当结果集不为空时
      System.out.println("学号:" + result.getInt("id") + "姓名:"
       + result.getString("name"));
     }
     catch (Exception e)
     {
  e.printStackTrace();
     }
     finally
     {
  try
  {
      // 逐一将上面的几个对象关闭，因为不关闭的话会影响性能、并且占用资源
      // 注意关闭的顺序，最后使用的最先关闭
      if (result != null)
   result.close();
      if (pre != null)
   pre.close();
      if (con != null)
   con.close();
      System.out.println("数据库连接已关闭！");
  }
  catch (Exception e)
  {
      e.printStackTrace();
  }
     }
 }

【8】请简述Java中final、finally、finalize的区别

 （1）final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
 （2）finally是异常处理语句结构的一部分，表示总是执行。
 （3）finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

【9】请大概描述一下Vector、LinkedList和ArrayList的区别

 ArrayList： 底层是数组实现, 增删慢, 查找快 
 LinkedList： 底层是链表实现, 增删快, 查找慢
 Vector： 底层是数组实现, 原理和ArrayList相同, 但线程安全

 【扩展：关于集合的知识总结】

  Collection：
   |--List
   |--Set

  List：
  1，是有序的,存入的顺序和取出的顺序一致。
  2，元素是有索引的。
  3，元素可以重复。

  了解List接口的特有方法，注意：这些特有方法都是围绕着角标定义的。
  1,add(index,element);

  2,remove(index):

  3,set(index,element);

  4,get(index);

  List接口支持，增删改查操作。

  List
   |--Vector:数组结构的,是同步的。被ArrayList替代，因为效率低。

   |--ArrayList:数据结构是数组结构，是不同步的。查询速度很快。
    
   |--LinkedList:数据结构是链表结构，是不同步的。增删速度很快。
   

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

  Set:元素不可以重复的。不保证顺序。
   Set中的方法和Collection中的一致。
   
   Set:
    |--HashSet:哈希表结构。不同步的。查询速度快。
    |--TreeSet:它可以对Set集合中的元素进行排序。数据结构是二叉树。不同步的。

     TreeSet排序有两种方式：

      第一种：
       让元素自身具备比较性。让元素对象实现Comparable接口，覆盖compareTo方法。但是，需求中，需要元素的非自然排序时，或者元素本身就不具备自然排序时，怎么办？

      第二种：
       让容器具备比较性。其实就是定义一个比较器，就是实现Comparator接口，覆盖compare方法。
       
    
  List集合判断元素是否相同使用的equals方法。
  HashSet集合判断元素相同，依据 hashCode和equals方法。，
  TreeSet集合判断元素形同，依据compareTo或者compare方法的return 0;

  集合名称规律：
   前缀名：数据结构名。
   后缀名：所属集合的名字。

  ArrayList：数组结构，所属于List。想到索引，查询快。
  LinkedList：链表结构，所属于List。想到增删快。
  HashSet：哈希表结构，所属于Set,想到唯一性，查询速度快。
  TreeSet：二叉树结构，所属于Set，想到唯一性，而且排序。
    排序两种，自然排序Comaprable，compareTo比较器排序。Comparator.compare

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

  Map集合：
   特点：
   1，存储的都是键值对。
   2，要保证键的唯一性。
   
   存的方式：put(key,value);
   取的方式：keySet(),entrySet(),values();原理：就是将map集合转成set集合或者Collection集合，再通过Iterator取出。
   
   Map
    |--Hashtable:哈希表结构，同步的。null不可以作为键和值。
    |--HashMap:哈希表结构，不同步的。替代了Hashtable。允许null作为键和值。
    |--TreeMap:二叉树结构，不同步的，可以对map集合中的键进行排序。

 

【泛型】
 泛型：
 1，JDK1.5版本出现的新特性，安全机制。
 2，泛型将运行时期的问题转移到了编译时期。
 3，避免了强制转换的麻烦。
 4，泛型技术是用于编译时期的技术。

 泛型的体现：
 <>  这就是用于定义类型参数的符号。
 泛型可以简单的理解为，接收具体的元素类型。

 对源码进行编译时，通过泛型进行类型的检查。
 如果类型没有问题，则将源码编译成class文件。
 注意，class文件中是不带有泛型信息的。这种情况称之为泛型擦除。

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

【10】StringBuilder和StringBuffer与String的区别

 StringBuilder和StringBuffeer是可变字符序列
 String是不变得,一但被初始化,就不能改变
  
 扩展：StringBuilder和StringBuffer的区别
  StringBuilder是线程不安全的,所以效率比较高,1.5版本出现
  StringBuffer是线程安全的,效率相对较低,1.0版本出现的

【11】请说明数据库中为什么要设置主键和外键？什么是事务处理？
 主键：表中一行数据的唯一标识
 特点：主键不能为null、也不也能重复

 外键：是另一张表的主键，主键和外键是构成表与表关联的唯一途径！
 特点：
   1. 外键可以重复，但外键必须是另一个表的主键！外键可以为null
   2. 一个表可以有多个外键！外键和主键用来维护表与表之间的关系！
【12】作用域private、friendly、protected、public的区别

 public,protected,friendly,private的访问权限如下：

    关键字 当前类 包内 子孙类 包外
    public √ √ √ √
    protected √ √ √ ×
    friendly √ √ × ×
    private √ × × ×

    不写时默认为friendly
    不使用关键字默认为包内使用。

【13】怎样把一个int类型的变量转换成一个字符串，又如何把字符串转换成int？

 【int类型禅城转成字符串有3种方法】

  （1）String s = String.valueOf(i);
  （2） String s = Integer.toString(i);
  （3） String s = "" + i;

 【把字符串转成int类型】

  try
  {
     Integer.parseInt(String s)
  }
  catch(NumberFormatException NFE)
  {
     System.out.println("格式错误");
  }
  
【14】Error和Exception的区别
 Error ：表示由JVM所侦测到的无法预期的错误，这是属于JVM层次的严重错误 ，导致 JVM 无法继续执行，因此，这是不可捕捉到的，无法采取任何恢复的操作，只能显示错误信息。

【15】抽象类和接口的区别

 （1）一个类可以有多个接口 只能有继承一个父类抽象类可以有构造方法，接口中不能有构造方法。
 （2）抽象类中可以有普通成员变量，接口中没有普通成员变量接口里边全部方法都必须是abstract的
 （3）抽象类的可以有实现了的方法，抽象类中的抽象方法的访问类型可以是public，protected，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型
 （4）抽象类中可以包含静态方法，接口中不能包含静态方法
 （5）抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

【16】常见的web服务器有那些？
 （1）BEA公司的WebLogic
 （2）IBM公司的WebSphere
 （3）Oracle9i
 （4）jBoss
 （5）Tomcat

【17】HashMap和Hashtable的区别
 HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，
 主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。

【18】请写一种单例模式

 （1）懒汉式（面试时用）
 public class Student {
  
  //私有构造方法
  private Student (){}

  //自己不创建对象
  private static Student s = null;

  //通过一个公共的方式访问
  public synchronized static Student getStudent(){
   if(s == null){
    s = new Student();
   }
   return s;
  }
 }

 （2）饿汉式（开发时用）
 public class Student {

  //私有构造方法
  private Student(){}

  //自己创建一个对象
  private static Student s = new Student();

  //提供公共的访问方式
  public static Student getStudent(){
   return s;
  }
 }

 

【19】事务的特性

 事物的特性
  （1）原子性：事务中所有操作是不可再分割的原子单位。事务中所有操作要么全部执行成功，要么全部执行失败。
  （2）一致性：事务执行后，数据库状态与其它业务规则保持一致。如转账业务，无论事务执行成功与否，参与转账的两个账号余额之和应该是不变的。
  （3）隔离性：隔离性是指在并发操作中，不同事务之间应该隔离开来，使每个并发中的事务不会相互干扰。
  （4）持久性：一旦事务提交成功，事务中所有的数据操作都必须被持久化到数据库中，即使提交事务后，数据库马上崩溃，在数据库重启时，也必须能保证通过某种机制恢复数据。

 事务隔离级别

  （1）脏读：读到未提交
  （2）不可重复读：两次读取不一致，读取到另一事务修改的记录
  （3）幻读：两次读取不一致，读取到另一事务插入的记录

 四大隔离级别
  （1）SERIALIZABLE（串行化）：对同一数据的访问是串行的，即非并发的，所以不会出现任何并发问题。易出现死锁，效率太低！不可用！
  （2）REPEATABLE READ（可重复读）：防止了脏读、不可重复读，但没有防止幻读
  （3）READ COMMITTED（读已提交）：防止了脏读，但没有防止不可重复读，以及幻读
  （4）READ UNCOMMITTED（读未提交）：可能出现所有并发问题，效率最高，但不可用！

【20】数据库中左外连接和右外连接有什么区别？

 

【21】简述你所理解的sql语句优化方案

 

【22】写出Servlet的生命周期函数

 Servlet接口中一共有5个方法，其中有3个生命周期方法;
  （1）在Servlet初次被访问时，Web容器会实例化一个servlet，并调用init方法对其进行初始化，该方法只被调用一次;
  （2）在Servlet每次被请求时，都会调用Service方法处理请求，该方法会被调用0到多次;
  （3）在Servlet被销毁之前会调用destroy方法，该方法也只被调用一次;

【23】写出Get和Post的区别
 GET请求
  请求参数会在浏览器的地址栏中显示，所以不安全
  请求参数长度限制长度在1K之内
  GET请求没有请求体，无法通过request.setCharacterEncoding()来设置参数的编码
 POST请求
  请求参数不会显示浏览器的地址栏，相对安全
  请求参数长度没有限制

【24】写出请求转发和重定向的区别
 （1）请求转发是一个请求，而重定向是两个请求
 （2）请求转发，是使用RequestDispatcher来完成，重定向使用response对象来完成
 （3）请求转发的路径都是服务器端路径，而重定向是客户端路径，需要给出应用名称
 （4）请求转发在浏览器地址栏中的地址是第一个Servlet的路径，而重定向在地址栏中的地址是第二个请求的Servlet的路径
 （5）请求转发中的两个Servlet是可以共享request数据的，而重定向因为是两个请求，所以不能共享request数据
 （6）请求转发只能转发到本应用的其他Servlet，而重定向可以重定向到其他应用中。

 【扩展】请求包含和请求转发的区别
   （1）请求包含和请求转发都是在一个请求中，访问两个Servlet。
   （2）请求包含和请求转发都是有一个Servlet去调用执行另一个Servlet
   （3）请求包含和请求转发都可以共享request中的数据，因为都是一个请求。

【25】JSP和Servlet的区别与联系
 （1）JSP是一种特殊的Servlet，JSP第一次运行的时候会被容器编译成servlet，然后执行得到结果后，反馈给客户端;
 （2）servlet相当于一个控制层再去调用相应的javabean处理数据,最后把结果返回给jsp;
 （3）servlet主要用于转向，将请求转向到相应的jsp页面;
 （4）jsp更多的是进行页面显示，Servlet更多的是处理业务，即jsp是页面，servlet是实现jsp的方法;

【26】谈谈你对SSH框架的理解

 SSH是Struts、Spring、Hibernate，Struts进行流程控制，Spring进行业务流转，Hibernate进行数据库操作的封装。

 Struts是一个在JSP Model2基础上实现的MVC框架，主要分为模型(Model)、视图(Viewer)和控制器(Controller)三部分，其主要的设计理念是通过控制器将表现逻辑和业务逻辑解耦，以提高系统的可维护性、可扩展性和可重用性

 Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架

 Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库
 
 【SSH基本业务流程】

  在表示层中，首先通过JSP页面实现交互界面，负责传送请求(Request)和接收响应(Response)，然后Struts根据配置文件(struts-config.xml)将ActionServlet接收到的Request委派给相应的Action处理。在业务层中，管理服务组件的Spring IoC容器负责向Action提供业务模型(Model)组件和该组件的协作对象数据处理(DAO)组件完成业务逻辑，并提供事务处理、缓冲池等容器组件以提升系统性能和保证数据的完整性。而在持久层中，则依赖于Hibernate的对象化映射和数据库交互，处理DAO组件请求的数据，并返回处理结果。

 【自己的观点】

  采用上述开发模型，不仅实现了视图、控制器与模型的彻底分离，而且还实现了业务逻辑层与持久层的分离。这样无论前端如何变化，模型层只需很少的改动，并且数据库的变化也不会对前端有所影响，大大提高了系统的可复用性。而且由于不同层之间耦合度小，有利于团队成员并行工作，大大提高了开发效率。

【27】重载与重写的区别
 重写：子类重写父类的方法。子类的方法名，参数列表，返回值与父类一样， 修饰符要比父类范围大。
 重载：在本类中重载，子类的方法名，参数，修饰符要一致

【28】用自己的语言描述Spring和Hibernate的优点和缺点，并对描述的缺点给出适当的解决方案
 【Spring优点】
 【Spring缺点】
 【Hibernate工作原理】
  1.读取并解析配置文件。
  2.读取并解析映射信息，创建SessionFactory
  3.打开Session
  4.创建事物Transaction
  5.持久化操作
  6.提交事务
  7.关闭Session
  8.关闭SessionFactory
 【Hibernate优点】
  优秀的ORM实现，无需编写的SQL语句，只需要操作相应的对象即可
  它支持各种关系数据库，从一对一到多对多的各种复杂关系。
  缓存机制，提供一级缓存和二级缓存
  使用Hibernate，移植性好
 【Hibernate缺点】

 

【29】请问cookie和session分别是什么？

 【cookie】
  Cookie是HTTP协议的规范之一，是服务器保存在客户端的数据，Cookie就是一个键值对，其大小及数量都是有限制的
  向客户端保存Cookie的方式为：
   Cookie cookie = new Cookie("test", "ABCDEFG");
   response.addCookie(cookie);

  从客户端获取Cookie的方式为：
   request.getCookies();
 【session】
  session是服务器端对象，用来表示http会话。
  session是域对象，有setAttribute()和getAttribute()等方法
  服务器会为每个会话创建一个session对象，所以session中的数据可供当前会话中所有servlet共享。

 【cookie和session的关系】
  session依赖Cookie，这是因为服务器需要把sessionId保存到客户端。如果用户的浏览器关闭了Cookie功能，那么session不能使用了！

【30】请列举你知道的HTTP状态码，并说明其含义

 HTTP 400 – 请求无效
  HTTP 401.1 – 未授权：登录失败
  HTTP 401.2 – 未授权：服务器配置问题导致登录失败
  HTTP 401.3 – ACL 禁止访问资源
  HTTP 401.4 – 未授权：授权被筛选器拒绝
  HTTP 401.5 – 未授权：ISAPI 或 CGI 授权失败

 HTTP 403 – 禁止访问
  HTTP 403 – 对 Internet 服务管理器 的访问仅限于 Localhost
  HTTP 403.1 禁止访问：禁止可执行访问
  HTTP 403.2 – 禁止访问：禁止读访问
  HTTP 403.3 – 禁止访问：禁止写访问
  HTTP 403.4 – 禁止访问：要求 SSL
  HTTP 403.5 – 禁止访问：要求 SSL 128
  HTTP 403.6 – 禁止访问：IP 地址被拒绝
  HTTP 403.7 – 禁止访问：要求客户证书
  HTTP 403.8 – 禁止访问：禁止站点访问
  HTTP 403.9 – 禁止访问：连接的用户过多
  HTTP 403.10 – 禁止访问：配置无效
  HTTP 403.11 – 禁止访问：密码更改
  HTTP 403.12 – 禁止访问：映射器拒绝访问
  HTTP 403.13 – 禁止访问：客户证书已被吊销
  HTTP 403.15 – 禁止访问：客户访问许可过多
  HTTP 403.16 – 禁止访问：客户证书不可信或者无效
  HTTP 403.17 – 禁止访问：客户证书已经到期或者尚未生效 HTTP 404.1 -

 无法找到 Web 站点
 HTTP 404- 无法找到文件
  HTTP 405 – 资源被禁止
  HTTP 406 – 无法接受
  HTTP 407 – 要求代理身份验证
  HTTP 410 – 永远不可用
  HTTP 412 – 先决条件失败
  HTTP 414 – 请求 – URI 太长

 HTTP 500 – 内部服务器错误
  HTTP 500.100 – 内部服务器错误 – ASP 错误
  HTTP 500-11 服务器关闭
  HTTP 500-12 应用程序重新启动
  HTTP 500-13 – 服务器太忙
  HTTP 500-14 – 应用程序无效
  HTTP 500-15 – 不允许请求 global.asa
  Error 501 – 未实现
  HTTP 502 – 网关错误

【31】请问TCP/IP一共有几层？分别是什么？

 答：一共有4层，自上而下为：1.应用层2.传输层3.网际层4.主机至网络层

 【扩展】：OSI有7层
 1.层物理层2.层数据链路层3.层网络层4.层传输层5.会话层6.表示层7.应用层

 
【32】多线程有哪几种实现方法？同步有哪几种实现方法？

 多线程有两种实现方法：
  （1）继承Thread类
  （2）实现Runnable接口

 同步的实现方面有两种：
  （1）synchronized,wait
  （2）notify

33、Java中会存在内存泄露吗？请简单描述

【34】Java编程,打印昨天的当前时刻

 public class YesterdayCurrent{
   public void main(String[] args){
     Calendar cal = Calendar.getInstance();
     cal.add(Calendar.DATE, -1);
     System.out.println(cal.getTime());
   }
 }

35、数据库中的varchar和char类型有什么区别？
36、什么是闭包？能否写一个实例？
37、请用javascript画一个表格里面显示openunion
38、请写一个javascript函数，用正则表达式去掉字符串首位的空格
39、请写一个函数，不调用Java内部函数实现大小写转换
40、请写一个函数，遍历一个目录里的所有文件和子目录
41、简述Spring的工作原理和为什么要用Spring
42、Spring配置文件中的Bean中的id和name的区别
43、Spring3中注释注入代码：@ Resource和@ Autowired的区别

【44】数据库如何提高查询速度
 (1)jdbc setFetchSize()
 (2)数据库：索引
 (3)把大表可以拆分成多个小表
 (4)dba 表进行分区
 (5)提高cpu,内存性能

45、写一个方法，实现字符串的反转，如：输入abc，输出cba
46、如何通过今天得到昨天0:00和后天的23:59？
47、描述你最擅长的设计模式

【48】谈谈hibernate和Mybatis的区别？

 答：Hibernate和Mybatis都是orm对象关系映射框架，都是用于将数据持久化的框架技术。

 Hiberante较深度的封装了jdbc，对开发者写sql的能力要求的不是那么的高，我们只要通过hql语句操作对象即可完成对数据持久化的操作了。

 另外hibernate可移植性好，如一个项目开始使用的是mysql数据库，但是随着业务的发展，现mysql数据库已经无法满足当前的绣球了，现在决定使用Oracle数据库，虽然sql标准定义的数据库间的sql语句差距不大，但是不同的数据库sql标准还是有差距的，那么我们手动修改起来会存在很大的困难，使用hibernate只需改变一下数据库方言即可搞定。用hibernate框架，数据库的移植变的非常方便。

 但是hibernate也存在着诸多的不足，比如在实际开发过程中会生成很多不必要的sql语句耗费程序资源，优化起来也不是很方便，且对存储过程支持的也不够太强大。但是针对于hibernate它也提供了一些优化策略，比如说懒加载、缓存、策略模式等都是针对于它的优化方案。

 Mybatis 也是对jdbc的封装，但是封装的没有hibernate那么深，我们可以再配置文件中写sql语句，可以根据需求定制sql语句，数据优化起来较hibernate容易很多。

 Mybatis要求程序员写sql的能力要相对使用hibernate的开发人员要高的多，且可移植性也不是很好。

 涉及到大数据的系统使用Mybatis比较好，因为优化较方便。涉及的数据量不是很大且对优化没有那么高，可以使用hibernate

【49】线程的生命周期是什么？

 线程定义：进程的执行单元，执行路径
 线程的生命周期：新建-就绪-运行-死亡
  在线程执行的过程中，有些其他的情况，会导致线程阻塞。

 画图说明（线程的生命周期图）：
  （1）新建--创建线程对象
  （2）就绪--调用start()方法进入就绪状态，具有执行资格，但不具备执行权。
  （3）运行--具有执行资格，也具备执行权。
   （4）阻塞--在运行过程中，如果调用sleep()或wait()，则线程会进入阻塞状态，不具有执行资格，也不具有执行权。
   （5）就绪--在阻塞状态时，如果sleep(时间)时间到了（醒了），或者被notify()唤醒，线程会重新回到就绪状态。
  （6）死亡--在运行状态时，run()结束或调用stop()方法线程就会结束，线程对象就变成垃圾。

【50】PreparedStatement(ps) 与Statement(Stat)的区别：

  作用  性能 安全 执行查询 jdbc事物

 ps: 预编译、发送SQL 高 高 char 需要trim 比较麻烦

 stat: 发送SQL  低 低 系统自动trim 简单（建议）

 PreparedStatement继承Statement

【51】Java有几种链接数据库的方式？

  有三种连接模式：1、OCI :APP通过第三方，再与数据库连接
    2、ODBC：通过桥  （微软公司）
    3、直接连接

【52】javaScript如何实现java中trim()的方法?用正则表达式

 function ltrim(str){
 return str.replace(/^\s+/g,"");
 }
 function rtrim(str){
    return str.replace(/^\s+$/g,"");
 }
 function trim(str){
  return str.replace(/^/s+|\s+$/g,"");
 }

【53】为什么很多程序用java写的？
 java 不挑平台，很多应用程序慢是因为数据库慢。

【54】DOM和SAX解析的区别：
 dom解析的优点是对文档增删改比较方便，只适合解析小型文档，缺点是占用内存比较大
 sax解析的优点是占用内存少，解析速度快，适合对大型的XML的解析，缺点是只适合做文档的读取，不适合做文档增删改。

【55】Mysql、Oracle分页查询

 【mysql的分页查询】
  mysql的分页查询是最简单的，借助关键字limit即可实现查询，查询语句通式：

  /*
   * sql:可以是单表的查询语句，也可以是多表的联合查询语句
   * firstIndex:其实的索引
   * pageSize:每页显示的记录数
   */

  select o.* from (sql) o limit firstIndex,pageSize

 【oracle分页查询】

     接下来重点说说oracle的分页查询，oracle的分页查询方法相对来说要多点，ROWNUM、row_number(),今天主要将两种效率稍好的分页查询语句。

     ①ROWNUM查询分页通式：

  /*
   * firstIndex:起始索引
   * pageSize:每页显示的数量* sql:可以是简单的单表查询语句，也可以是复杂的多表联合查询语句
   */
  
  select * from(select a.*,ROWNUM rn from(sql) a where ROWNUM<=(firstIndex+pageSize)) where rn>firstIndex

 

     ②row_number()解析函数分页查询通式：

   /*
    * firstIndex:起始索引 * pageSize:每页显示的数量
    * orderColumn:排序的字段名
    * sql:可以是简单的单表查询语句，也可以是复杂的多表联合查询语句
    */
   
  select * from(select * from(select t.*,row_number() over(order by orderColumn) as rownumber from(sql) t) p where p.rownumber>firstIndex) where rownum<=pageSize

【56】&和&&的区别
 &是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）。

【57】列举几个常见的运行时异常（RuntimeException）

 ClassCastException
 IllegalStateException
 IndexOutOfBoundsException
 NoSuchElementException
 NullPointerException
 SecurityException
 SystemException

【58】谈一谈Java中运行时异常（RuntimeException及其子类）类和一般异常类的区别和联系？

 （1）运行时异常类和一般异常类的祖先是Exception；
 （2）运行时异常类通常用于发现编程错误，而一般的异常类用于发现程序执行过程中出现的一些异常情况；
 （3）运行时异常类不用在throws子句中声明，而一般的异常类必须在throws子句中声明；
 （4）二者都可以使用catch捕获；

【59】给一个定长为100的定长数组随机添加1--100的数字，不能重复

 public class RandomDemo {

  public static void main(String[] args) {

   //定义一个长度为100的int型数组
   int[] arr = new int[100];

   //创建Random对象以获取随机数
   Random random = new Random();

   //定义一个变量，用来记录从1-100中取出的一个随机数字,并初始化为0
   int number = 0;

   //定义一个集合,用来存放有索引但不重复的Integer对象
   HashSet hashSet = new LinkedHashSet();

   while (hashSet.size() < 100) {

    //获得一个0-100(含0和100)之间的随机数
    number = random.nextInt(101);

    //如果number不等于0,就将随机数添加到集合中
    if (number != 0) {
     hashSet.add(number);
    }
   }

   System.out.println("集合长度为：" + hashSet.size());
   System.out.println("集合元素为：" + hashSet);
   
   //定义一个Integer类型的数组,为了将集合转换成int类型数组
   Integer[] listArr = new Integer[100];

   //将集合转成数组
   hashSet.toArray(listArr);

   //将Integer数组转成int类型数组
   for (int i = 0; i < arr.length; i++) {
    arr[i] = listArr[i];
   }
   
   System.out.println("数组的长度为：" + arr.length);
   System.out.println("数组元素为："+Arrays.toString(arr));
   
   //对数组进行排序
   Arrays.sort(arr);

   //打印排序后的数组元素
   System.out.println("打印后的数组元素为：" + Arrays.toString(arr));

  }
 }
【60】递归求5的阶乘

 //定义一个方法jc
 public static int jc(int n){
  if(n==1){
   return 1;
  }else{
   return n*jc(n-1);
  }
 }

【Hibernate相关的知识详细总结】

 hibernate工作原理

  1.读取并解析配置文件。
  2.读取并解析映射信息，创建SessionFactory
  3.打开Session
  4.创建事物Transaction
  5.持久化操作
  6.提交事务
  7.关闭Session
  8.关闭SessionFactory

  这个就是原理，不是流程。

  Hibernate是一个基于JDBC的主流持久层框架，一个优秀的ORM（对象关系映射）实现，对JDBC访问数据库的代码做了封装，很大程度上简化了DAO层的编码工作。

 原理：
  1.通过Configuration().configure();读取并解析hibernate.cfg.xml配置文件
  2.由hibernate.cfg.xml中的读取并解析映射信息
  3.通过config.buildSessionFactory();//创建SessionFactory
  4.sessionFactory.openSession();//打开Sesssion
  5.session.beginTransaction();//创建事务Transation
  6.persistent operate持久化操作
  7.session.getTransaction().commit();//提交事务
  8.关闭Session
  9.关闭SesstionFactory

 为什么要用Hibernate：

  1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
  2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作
  3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
  4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

 hibernate 简介：

  hibernate是一个开源框架，它是对象关联关系映射的框架，它对JDBC做了轻量级的封装，而我们java程序员可以使用面向对象的思想来操纵数据库。

  hibernate核心接口
   session：负责被持久化对象CRUD操作
   sessionFactory:负责初始化hibernate，创建session对象
   configuration:负责配置并启动hibernate，创建SessionFactory
   Transaction:负责事物相关的操作
   Query和Criteria接口：负责执行各种数据库查询

 
 Hibernate是如何延迟加载?

  1. 对于Hibernate get方法，Hibernate会确认一下该id对应的数据是否存在，首先在session缓存中查找，然后在二级缓存中查找，还没有就查询数据库，数据 库中没有就返回null。这个相对比较简单，也没有太大的争议。主要要说明的一点就是在这个版本(bibernate3.2以上)中get方法也会查找二级缓存！

  2. Hibernate load方法加载实体对象的时候，根据映射文件上类级别的lazy属性的配置(默认为true)，分情况讨论：

  (1)若为true,则首先在Session缓存中查找，看看该id对应的对象是否存在，不存在则使用延迟加载，返回实体的代理类对象(该代理类为实体类的子类，由CGLIB动态生成)。等到具体使用该对象(除获取OID以外)的时候，再查询二级缓存和数据库，若仍没发现符合条件的记录，则会抛出一个ObjectNotFoundException。

  (2)若为false,就跟Hibernateget方法查找顺序一样，只是最终若没发现符合条件的记录，则会抛出ObjectNotFoundException。

 Hibernate中get和load方法的区别:

  （1）get()采用立即加载方式,而load()采用延迟加载;
  （2）get()方法执行的时候,会立即向数据库发出查询语句,而load()方法返回的是一个代理(此代理中只有一个id属性)，只有等真正使用该对象属性的时候,才会发出sql语句            
  （3）如果数据库中没有对应的记录,get()方法返回的是null.而load()方法出现异常ObjectNotFoundException

 
 Hibernate核心API：

  Configration
  SessionFectory
  Session
  Transaction
  Query
  Criteria
  SQLQuery
 

 Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)

  类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、

 

 说下Hibernate的缓存机制：

  Hibernate缓存的作用：

   内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据

  Hibernate缓存分类：

   Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存

   Hibernate一级缓存又称为“Session的缓存”，它是内置的，意思就是说，只要你使用hibernate就必须使用session缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。在第一级缓存中，持久化类的每个实例都具有唯一的OID。

   Hibernate二级缓存又称为“SessionFactory的缓存”，由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。第二级缓存是可选的，是一个可配置的插件，在默认情况下，SessionFactory不会启用这个插件。

 什么样的数据适合存放到第二级缓存中？
 　　
  1 很少被修改的数据 　　
  2 不是很重要的数据，允许出现偶尔并发的数据 　　
  3 不会被并发访问的数据 　　
  4 常量数据 　　

 不适合存放到第二级缓存的数据？ 　　
  1经常被修改的数据 　　
  2 .绝对不允许出现并发访问的数据，如财务数据，绝对不允许出现并发 　　
  3 与其他应用共享的数据。

 Hibernate查找对象如何应用缓存？

  当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；如果都查不到，再查询数据库，把结果按照ID放入到缓存
  删除、更新、增加数据的时候，同时更新缓存

 Hibernate管理缓存实例
  无论何时，我们在管理Hibernate缓存（Managing the caches）时，当你给save()、update()或saveOrUpdate()方法传递一个对象时，或使用load()、 get()、list()、iterate() 或scroll()方法获得一个对象时, 该对象都将被加入到Session的内部缓存中。
  当随后flush()方法被调用时，对象的状态会和数据库取得同步。 如果你不希望此同步操作发生，或者你正处理大量对象、需要对有效管理内存时，你可以调用evict() 方法，从一级缓存中去掉这些对象及其集合。

 Hibernate的查询方式
  Sql、Criteria,object comptosition
  Hql：
  1、 属性查询
  2、 参数查询、命名参数查询
  3、 关联查询
  4、 分页查询
  5、 统计函数

 如何优化Hibernate？
  1.使用双向一对多关联，不使用单向一对多
  2.灵活使用单向一对多关联
  3.不用一对一，用多对一取代
  4.配置对象缓存，不使用集合缓存
  5.一对多集合使用Bag,多对多集合使用Set
  6. 继承类使用显式多态
  7. 表字段要少，表关联不要怕多，有二级缓存撑腰

 

 hibernate的开发步骤：

 开发步骤
     1)搭建好环境
  引入hibernate最小的jar包
  准备Hibernate.cfg.xml启动配置文件
     2)写实体类(pojo)
     3)为实体类写映射文件"User.hbm.xml"
  在hibernate.cfg.xml添加映射的实体
     4)创建库表
     5)写测试类
  获得Configuration
  创建SessionFactory
  打开Session
  开启事务
  使用session操作数据
  提交事务
  关闭资源

【61】Hibernate主键生成策略有哪些？各有什么优点和缺点？

 手工控制
  assigned(不限制类型)
   assigned策略是由程序员手工控制输入数据模型OID的一种id生成策略
   assigned策略不限定数据库中id字段的类型

   缺点：
    无法保障id的不重复性
    通常配合外部自定义的id生成策略使用，否则将具有很大的风险性

 数据库自动生成

  native(整型数值类型)
   native策略是一种设计性OID生成策略
   native会根据你所使用的数据库类型（XML中配置的驱动），在下列各种生成策略中自动选择对应的id生成策略
   identity
   sequence
   hilo

  uuid(字符串类型)
   uuid策略是由以下4种数据联合计算得出的一种OID生成策略
    IP地址（公网地址，不是路由地址）
    JVM启动时间(精确到250ms)
    当前系统时间
    JVM提供的计数器(保障唯一)
   uuid策略要求数据库中id字段为字符串类型，长度为32位
   uuid策略可以保障id的唯一性，因此不具有风险性

   缺点：不好识别，而且给Java虚拟机的压力比较大。

  increment(整型数值类型)
   increment策略是由Hibernate内部控制生成OID的一种id生成策略
   increment策略要求数据库中id字段为整型数值类型（类的id属性为int或Integer或Long类型，数据库id为bigint类型）
   increment策略首先从对应数据库表中取出当前已使用的最大id值max,然后在此基础上+1，提供给当前要操作数据，完成主键唯一性增长，可兼容数据库

   缺点：
    increment策略虽然可以保障id的唯一性，但是如果出现并发操作时，很有可能获取到相同的max值，导致相同id的出现，因此需要更多的配置，来控制数据库的并发策略。所以不推荐使用。

  identity (整型数值类型)
   identity策略是由数据库底层控制生成OID的一种id生成策略
   identity策略要求数据库中id字段为整型数值类型，并且要求设置成自增特性
   identity只能应用于数据库提供主键自增策略的数据库实现，不能全兼容所有数据库，MySQL可用
   identity策略由数据库底层实现，即便申请了一个id不使用，也不影响下一个id的获取，因此线程安全

   这是Mysql专用的策略。

  sequence (整型数值类型)
   sequence策略是由数据库底层控制生成OID的一种id生成策略
   sequence策略要求数据库中id字段为整型数值类型
   sequence只能应用于提供序列支持的数据库实现，不能全兼容所有数据库，Oracle可用
   sequence策略由数据库底层实现，id生成控制交由数据库管理，是线程安全的策略

   这是Oracle专用的策略

 复合主键/联合主键/多主键(了解)

  复合主键指在一个数据模型使用两个或两个以上的属性来作为唯一性标识用于区分数据
  复合主键在目前的开发中极少使用，主要是为了兼容早期的遗留系统
  复合主键开发方式：

  注意：复合主键与主键只能选择其中一种使用

【62】SQL中having和where的区别是什么?

 where语句在group by语句之前,SQL会在分组之前计算where语句;
 having语句在group by语句之后,SQL会在分组之后计算having语句;

 having执行记录组选择的一部分来工作的。
 where则是执行所有数据来工作的。
 
 再者having可以用聚合函数。