金九银十又到了跳槽的高峰期，然而有效的准备面试，无疑是获得高薪水的关键。凡事预则立不预则废，无论你是近期打算跳槽，还是过完年准备跳槽，我想此刻开始准备面试，无疑是最明智的选择。信息过载的今天，想要找一份靠谱的高频面试题和权威的答案非常不容易，值得庆幸的是这篇文章为你汇总了大量的干货面试资料，下面一起来看吧。

Java程序是怎么执行的

我们日常的工作中都使用开发工具（IntelliJ IDEA 或 Eclipse 等）可以很方便的调试程序，或者是通过打包工具把项目打包成 jar 包或者 war 包，放入 Tomcat 等 Web 容器中就可以正常运行了，但你有没有想过 Java 程序内部是如何执行的？其实不论是在开发工具中运行还是在 Tomcat 中运行，Java 程序的执行流程基本都是相同的，它的执行流程如下：

• 先把 Java 代码编译成字节码，也就是把 .java 类型的文件编译成 .class 类型的文件。这个过程的大致执行流程：Java 源代码 -> 词法分析器 -> 语法分析器 -> 语义分析器 -> 字符码生成器 -> 最终生成字节码，其中任何一个节点执行失败就会造成编译失败；

• 把 class 文件放置到 Java 虚拟机，这个虚拟机通常指的是 Oracle 官方自带的 Hotspot JVM；

• Java 虚拟机使用类加载器（Class Loader）装载 class 文件；

• 类加载完成之后，会进行字节码效验，字节码效验通过之后 JVM 解释器会把字节码翻译成机器码交由操作系统执行。但不是所有代码都是解释执行的，JVM 对此做了优化，比如，以 Hotspot 虚拟机来说，它本身提供了 JIT（Just In Time）也就是我们通常所说的动态编译器，它能够在运行时将热点代码编译为机器码，这个时候字节码就变成了编译执行。

Java 程序执行流程图如下：

Java虚拟机是如何判定热点代码的

Java 虚拟机判定热点代码的方式有两种：

• 基于采样的热点判定：主要是虚拟机会周期性的检查各个线程的栈顶，若某个或某些方法经常出现在栈顶，那这个方法就是“热点方法”。这种判定方式的优点是实现简单；缺点是很难精确一个方法的热度，容易受到线程阻塞或外界因素的影响。

• 基于计数器的热点判定：主要就是虚拟机给每一个方法甚至代码块建立了一个计数器，统计方法的执行次数，超过一定的阀值则标记为此方法为热点方法。

Hotspot 虚拟机使用的基于计数器的热点探测方法。它使用了两类计数器：方法调用计数器和回边计数器，当到达一定的阀值是就会触发 JIT 编译。方法调用计数器：在 client 模式下的阀值是 1500 次，Server 是 10000 次，可以通过虚拟机参数：-XX:CompileThreshold=N 对其进行设置。但是JVM还存在热度衰减，时间段内调用方法的次数较少，计数器就减小。回边计数器：主要统计的是方法中循环体代码执行的次数。

以下Integer代码输出的结果是

Integer age = 10;	
Integer age2 = 10;	
Integer age3 = 133;	
Integer age4 = 133;	
System.out.println((age == age2) + "," + (age3 == age4));

答：true,false题目解析：此道题目考察的是，面试者对于基础类型高频区缓存的掌握，因为 Integer 的高频区的取值是 -128-127，所以在这个区间的值会复用已有的缓存，对比的结果自然是 true,false 。

以下StringBuffer传值修改后的执行结果是什么

public static void main(String[] args) {	
  StringBuffer sf = new StringBuffer("hi");	
  changeStr(sf);	
  System.out.println(sf);	
}	
public static void changeStr(StringBuffer sf){	
    sf.append("laowang");	
}

答：hilaowang题目解析：String 为不可变类型，在方法内对 String 修改的时候，相当修改传递过来的是一个 String 副本，所以 String 本身的值是不会被修改的，而 StringBuffer 为可变类型，传递过来的参数相当于对象本身，所以打印的结果就为 hilaowang。

 以下数组比较的结果分别是什么

