Java面试题全集（10）

91、用Java写一个单例类。 

答： 

- 饿汉式单例

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

[/code]

注意：实现一个单例有两点注意事项，①将构造器私有，不允许外界通过构造器创建对象；②通过公开的静态方法向外界返回类的唯一实例。这里有一个问题可以思考：Spring的IoC容器可以为普通的类创建单例，它是怎么做到的呢？

92、什么是UML？ 

答：UML是统一建模语言（Unified Modeling Language）的缩写，它发表于1997年，综合了当时已经存在的面向对象的建模语言、方法和过程，是一个支持模型化和软件系统开发的图形化语言，为软件开发的所有阶段提供模型化和可视化支持。使用UML可以帮助沟通与交流，辅助应用设计和文档的生成，还能够阐释系统的结构和行为。

93、UML中有哪些常用的图？ 

答：UML定义了多种图形化的符号来描述软件系统部分或全部的静态结构和动态结构，包括：用例图（use case diagram）、类图（class diagram）、时序图（sequence diagram）、协作图（collaboration diagram）、状态图（statechart diagram）、活动图（activity diagram）、构件图（component diagram）、部署图（deployment diagram）等。在这些图形化符号中，有三种图最为重要，分别是：用例图（用来捕获需求，描述系统的功能，通过该图可以迅速的了解系统的功能模块及其关系）、类图（描述类以及类与类之间的关系，通过该图可以快速了解系统）、时序图（描述执行特定任务时对象之间的交互关系以及执行顺序，通过该图可以了解对象能接收的消息也就是说对象能够向外界提供的服务）。 

用例图： 



类图： 



时序图： 



94、用Java写一个冒泡排序。 

答：冒泡排序几乎是个程序员都写得出来，但是面试的时候如何写一个逼格高的冒泡排序却不是每个人都能做到，下面提供一个参考代码：

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

[/code]

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

95、用Java写一个折半查找。 

答：折半查找，也称二分查找、二分搜索，是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组已经为空，则表示找不到指定的元素。这种搜索算法每一次比较都使搜索范围缩小一半，其时间复杂度是O(logN)。

import java.util.Comparator;
public class MyUtil {
  public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {
 return binarySearch(x, 0, x.length- 1, key);
  }
    // 使用循环实现的二分查找
  public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {
    int low = 0;
    int high = x.length - 1;
    while (low <= high) {
      int mid = (low + high) >>> 1;
      int cmp = comp.compare(x[mid], key);
      if (cmp < 0) {
           low= mid + 1;
      }else if (cmp > 0) {
           high= mid - 1;
      }else {
           return mid;
      }
     }
     return -1;
  }
   // 使用递归实现的二分查找
  private static<T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {
    if(low <= high) {
      int mid = low + ((high -low) >> 1);
      if(key.compareTo(x[mid])== 0) {
         return mid;
      }else if(key.compareTo(x[mid])< 0) {
         return binarySearch(x,low, mid - 1, key);
      } else {
         return binarySearch(x,mid + 1, high, key);
      }
     }
     return -1;
  }
}

[/code]

说明：上面的代码中给出了折半查找的两个版本，一个用递归实现，一个用循环实现。需要注意的是计算中间位置时不应该使用(high+ low) / 2的方式，因为加法运算可能导致整数越界，这里应该使用以下三种方式之一：low + (high - low) / 2或low + (high – low) >> 1或(low + high)
>>> 1（>>>是逻辑右移，是不带符号位的右移）

   

96、阐述Servlet和CGI的区别? 

答：Servlet与CGI的区别在于Servlet处于服务器进程中，它通过多线程方式运行其service()方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于Servlet。

补充：Sun Microsystems公司在1996年发布Servlet技术就是为了和CGI进行竞争，Servlet是一个特殊的Java程序，一个基于Java的Web应用通常包含一个或多个Servlet类。Servlet不能够自行创建并执行，它是在Servlet容器中运行的，容器将用户的请求传递给Servlet程序，并将Servlet的响应回传给用户。通常一个Servlet会关联一个或多个JSP页面。以前CGI经常因为性能开销上的问题被诟病，然而Fast
CGI早就已经解决了CGI效率上的问题，所以面试的时候大可不必信口开河的诟病CGI，事实上有很多你熟悉的网站都使用了CGI技术。

97、Servlet接口中有哪些方法？ 

