<h2><strong>前言</strong></h2>    <p>参加了2017年校招，面试了阿里、百度、腾讯、滴滴、美团、网易、去哪儿等公司，个人是客户端 Android 方向，总结了面试过程中频率出现较高的题目，希望对大家有所帮助。</p>    <p style="text-align:center"><img src="https://simg.open-open.com/show/a0a17c940bbd3b83e6fc504ae0b929de.jpg"></p>    <h2><strong>Java 一些知识点</strong></h2>    <h3><strong>Object 有哪些方法</strong></h3>    <ul>     <li>public  方法： getClass 、 equals 、 hashCode 、 toString 、 wait 、 notify</li>     <li>protected  方法： clone 、 finalize</li>     <li>private  方法： registerNatives ，该方法作用是将不同平台C/C++实现的方法映射到Java中的 native 方法</li>    </ul>    <pre>  <code class="language-java">public class Object {      private static native void registerNatives();      // 声明后有紧接静态代码块      static {          registerNatives();      }  }</code></pre>    <h3><strong>自动装箱</strong></h3>    <pre>  <code class="language-java">public static void main(String[] args) {      int i = 0;      Integer j = new Integer(0);      System.out.println(j == i);      System.out.println(j.equals(i));  }</code></pre>    <p>上述代码的输出是</p>    <pre>  <code class="language-java">true   true</code></pre>    <h3><strong>Java 虚拟机 GC 根节点的选择</strong></h3>    <p>Java通过可达性分析来判断对象是否存活。基本思想是通过一系列称为”GC roots”的对象作为起始点，可以作为根节点的是：</p>    <ul>     <li>虚拟机栈（栈帧中的本地变量表）中引用的对象</li>     <li>本地方法栈中 JNI（即一般说的 Native 方法）引用的对象</li>     <li>方法区中类静态属性引用的对象</li>     <li>方法区中常量引用的对象</li>    </ul>    <p>笔者这么理解，作为GC Roots的节点主要在全局性的引用（例如常量或类静态属性）与执行上下文（例如栈帧中的本地变量表）中。</p>    <p>虚拟机栈、本地方法栈这都是局部变量，某个方法执行完，某些局部使用的对象可以被回收。</p>    <h3><strong>类加载机制</strong></h3>    <ul>     <li>启动类加载器( Bootstrap ClassLoader)启动类加载器无法被 java 程序员 直接引用, 这个类加载器负责把存放在 <JAVA_HOME>\lib 目录中的, 或者被 -Xbootclasspath 参数指定路径中的, 并且是被虚拟机识别的类库加载到虚拟机内存中.</li>     <li>扩展类加载器(Extension ClassLoader)负责加载在 <JAVA_HOME>\lib\ext 目录中的, 或者被 java.ext.dirs 系统变量所指定的路径中的所有类库。</li>     <li>应用程序类加载器( Application ClassLoader )这个类加载器是 ClassLoader  中的  getSystemClassLoader() 方法的返回值, 一般称其为系统类加载器, 它负责加载用户类路径(  ClassPath  )上所指定的类库</li>    </ul>    <p>从 java 虚拟机的角度而降, 只存在两种不同的类加载器：</p>    <ul>     <li>一个是启动类加载器(  Bootstrap ClassLoader  ), 这个类加载使用 C++ 语言实现, 是虚拟机自身的一部分;</li>     <li>另一种是其他所有的类加载器, 他们由 java 语言实现, 独立于虚拟机之外, 并且全部继承自 java.lang.ClassLoader</li>    </ul>    <p>加载类的寻找范围就是 JVM 默认路径加上 Classpath , 类具体是使用哪个类加载器不确定。</p>    <h3><strong>类加载主要步骤</strong></h3>    <ul>     <li>加载 把 class 文件的二进制字节流加载到 jvm 里面</li>     <li>验证 确保 class 文件的字节流包含的信息符合当前 jvm 的要求 有文件格式验证, 元数据验证, 字节码验证, 符号引用验证等</li>     <li>准备 正式为类变量分配内存并设置类变量初始值的阶段, 初始化为各数据类型的零值</li>     <li>解析 把常量值内的符号引用替换为直接引用的过程</li>     <li>初始化 执行类构造器 <clinit>() 方法</li>     <li>使用 根据相应的业务逻辑代码使用该类</li>     <li>卸载 类从方法区移除</li>    </ul>    <h3><strong>双亲委派模型</strong></h3>    <p>除了顶层的启动类加载器之外, 其余的类加载器都应当有自己的父类加载器, 父子关系这儿一般都是以组合来实现。</p>    <p>工作过程: 如果一个类加载器收到了类加载的请求, 它首先不会自己去尝试加载这个类, 而是把这个请求委派给父类加载器去完成, 最终所有的加载请求都会传送到顶层的启动类加载器中, 只有当父类加载器反馈自己无法完成这个请求时候, 才由子加载器来加载。</p>    <p>例如类 Object ，它放在 rt.jar 中，无论哪一个类加载器要加载这个类，最终都是委派给启动类加载器进行加载，因此 Object 类在程序的各种类加载器环境中都是同一个类。</p>    <p>对于任何一个类, 都需要由加载它的类加载器和这个类本身一同确定其在 java 虚拟机中的唯一性。</p>    <p>ClassLoader.loadClass() 的代码如下，先检查是否已经被加载过，如果没有则 parent.loadClass() 调用父加载器的 loadClass() 方法，如果父加载器为空则默认使用启动类加载器作为父加载器。如果父类加载器加载失败，抛出 ClassNotFoundException ，再调用自己的 findClass() 方法进行加载。</p>    <p>另外，如果我们自己实现类加载器，一般是 Override 复写  findClass 方法，而不是 loadClass 方法。</p>    <pre>  <code class="language-java">protected Class<?> loadClass(String name, boolean resolve)   throws ClassNotFoundException {      synchronized (getClassLoadingLock(name)) {          // First, check if the class has already been loaded          Class c = findLoadedClass(name);          if (c == null) {              long t0 = System.nanoTime();              try {                  if (parent != null) {                      c = parent.loadClass(name, false);                  } else {                      c = findBootstrapClassOrNull(name);                  }              } catch (ClassNotFoundException e) {                  // ClassNotFoundException thrown if class not found                  // from the non-null parent class loader              }                if (c == null) {                  // If still not found, then invoke findClass in order                  // to find the class.                  long t1 = System.nanoTime();                  c = findClass(name); //可以Override该方法              }          }          if (resolve) {              resolveClass(c);          }          return c;      }  }</code></pre>    <h2><strong>Java 后台的一点知识</strong></h2>    <h3><strong>JSP 与 Servlet 的关系</strong></h3>    <ul>     <li>Tomcat 等 Web 容器最终会把 JSP转化为 Servlet</li>     <li>Jsp更擅长表现于页面显示, Servlet更擅长于逻辑控制</li>     <li>Servlet是利用  System.out.println() 来输出 html 代码，由于包括大量的HTML标签、大量的静态文本及格式等，导致Servlet的开发效率低下</li>     <li>JSP通过在标准的HTML页面中嵌入Java代码，其静态的部分无须Java程序控制，Java 代码只控制那些动态生成的信息</li>     <li>最终 JSP 被容器解释为 Servlet，其中Html 代码也是用 System.out.println() 等拼接输出的</li>     <li>JSP 第一次访问的时候，要转化为 java 文件，然后编译为 class 文件，所以第一次访问 JSP 速度会比较慢，后面会快很多</li>    </ul>    <h3><strong>Servlet 生命周期</strong></h3>    <p>主要是 java.servlet.Servlet 接口中的 init() 、 service() 、和 destroy() 3个方法。</p>    <ul>     <li>初始化阶段，web容器通过调用 init() 方法来初始化 Servlet 实例，在Servlet的整个生命周期类， init() 方法只被调用一次</li>     <li>客户请求到来时，容器会开始一个新线程，并调用servlet的  service() 方法， service()  方法根据请求的http方法来调用  doget()  或 dopost()</li>     <li>终止阶段调用 destroy() 方法，销毁一些资源</li>    </ul>    <h3><strong>GET 请求 vs POST 请求</strong></h3>    <ul>     <li>GET 用于信息获取，是安全的和幂等的， GET 一般是对后台数据库的信息进行查询</li>     <li>POST 表示可能修改变服务器上的资源的请求，一般是对后台数据库进行增、删、改的操作</li>     <li>GET 请求的参数会跟在URL后进行传递，请求的数据会附在URL之后，以 ? 分割URL和传输数据，参数之间以 & 相连，一般浏览器对 URL 的长度会有限制</li>     <li>POST 请求，提交的数据则放置在是HTTP包的包体中，用类似 Key-Value 的格式发送一些数据，相对来说， GET 请求会把请求的参数暴露在 URL 中，安全性比 POST 差一些</li>    </ul>    <h3><strong>HTTP 请求的基本格式</strong></h3>    <ul>     <li>< request line>  请求行</li>     <li><headers>  请求头（参数头）</li>     <li><blank line>  空白行</li>     <li>[<request-body>]  请求实体（ GET没有， POST有 ）</li>    </ul>    <h2><strong>数据库</strong></h2>    <h3><strong>索引的分类</strong></h3>    <p>主要分为聚集索引和非聚集索引：</p>    <ul>     <li>聚集索引存储记录物理上连续，而非聚集索引是逻辑上的连续，物理存储并不连续</li>     <li>聚集索引一个表只能有一个，而非聚集索引一个表可以存在多个</li>    </ul>    <h3><strong>ResultSet 统计记录数目</strong></h3>    <p>Java 中使用 JDBC 连接数据库，最后都会得到一个 ResultSet，比如如下的代码</p>    <pre>  <code class="language-java">Connection con = DriverManager.getConnection(url, username, password);   Statement sta = con.createStatement();   String sql = "select * from student";   ResultSet resultSet = sta.executeQuery(sql);</code></pre>    <p>那么如何根据得到的 ResultSet 统计一共有多少条记录呢？注意： ResultSet 没有提供类似 size() 、 length 的 API 来直接获取总记录数。</p>    <p>方法1：利用循环</p>    <pre>  <code class="language-java">int sum = 0;        while(resultSet.next()){            sum++;        }</code></pre>    <p>方法2：利用ResultSet的getRow方法来获得ResultSet的总行数</p>    <pre>  <code class="language-java">resultSet.last(); //移到最后一行       int rowCount = resultSet.getRow(); //得到当前行号，也就是记录数</code></pre>    <h2><strong>设计模式</strong></h2>    <h3><strong>单例模式</strong></h3>    <p>单例模式中必须保证只有一个实例存在。有时候单例是为了避免重复创建多个实例造成资源浪费，有时候也是为了避免多个不同的实例导致系统不一致的行为。</p>    <p>Android 中，App启动时系统会创建一个 Application 对象，用来存储系统的一些信息，这儿的 Application 就是是单例模式的应用。可以通过 Context.getApplicationContext() 获取唯一的 Application 实例。</p>    <pre>  <code class="language-java">class Singleton {         private volatile static Singleton instance;           private Singleton() { }           public static Singleton getInstance() {             //第一重判断            if (instance == null) {                //锁定代码块                synchronized (Singleton.class) {                    //第二重判断                    if (instance == null) {                        instance = new Singleton(); //创建单例实例                    }                }            }            return instance;         }    }</code></pre>    <p>为什么 synchronized 里面需要加一次判断 if (instance == null) ，是考虑这样的特殊情形：比如线程A、B都到达第一个 if (instance == null) ，线程A进入 synchronized 代码中创建实例，线程B排队等待。但当A执行完毕时，线程B进入 synchronized 锁定代码，它并不知道实例已经创建，将继续创建新的实例，导致产生多个单例对象。</p>    <p>也可以用内部类的方式创建，</p>    <pre>  <code class="language-java">public class Singleton(){      private static class Inner {          private static Singleton instance = new Singleton();      }      private Singleton() {      }      public static Singleton getInstance(){          return Inner.instance;      }  }</code></pre>    <h3><strong>模板方法模式</strong></h3>    <p>在父类中实现一个算法不变的部分，并将可变的行为留给子类来实现。</p>    <p>比如 AsyncTask 里面的四个方法 onPreExecute 、 doInBackground 、 onProgressUpdate 、 onPostExecute</p>    <p>还有 Activity 也应用了模板方法模式</p>    <p>onCreate 、 onStart 、 onResume 、 onPause 、 onStop 、 onDestroy 、 onRestart</p>    <h3><strong>适配器模式</strong></h3>    <p>分为两种：类的适配器模式、对象的适配器模式</p>    <p>Android 里的 ListView 和  <a href="/misc/goto?guid=4958988892678383054" title="RecyclerView">RecyclerView</a> 的 setAdapter() 方法就是使用了适配器模式。</p>    <h3><strong>观察者模式</strong></h3>    <p>在 GUI 中，不管是 Windows 桌面应用、或者 Android、IOS，都会给某个按钮 Button 设置监听事件，这儿就是使用了观察者模式。Android 中设置 Button 的监听事件代码如下：</p>    <pre>  <code class="language-java">final Button button = (Button) findViewById(R.id.button_id);  button.setOnClickListener(new View.OnClickListener() {      public void onClick(View v) {          // Perform action on click      }  });</code></pre>    <h2><strong>笔试编程题</strong></h2>    <h3><strong>线程 VS 进程</strong></h3>    <p>关于线程和进程，不正确的描述是 <em>__</em> 。(选 D 栈是线程私有， 保存其运行状态和局部变量 )</p>    <p>A. 进程的隔离性要好于线程</p>    <p>B. 线程在资源消耗上通常要比进程轻量</p>    <p>C. 不同进程间不会共享逻辑地址空间</p>    <p>D. 同一个进程的线程之间共享内存，包括堆和栈</p>    <p>E. 进程间有途径共享大量内存中的数据</p>    <p>F. 线程间通讯可以通过直接访问全局变量，或者使用进程间通讯的机制(IPC)</p>    <h3><strong>找出未打卡的员工</strong></h3>    <p>题目：输入两行数据，第一行为全部员工的 id，第二行为某一天打卡的员工 id，已知只有一个员工没有打卡，求出未打卡员工的 id。（员工 id 不重复，每行输入的 id 未排序）</p>    <p>输入：</p>    <p>1001 1003 1002 1005 1004</p>    <p>1002 1003 1001 1004</p>    <p>输出：</p>    <p>1005</p>    <p>分析：可以用两个 List，第一个 List 保存所有员工的 id，第二个 List 保存打卡员工的 id，从第一个List 中把第二个 List 的数据都删除，最终剩下的就是未打卡员工的 id。</p>    <p>更好的方法：异或，两行数据中未打卡员工的 id 出现了一次，其余员工的 id 都出现了2次，两个相同的数异或为0。</p>    <pre>  <code class="language-java">public static void main(String[] args) {      Scanner scan = new Scanner(System.in);      while (scan.hasNext()) {            String[] ids = scan.nextLine().split(" ");          String[] marks = scan.nextLine().split(" ");          int result = 0;          for (int i = 0; i < ids.length; i++) {              result ^= Integer.parseInt(ids[i]);          }          for (int i = 0; i < marks.length; i++) {              result ^= Integer.parseInt(marks[i]);          }          System.out.println(result);      }  }</code></pre>    <h2><strong>手写代码题</strong></h2>    <h3><strong>快速排序</strong></h3>    <p>排序是经典面试题，公司也希望通过手写快排来考察面试者的编程习惯和基本功。</p>    <pre>  <code class="language-java">// 排序范围 [start, end], 包含 end  public void sort(int[] arr, int start, int end) {      if (start < end) {          int p = partition(arr, start, end);          quickSort(arr, start, p - 1);          quickSort(arr, p + 1, end);      }  }  // 一次划分代码，返回被划分后的基准位置  public static int partition(int[] arr, int left, int right) {      int pivot = arr[left];       while (left < right) {          while (left < right && arr[right] >= pivot)              right--;          if (left < right)              arr[left++] = arr[right];          while (left < right && arr[left] <= pivot)              left++;          if (left < right)              arr[right--] = arr[left];      }      arr[left] = pivot;      return left;  }</code></pre>    <p>Note：快排是不稳定的，常见的稳定排序是：冒泡、插入、归并</p>    <h3><strong>括号字符串是否合法</strong></h3>    <p>某个字符串只包括 ( 和 ） ，判断其中的括号是否匹配正确，比如 (()()) 正确， ((())() 错误， 不允许使用栈 。</p>    <p>这种类似题的常见思路是栈，对于左括号入栈，如果遇到右括号，判断此时栈顶是不是左括号，是则将其出栈，不是则该括号序列不合法。</p>    <p>面试官要求不能使用栈，可以使用计数器，利用 int count 字段。</p>    <pre>  <code class="language-java">public static boolean checkBrackets(String str) {      char[] cs = str.toCharArray();      int count = 0;      for (int i = 0; i < cs.length; i++) {          if (cs[i] == '(')              count++;          else {              count--;              if (count < 0) {                  return false;              }          }      }        return count == 0;  }</code></pre>    <h3><strong>扑克牌随机发牌</strong></h3>    <p>对于52张牌，实现一个随机打算扑克牌顺序的程序。52张牌使用 int 数组模拟。</p>    <p>该算法的难点是如何保证随机性？有个经典算法 shuffle ，思路就是遍历数组，在剩下的元素里再随机取一个元素，然后再在剩下的元素里再随机取一个元素。每次取完元素后，我们就不会让这个元素参与下一次的选取。</p>    <pre>  <code class="language-java">To shuffle an array a of n elements (indices 0..n-1):    for i from n − 1 downto 1 do         j ← random integer with 0 ≤ j ≤ i         exchange a[j] and a[i]</code></pre>    <p>注意这儿是 0 ≤ j ≤ i ，包括 j=i 的情况，因为可能洗牌后某个牌未发生交换，比如第51张牌还是原来的第51张牌。</p>    <pre>  <code class="language-java">public void randomCards() {      int[] data = new int[52];      Random random= new Random();      for (int i = 0; i < data.length; i++)          data[i] = i;        for (int i = data.length - 1; i > 0; i--) {          int temp = random.nextInt(i+1); //产生 [0,i] 之间的随机数          swap(data,i,temp);      }  }</code></pre>    <h2><strong>智力题</strong></h2>    <h3><strong>金条付费</strong></h3>    <p>你让工人为你工作7天，回报是一根金条，这个金条平分成相连的7段，你必须在每天结束的时候给他们一段金条，如果只允许你两次把金条弄断，你如何给你的工人付费？</p>    <p>答案：切成一段,两段,和四段.</p>    <p>第1天: 给出1.</p>    <p>第2天: 给出2,还回1.</p>    <p>第3天: 给出1.</p>    <p>第4天: 给出4,还回1+2.</p>    <p>第5天: 给出1.</p>    <p>第6天: 给出2,还回1.</p>    <p>第7天: 给出1.</p>    <h3><strong>赛马</strong></h3>    <p>25匹马，速度都不同，但每匹马的速度都是定值。现在只有5条赛道，无法计时，即每赛一场最多只能知道5匹马的相对快慢。问最少赛几场可以找出25匹马中速度最快的前3名？</p>    <p>答案：</p>    <ul>     <li>25匹马分成5组，先进行5场比赛</li>     <li>再将刚才5场的冠军进行第6场比赛，得到第一名。按照第6场比赛的名词把前面5场比赛所在的组命名为 A、B、C、D、E 组，即 A 组的冠军是第6场第一名，B 组的冠军是第二名 …</li>     <li>分析第2名和第3名的可能性，如果确定有多于3匹马比某匹马快，那它可以被淘汰了。因为 D 组是第6场的第四名，整个D 组被淘汰了，同意整个 E 组被淘汰。剩下可能是整体的第2、3名的就是C组的第1名、B组的1、2名、A组的第2、3名。取这5匹马进行第7场比赛<br> -所以，一共需要7场比赛</li>    </ul>    <p> </p>    <p>来自：http://原网站已经失效/article/it-interview-question-2017.html</p>    <p> </p>