2017年高频率的互联网校园招聘面试题

前言

参加了2017年校招，面试了阿里、百度、腾讯、滴滴、美团、网易、去哪儿等公司，个人是客户端 Android 方向，总结了面试过程中频率出现较高的题目，希望对大家有所帮助。

Java 一些知识点

Object 有哪些方法

• public  方法： getClass 、 equals 、 hashCode 、 toString 、 wait 、 notify
• protected  方法： clone 、 finalize
• private  方法： registerNatives ，该方法作用是将不同平台C/C++实现的方法映射到Java中的 native 方法

public class Object {
    private static native void registerNatives();
    // 声明后有紧接静态代码块
    static {
        registerNatives();
    }
}

自动装箱

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

上述代码的输出是

true 
true

Java 虚拟机 GC 根节点的选择

Java通过可达性分析来判断对象是否存活。基本思想是通过一系列称为”GC roots”的对象作为起始点，可以作为根节点的是：

• 虚拟机栈（栈帧中的本地变量表）中引用的对象
• 本地方法栈中 JNI（即一般说的 Native 方法）引用的对象
• 方法区中类静态属性引用的对象
• 方法区中常量引用的对象

笔者这么理解，作为GC Roots的节点主要在全局性的引用（例如常量或类静态属性）与执行上下文（例如栈帧中的本地变量表）中。

虚拟机栈、本地方法栈这都是局部变量，某个方法执行完，某些局部使用的对象可以被回收。

类加载机制

• 启动类加载器( Bootstrap ClassLoader)启动类加载器无法被 java 程序员 直接引用, 这个类加载器负责把存放在 <JAVA_HOME>\lib 目录中的, 或者被 -Xbootclasspath 参数指定路径中的, 并且是被虚拟机识别的类库加载到虚拟机内存中.
• 扩展类加载器(Extension ClassLoader)负责加载在 <JAVA_HOME>\lib\ext 目录中的, 或者被 java.ext.dirs 系统变量所指定的路径中的所有类库。
• 应用程序类加载器( Application ClassLoader )这个类加载器是 ClassLoader  中的  getSystemClassLoader() 方法的返回值, 一般称其为系统类加载器, 它负责加载用户类路径(  ClassPath  )上所指定的类库

从 java 虚拟机的角度而降, 只存在两种不同的类加载器：

• 一个是启动类加载器(  Bootstrap ClassLoader  ), 这个类加载使用 C++ 语言实现, 是虚拟机自身的一部分;
• 另一种是其他所有的类加载器, 他们由 java 语言实现, 独立于虚拟机之外, 并且全部继承自 java.lang.ClassLoader

加载类的寻找范围就是 JVM 默认路径加上 Classpath , 类具体是使用哪个类加载器不确定。

类加载主要步骤

• 加载 把 class 文件的二进制字节流加载到 jvm 里面
• 验证 确保 class 文件的字节流包含的信息符合当前 jvm 的要求 有文件格式验证, 元数据验证, 字节码验证, 符号引用验证等
• 准备 正式为类变量分配内存并设置类变量初始值的阶段, 初始化为各数据类型的零值
• 解析 把常量值内的符号引用替换为直接引用的过程
• 初始化 执行类构造器 <clinit>() 方法
• 使用 根据相应的业务逻辑代码使用该类
• 卸载 类从方法区移除

双亲委派模型

除了顶层的启动类加载器之外, 其余的类加载器都应当有自己的父类加载器, 父子关系这儿一般都是以组合来实现。

工作过程: 如果一个类加载器收到了类加载的请求, 它首先不会自己去尝试加载这个类, 而是把这个请求委派给父类加载器去完成, 最终所有的加载请求都会传送到顶层的启动类加载器中, 只有当父类加载器反馈自己无法完成这个请求时候, 才由子加载器来加载。

例如类 Object ，它放在 rt.jar 中，无论哪一个类加载器要加载这个类，最终都是委派给启动类加载器进行加载，因此 Object 类在程序的各种类加载器环境中都是同一个类。

对于任何一个类, 都需要由加载它的类加载器和这个类本身一同确定其在 java 虚拟机中的唯一性。

ClassLoader.loadClass() 的代码如下，先检查是否已经被加载过，如果没有则 parent.loadClass() 调用父加载器的 loadClass() 方法，如果父加载器为空则默认使用启动类加载器作为父加载器。如果父类加载器加载失败，抛出 ClassNotFoundException ，再调用自己的 findClass() 方法进行加载。

另外，如果我们自己实现类加载器，一般是 Override 复写  findClass 方法，而不是 loadClass 方法。

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