答：Servlet接口定义了5个方法，其中前三个方法与Servlet生命周期相关： 

- void init(ServletConfig config) throws ServletException 

- void service(ServletRequest req, ServletResponse resp) throws ServletException, java.io.IOException 

- void destory() 

- java.lang.String getServletInfo() 

- ServletConfig getServletConfig()

Web容器加载Servlet并将其实例化后，Servlet生命周期开始，容器运行其init()方法进行Servlet的初始化；请求到达时调用Servlet的service()方法，service()方法会根据需要调用与请求对应的doGet或doPost等方法；当服务器关闭或项目被卸载时服务器会将Servlet实例销毁，此时会调用Servlet的destroy()方法。

98、转发（forward）和重定向（redirect）的区别？ 

答：forward是容器中控制权的转向，是服务器请求资源，服务器直接访问目标地址的URL，把那个URL 的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。redirect就是服务器端根据逻辑，发送一个状态码，告诉浏览器重新去请求那个地址，因此从浏览器的地址栏中可以看到跳转后的链接地址，很明显redirect无法访问到服务器保护起来资源，但是可以从一个网站redirect到其他网站。forward更加高效，所以在满足需要时尽量使用forward（通过调用RequestDispatcher对象的forward()方法，该对象可以通过ServletRequest对象的getRequestDispatcher()方法获得），并且这样也有助于隐藏实际的链接；在有些情况下，比如需要访问一个其它服务器上的资源，则必须使用重定向（通过HttpServletResponse对象调用其sendRedirect()方法实现）。

99、JSP有哪些内置对象？作用分别是什么？ 

答：JSP有9个内置对象： 

- request：封装客户端的请求，其中包含来自GET或POST请求的参数； 

- response：封装服务器对客户端的响应； 

- pageContext：通过该对象可以获取其他对象； 

- session：封装用户会话的对象； 

- application：封装服务器运行环境的对象； 

- out：输出服务器响应的输出流对象； 

- config：Web应用的配置对象； 

- page：JSP页面本身（相当于Java程序中的this）； 

- exception：封装页面抛出异常的对象。

补充：如果用Servlet来生成网页中的动态内容无疑是非常繁琐的工作，另一方面，所有的文本和HTML标签都是硬编码，即使做出微小的修改，都需要进行重新编译。JSP解决了Servlet的这些问题，它是Servlet很好的补充，可以专门用作为用户呈现视图（View），而Servlet作为控制器（Controller）专门负责处理用户请求并转发或重定向到某个页面。基于Java的Web开发很多都同时使用了Servlet和JSP。JSP页面其实是一个Servlet，能够运行Servlet的服务器（Servlet容器）通常也是JSP容器，可以提供JSP页面的运行环境，Tomcat就是一个Servlet/JSP容器。第一次请求一个JSP页面时，Servlet/JSP容器首先将JSP页面转换成一个JSP页面的实现类，这是一个实现了JspPage接口或其子接口HttpJspPage的Java类。JspPage接口是Servlet的子接口，因此每个JSP页面都是一个Servlet。转换成功后，容器会编译Servlet类，之后容器加载和实例化Java字节码，并执行它通常对Servlet所做的生命周期操作。对同一个JSP页面的后续请求，容器会查看这个JSP页面是否被修改过，如果修改过就会重新转换并重新编译并执行。如果没有则执行内存中已经存在的Servlet实例。我们可以看一段JSP代码对应的Java程序就知道一切了，而且9个内置对象的神秘面纱也会被揭开。

JSP页面：

<%@ page pageEncoding="UTF-8"%><%String path = request.getContextPath();String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
%><!DOCTYPE html><html>
 <head>
   <base href="<%=basePath%>">
   <title>首页</title>
   <style type="text/css">
       * { font-family: "Arial"; }
   </style>
 </head>

 <body>
   <h1>Hello, World!</h1>
   <hr/>
   <h2>Current time is: <%= new java.util.Date().toString() %></h2>
 </body></html>

对应的Java代码：