String[] strArr = {"dog", "cat", "pig", "bird"};	
String[] strArr2 = {"dog", "cat", "pig", "bird"};	
System.out.println(Arrays.equals(strArr, strArr2));	
System.out.println(strArr.equals(strArr2));	
System.out.println(strArr == strArr2);

答：true、 false、 false。题目解析：strArr == strArr2 为引用比较，因此结果一定是 false，而数组本身的比较也就是 strArr.equals(strArr2) 为 false 的原因是因为数组没有重写 equals 方法，因此也是引用比较。数组 equals 源码实现如下：

public boolean equals(Object obj) {	
  return (this == obj);	
}

而 Arrays.equals 的结果之所以是 true 是因为 Arrays.equals 重写了 equals 方法。源代码实现如下：

public static boolean equals(Object[] a, Object[] a2) {	
    if (a==a2)	
        return true;	
    if (a==null || a2==null)	
        return false;	
    int length = a.length;	
    if (a2.length != length)	
        return false;	
    for (int i=0; i<length; i++) {	
        Object o1 = a[i];	
        Object o2 = a2[i];	
        if (!(o1==null ? o2==null : o1.equals(o2)))	
            return false;	
    }	
    return true;	
}

常用的序列化方式都有哪些

答：常用的序列化方式有以下三种：1) Java 原生序列化方式请参考以下代码：

// 序列化和反序列化	
class SerializableTest {	
    public static void main(String[] args) throws IOException, ClassNotFoundException {	
        // 对象赋值	
        User user = new User();	
        user.setName("老王");	
        user.setAge(30);	
        System.out.println(user);	
        // 创建输出流（序列化内容到磁盘）	
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("test.out"));	
        // 序列化对象	
        oos.writeObject(user);	
        oos.flush();	
        oos.close();	
        // 创建输入流（从磁盘反序列化）	
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.out"));	
        // 反序列化	
        User user2 = (User) ois.readObject();	
        ois.close();	
        System.out.println(user2);	
    }	
}	
class User implements Serializable {	
    private static final long serialVersionUID = 5132320539584511249L;	
    private String name;	
    private int age;	
    @Override	
    public String toString() {	
        return "{name:" + name + ",age:" + age + "}";	
    }	
    public String getName() {	
        return name;	
    }	
    public void setName(String name) {	
        this.name = name;	
    }	
    public int getAge() {	
        return age;	
    }	
    public void setAge(int age) {	
        this.age = age;	
    }	
}

2) JSON 格式，可使用 fastjson 或 GSONJSON 是一种轻量级的数据格式，JSON 序列化的优点是可读性比较高，方便调试。我们本篇以 fastjson 的序列化为例，请参考以下代码：

// 序列化和反序列化	
class SerializableTest {	
    public static void main(String[] args) throws IOException, ClassNotFoundException {	
        // 对象赋值	
        User user = new User();	
        user.setName("老王");	
        user.setAge(30);	
        System.out.println(user);	
        String jsonSerialize = JSON.toJSONString(user);	
        User user3 = (User) JSON.parseObject(jsonSerialize, User.class);	
        System.out.println(user3);	
    }	
}	
class User implements Serializable {	
    private static final long serialVersionUID = 5132320539584511249L;	
    private String name;	
    private int age;	
    @Override	
    public String toString() {	
        return "{name:" + name + ",age:" + age + "}";	
    }	
    public String getName() {	
        return name;	
    }	
    public void setName(String name) {	
        this.name = name;	
    }	
    public int getAge() {	
        return age;	
    }	
    public void setAge(int age) {	
        this.age = age;	
    }	
}

3) Hessian 方式序列化Hessian 序列化的优点是可以跨编程语言，比 Java 原生的序列化和反序列化效率高。请参考以下示例代码：