Java 后台的一点知识

JSP 与 Servlet 的关系

• Tomcat 等 Web 容器最终会把 JSP转化为 Servlet
• Jsp更擅长表现于页面显示, Servlet更擅长于逻辑控制
• Servlet是利用  System.out.println() 来输出 html 代码，由于包括大量的HTML标签、大量的静态文本及格式等，导致Servlet的开发效率低下
• JSP通过在标准的HTML页面中嵌入Java代码，其静态的部分无须Java程序控制，Java 代码只控制那些动态生成的信息
• 最终 JSP 被容器解释为 Servlet，其中Html 代码也是用 System.out.println() 等拼接输出的
• JSP 第一次访问的时候，要转化为 java 文件，然后编译为 class 文件，所以第一次访问 JSP 速度会比较慢，后面会快很多

Servlet 生命周期

主要是 java.servlet.Servlet 接口中的 init() 、 service() 、和 destroy() 3个方法。

• 初始化阶段，web容器通过调用 init() 方法来初始化 Servlet 实例，在Servlet的整个生命周期类， init() 方法只被调用一次
• 客户请求到来时，容器会开始一个新线程，并调用servlet的  service() 方法， service()  方法根据请求的http方法来调用  doget()  或 dopost()
• 终止阶段调用 destroy() 方法，销毁一些资源

GET 请求 vs POST 请求

• GET 用于信息获取，是安全的和幂等的， GET 一般是对后台数据库的信息进行查询
• POST 表示可能修改变服务器上的资源的请求，一般是对后台数据库进行增、删、改的操作
• GET 请求的参数会跟在URL后进行传递，请求的数据会附在URL之后，以 ? 分割URL和传输数据，参数之间以 & 相连，一般浏览器对 URL 的长度会有限制
• POST 请求，提交的数据则放置在是HTTP包的包体中，用类似 Key-Value 的格式发送一些数据，相对来说， GET 请求会把请求的参数暴露在 URL 中，安全性比 POST 差一些

HTTP 请求的基本格式

• < request line>  请求行
• <headers>  请求头（参数头）
• <blank line>  空白行
• [<request-body>]  请求实体（ GET没有， POST有 ）

数据库

索引的分类

主要分为聚集索引和非聚集索引：

• 聚集索引存储记录物理上连续，而非聚集索引是逻辑上的连续，物理存储并不连续
• 聚集索引一个表只能有一个，而非聚集索引一个表可以存在多个

ResultSet 统计记录数目

Java 中使用 JDBC 连接数据库，最后都会得到一个 ResultSet，比如如下的代码

Connection con = DriverManager.getConnection(url, username, password);
 Statement sta = con.createStatement();
 String sql = "select * from student";
 ResultSet resultSet = sta.executeQuery(sql);

那么如何根据得到的 ResultSet 统计一共有多少条记录呢？注意： ResultSet 没有提供类似 size() 、 length 的 API 来直接获取总记录数。

方法1：利用循环

int sum = 0;      
while(resultSet.next()){      
    sum++;      
}

方法2：利用ResultSet的getRow方法来获得ResultSet的总行数

resultSet.last(); //移到最后一行 
int rowCount = resultSet.getRow(); //得到当前行号，也就是记录数

设计模式

单例模式

单例模式中必须保证只有一个实例存在。有时候单例是为了避免重复创建多个实例造成资源浪费，有时候也是为了避免多个不同的实例导致系统不一致的行为。

Android 中，App启动时系统会创建一个 Application 对象，用来存储系统的一些信息，这儿的 Application 就是是单例模式的应用。可以通过 Context.getApplicationContext() 获取唯一的 Application 实例。

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

为什么 synchronized 里面需要加一次判断 if (instance == null) ，是考虑这样的特殊情形：比如线程A、B都到达第一个 if (instance == null) ，线程A进入 synchronized 代码中创建实例，线程B排队等待。但当A执行完毕时，线程B进入 synchronized 锁定代码，它并不知道实例已经创建，将继续创建新的实例，导致产生多个单例对象。

也可以用内部类的方式创建，

public class Singleton(){
    private static class Inner {
        private static Singleton instance = new Singleton();
    }
    private Singleton() {
    }
    public static Singleton getInstance(){
        return Inner.instance;
    }
}

模板方法模式

在父类中实现一个算法不变的部分，并将可变的行为留给子类来实现。

比如 AsyncTask 里面的四个方法 onPreExecute 、 doInBackground 、 onProgressUpdate 、 onPostExecute

还有 Activity 也应用了模板方法模式