/*
* Generated by the Jasper component of Apache Tomcat
* Version: Apache Tomcat/7.0.52
* Generated at: 2014-10-13 13:28:38 UTC
* Note: The last modified time of this file was set to
*       the last modified time of the source file after
*       generation to assist with modification tracking.
*/package org.apache.jsp;import javax.servlet.*;import javax.servlet.http.*;import javax.servlet.jsp.*;public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
       implements org.apache.jasper.runtime.JspSourceDependent {

   private static final javax.servlet.jsp.JspFactory _jspxFactory = javax.servlet.jsp.JspFactory
           .getDefaultFactory();

   private static java.util.Map<java.lang.String, java.lang.Long> _jspx_dependants;

   private javax.el.ExpressionFactory _el_expressionfactory;
   private org.apache.tomcat.InstanceManager _jsp_instancemanager;

   public java.util.Map<java.lang.String, java.lang.Long> getDependants() {
       return _jspx_dependants;
   }

   public void _jspInit() {
       _el_expressionfactory = _jspxFactory.getJspApplicationContext(
               getServletConfig().getServletContext()).getExpressionFactory();
       _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory
               .getInstanceManager(getServletConfig());
   }

   public void _jspDestroy() {
   }

   public void _jspService(
           final javax.servlet.http.HttpServletRequest request,
           final javax.servlet.http.HttpServletResponse response)
           throws java.io.IOException, javax.servlet.ServletException {
       // 内置对象就是在这里定义的
       final javax.servlet.jsp.PageContext pageContext;
       javax.servlet.http.HttpSession session = null;
       final javax.servlet.ServletContext application;
       final javax.servlet.ServletConfig config;
       javax.servlet.jsp.JspWriter out = null;
       final java.lang.Object page = this;
       javax.servlet.jsp.JspWriter _jspx_out = null;
       javax.servlet.jsp.PageContext _jspx_page_context = null;

       try {
           response.setContentType("text/html;charset=UTF-8");
           pageContext = _jspxFactory.getPageContext(this, request, response,
                   null, true, 8192, true);
           _jspx_page_context = pageContext;
           application = pageContext.getServletContext();
           config = pageContext.getServletConfig();
           session = pageContext.getSession();
           out = pageContext.getOut();
           _jspx_out = out;

           out.write('\r');
           out.write('\n');

           String path = request.getContextPath();
           String basePath = request.getScheme() + "://"
                   + request.getServerName() + ":" + request.getServerPort()
                   + path + "/";// 以下代码通过输出流将HTML标签输出到浏览器中            out.write("\r\n");
           out.write("\r\n");
           out.write("<!DOCTYPE html>\r\n");
           out.write("<html>\r\n");
           out.write("  <head>\r\n");
           out.write("    <base href=\"");
           out.print(basePath);
           out.write("\">\r\n");
           out.write("    <title>首页</title>\r\n");
           out.write("    <style type=\"text/css\">\r\n");
           out.write("    \t* { font-family: \"Arial\"; }\r\n");
           out.write("    </style>\r\n");
           out.write("  </head>\r\n");
           out.write("  \r\n");
           out.write("  <body>\r\n");
           out.write("    <h1>Hello, World!</h1>\r\n");
           out.write("    <hr/>\r\n");
           out.write("    <h2>Current time is: ");
           out.print(new java.util.Date().toString());
           out.write("</h2>\r\n");
           out.write("  </body>\r\n");
           out.write("</html>\r\n");
       } catch (java.lang.Throwable t) {
           if (!(t instanceof javax.servlet.jsp.SkipPageException)) {                out = _jspx_out;
               if (out != null && out.getBufferSize() != 0)
                   try {                        out.clearBuffer();
                   } catch (java.io.IOException e) {
                   }
               if (_jspx_page_context != null)
                   _jspx_page_context.handlePageException(t);
               else
                   throw new ServletException(t);
           }
       } finally {
           _jspxFactory.releasePageContext(_jspx_page_context);
       }
   }
}

100、get和post请求的区别？ 

答： 

①get请求用来从服务器上获得资源，而post是用来向服务器提交数据； 

②get将表单中数据按照name=value的形式，添加到action 所指向的URL 后面，并且两者使用"?"连接，而各个变量之间使用"&"连接；post是将表单中的数据放在HTTP协议的请求头或消息体中，传递到action所指向URL； 

③get传输的数据要受到URL长度限制（1024字节）；而post可以传输大量的数据，上传文件通常要使用post方式； 

④使用get时参数会显示在地址栏上，如果这些数据不是敏感数据，那么可以使用get；对于敏感数据还是应用使用post； 

⑤get使用MIME类型application/x-www-form-urlencoded的URL编码（也叫百分号编码）文本的格式传递参数，保证被传送的参数由遵循规范的文本组成，例如一个空格的编码是"%20"。