// 序列化和反序列化	
class SerializableTest {	
    public static void main(String[] args) throws IOException, ClassNotFoundException {	
       // 序列化	
        ByteArrayOutputStream bo = new ByteArrayOutputStream();	
        HessianOutput hessianOutput = new HessianOutput(bo);	
        hessianOutput.writeObject(user);	
        byte[] hessianBytes = bo.toByteArray();	
        // 反序列化	
        ByteArrayInputStream bi = new ByteArrayInputStream(hessianBytes);	
        HessianInput hessianInput = new HessianInput(bi);	
        User user4 = (User) hessianInput.readObject();	
        System.out.println(user4);	
    }	
}	
class User implements Serializable {	
    private static final long serialVersionUID = 5132320539584511249L;	
    private String name;	
    private int age;	
    @Override	
    public String toString() {	
        return "{name:" + name + ",age:" + age + "}";	
    }	
    public String getName() {	
        return name;	
    }	
    public void setName(String name) {	
        this.name = name;	
    }	
    public int getAge() {	
        return age;	
    }	
    public void setAge(int age) {	
        this.age = age;	
    }	
}

有哪些方法可以解决哈希冲突

答：哈希冲突的常用解决方案有以下 4 种：

• 开放定址法：当关键字的哈希地址 p=H（key）出现冲突时，以 p 为基础，产生另一个哈希地址 p1，如果 p1 仍然冲突，再以 p 为基础，产生另一个哈希地址 p2，循环此过程直到找出一个不冲突的哈希地址，将相应元素存入其中；

• 再哈希法：这种方法是同时构造多个不同的哈希函数，当哈希地址 Hi=RH1（key）发生冲突时，再计算 Hi=RH2（key），循环此过程直到找到一个不冲突的哈希地址，这种方法唯一的缺点就是增加了计算时间；

• 链地址法：这种方法的基本思想是将所有哈希地址为 i 的元素构成一个称为同义词链的单链表，并将单链表的头指针存在哈希表的第 i 个单元中，因而查找、插入和删除主要在同义词链中进行。链地址法适用于经常进行插入和删除的情况；

• 建立公共溢出区：将哈希表分为基本表和溢出表两部分，凡是和基本表发生冲突的元素，一律填入溢出表。

JVM内存布局是怎样的

答：不同虚拟机实现可能略微有所不同，但都会遵从 Java 虚拟机规范，Java 8 虚拟机规范规定，Java 虚拟机所管理的内存将会包括以下几个区域：

• 程序计数器（Program Counter Register）

• Java 虚拟机栈（Java Virtual Machine Stacks）

• 本地方法栈（Native Method Stack）

• Java 堆（Java Heap）

• 方法区（Methed Area）

1) 程序计数器

程序计数器（Program Counter Register）是一块较小的内存空间，它可以看作是当前线程所执行的字节码的行号指示器。在虚拟机的概念模型里，字节码解析器的工作是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。

由于 JVM 的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，也就是任何时刻，一个处理器（或者说一个内核）都只会执行一条线程中的指令。因此为了线程切换后能恢复到正确的执行位置，每个线程都有独立的程序计数器。

如果线程正在执行 Java 中的方法，程序计数器记录的就是正在执行虚拟机字节码指令的地址，如果是 Native 方法，这个计数器就为空（undefined），因此该内存区域是唯一一个在 Java 虚拟机规范中没有规定 OutOfMemoryError 的区域。

2) Java虚拟机栈

Java虚拟机栈（Java Virtual Machine Stacks）描述的是 Java 方法执行的内存模型，每个方法在执行的同时都会创建一个线帧（Stack Frame）用于存储局部变量表、操作数栈、动态链接、方法出口等信息，每个方法从调用直至执行完成的过程，都对应着一个线帧在虚拟机栈中入栈到出栈的过程。

• 如果线程请求的栈深度大于虚拟机所允许的栈深度就会抛出 StackOverflowError 异常。

• 如果虚拟机是可以动态扩展的，如果扩展时无法申请到足够的内存就会抛出 OutOfMemoryError 异常。

3) 本地方法栈

本地方法栈（Native Method Stack）与虚拟机栈的作用是一样的，只不过虚拟机栈是服务 Java 方法的，而本地方法栈是为虚拟机调用 Native 方法服务的。在 Java 虚拟机规范中对于本地方法栈没有特殊的要求，虚拟机可以自由的实现它，因此在 Sun HotSpot 虚拟机直接把本地方法栈和虚拟机栈合二为一了。

4) Java 堆

Java堆（Java Heap）是 JVM 中内存最大的一块，是被所有线程共享的，在虚拟机启动时候创建，Java堆唯一的目的就是存放对象实例，几乎所有的对象实例都在这里分配内存，随着JIT编译器的发展和逃逸分析技术的逐渐成熟，栈上分配、标量替换优化的技术将会导致一些微妙的变化，所有的对象都分配在堆上渐渐变得不那么绝对了。