onCreate 、 onStart 、 onResume 、 onPause 、 onStop 、 onDestroy 、 onRestart

适配器模式

分为两种：类的适配器模式、对象的适配器模式

Android 里的 ListView 和  RecyclerView 的 setAdapter() 方法就是使用了适配器模式。

观察者模式

在 GUI 中，不管是 Windows 桌面应用、或者 Android、IOS，都会给某个按钮 Button 设置监听事件，这儿就是使用了观察者模式。Android 中设置 Button 的监听事件代码如下：

final Button button = (Button) findViewById(R.id.button_id);
button.setOnClickListener(new View.OnClickListener() {
    public void onClick(View v) {
        // Perform action on click
    }
});

笔试编程题

线程 VS 进程

关于线程和进程，不正确的描述是 __ 。(选 D 栈是线程私有， 保存其运行状态和局部变量 )

A. 进程的隔离性要好于线程

B. 线程在资源消耗上通常要比进程轻量

C. 不同进程间不会共享逻辑地址空间

D. 同一个进程的线程之间共享内存，包括堆和栈

E. 进程间有途径共享大量内存中的数据

F. 线程间通讯可以通过直接访问全局变量，或者使用进程间通讯的机制(IPC)

找出未打卡的员工

题目：输入两行数据，第一行为全部员工的 id，第二行为某一天打卡的员工 id，已知只有一个员工没有打卡，求出未打卡员工的 id。（员工 id 不重复，每行输入的 id 未排序）

输入：

1001 1003 1002 1005 1004

1002 1003 1001 1004

输出：

1005

分析：可以用两个 List，第一个 List 保存所有员工的 id，第二个 List 保存打卡员工的 id，从第一个List 中把第二个 List 的数据都删除，最终剩下的就是未打卡员工的 id。

更好的方法：异或，两行数据中未打卡员工的 id 出现了一次，其余员工的 id 都出现了2次，两个相同的数异或为0。

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

手写代码题

快速排序

排序是经典面试题，公司也希望通过手写快排来考察面试者的编程习惯和基本功。

// 排序范围 [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;
}

Note：快排是不稳定的，常见的稳定排序是：冒泡、插入、归并

括号字符串是否合法

某个字符串只包括 ( 和 ） ，判断其中的括号是否匹配正确，比如 (()()) 正确， ((())() 错误， 不允许使用栈 。

这种类似题的常见思路是栈，对于左括号入栈，如果遇到右括号，判断此时栈顶是不是左括号，是则将其出栈，不是则该括号序列不合法。

面试官要求不能使用栈，可以使用计数器，利用 int count 字段。

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

扑克牌随机发牌

对于52张牌，实现一个随机打算扑克牌顺序的程序。52张牌使用 int 数组模拟。

该算法的难点是如何保证随机性？有个经典算法 shuffle ，思路就是遍历数组，在剩下的元素里再随机取一个元素，然后再在剩下的元素里再随机取一个元素。每次取完元素后，我们就不会让这个元素参与下一次的选取。

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]

注意这儿是 0 ≤ j ≤ i ，包括 j=i 的情况，因为可能洗牌后某个牌未发生交换，比如第51张牌还是原来的第51张牌。

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

智力题

金条付费

你让工人为你工作7天，回报是一根金条，这个金条平分成相连的7段，你必须在每天结束的时候给他们一段金条，如果只允许你两次把金条弄断，你如何给你的工人付费？

答案：切成一段,两段,和四段.

第1天: 给出1.

第2天: 给出2,还回1.

第3天: 给出1.

第4天: 给出4,还回1+2.

第5天: 给出1.

第6天: 给出2,还回1.

第7天: 给出1.

赛马

25匹马，速度都不同，但每匹马的速度都是定值。现在只有5条赛道，无法计时，即每赛一场最多只能知道5匹马的相对快慢。问最少赛几场可以找出25匹马中速度最快的前3名？

答案：

• 25匹马分成5组，先进行5场比赛
• 再将刚才5场的冠军进行第6场比赛，得到第一名。按照第6场比赛的名词把前面5场比赛所在的组命名为 A、B、C、D、E 组，即 A 组的冠军是第6场第一名，B 组的冠军是第二名 …
• 分析第2名和第3名的可能性，如果确定有多于3匹马比某匹马快，那它可以被淘汰了。因为 D 组是第6场的第四名，整个D 组被淘汰了，同意整个 E 组被淘汰。剩下可能是整体的第2、3名的就是C组的第1名、B组的1、2名、A组的第2、3名。取这5匹马进行第7场比赛
  -所以，一共需要7场比赛