如果在堆中没有内存完成实例分配，并且堆不可以再扩展时，将会抛出 OutOfMemoryError。Java 虚拟机规范规定，Java 堆可以处在物理上不连续的内存空间中，只要逻辑上连续即可，就像我们的磁盘空间一样。在实现上也可以是固定大小的，也可以是可扩展的，不过当前主流的虚拟机都是可扩展的，通过 -Xmx 和 -Xms 控制。

5) 方法区

方法区（Methed Area）用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译后的代码等数据。很多人把方法区称作“永久代”（Permanent Generation），本质上两者并不等价，只是 HotSpot 虚拟机垃圾回收器团队把 GC 分代收集扩展到了方法区，或者说是用来永久代来实现方法区而已，这样能省去专门为方法区编写内存管理的代码，但是在 JDK 8 也移除了“永久代”，使用 Native Memory 来实现方法区。当方法无法满足内存分配需求时会抛出 OutOfMemoryError 异常。

synchronized是如何实现锁升级的

答：在锁对象的对象头里面有一个 threadid 字段，在第一次访问的时候 threadid 为空，JVM（Java 虚拟机）让其持有偏向锁，并将 threadid 设置为其线程 id，再次进入的时候会先判断 threadid 是否尤其线程 id 一致。

如果一致则可以直接使用，如果不一致，则升级偏向锁为轻量级锁，通过自旋循环一定次数来获取锁，不会阻塞，执行一定次数之后就会升级为重量级锁，进入阻塞，整个过程就是锁升级的过程。

RabbitMQ有哪种重要的组件

它们有什么作用

答：RabbitMQ 包含的重要组件有：ConnectionFactory（连接管理器）、Channel（信道）、Exchange（交换器）、Queue（队列）、RoutingKey（路由键）、BindingKey（绑定键） 等重要的组件，它们的作用如下：

• ConnectionFactory（连接管理器）：应用程序与 RabbitMQ 之间建立连接的管理器，程序代码中使用；

• Channel（信道）：消息推送使用的通道；

• Exchange（交换器）：用于接受、分配消息；

• Queue（队列）：用于存储生产者的消息；

• RoutingKey（路由键）：用于把生成者的数据分配到交换器上；

• BindingKey（绑定键）：用于把交换器的消息绑定到队列上。

运行流程，如下图所示：

以上面试内容均来自《Java面试全解析：核心知识点与典型面试题》这门课的真实评价：

通过这门课拿到阿里巴巴 Offer 的同学：

这门课所包含的知识点：

我是谁

我是王磊，某上市公司技术研发经理，资深面试官，阿里云社区认证专家。前奇虎 360 员工，有着 10 余年的编程工作经验，目前主要负责新员工技术面试和平台架构制订的相关事宜。在接下来两个多月的时间里，让我们一起学习 Java 技术核心和面试要点，一起构建一个完整的 Java 认知体系。

你将获得

1. 收获 Java 技术栈的核心知识点

这个课程几乎涵盖了 Java 技术栈的大部分内容，不止对于面试，在日常的工作中也可以发挥很大的作用。

2. 500 多道实用、权威、高频 Java 面试题详解

这 500 多道面试题，都是目前主流企业使用最高频的面试题库，也都是 Java 版本升级之后，重新整理归纳的最新答案，会让面试者少走很多不必要的弯路。同时每道题都做到了详尽的描述，以确保每个阶段的读者都能看得懂，面试题中的专业短语也都确保提供了必要的介绍，部分难懂的题目也提供了题目解析和示例代码。

3. 理解技术背后的实现原理

死记硬背的内容通常会随着时间的推移很快就忘记，所以在学习一门技术的时候，一定要了解其背后的实现原理，从而构建逻辑上的因果关系，这样才能够记的更久。这门课程会深入浅出地对技术背后的原理进行深入的分析，让读者“知其然，并知其所以然”。

扫描下图中二维码

了解课程详情

▼

点击阅读原文，获取秋招面试攻略，我在阿里内推群等你！！