《互联网大厂 Java 面试：核心知识、框架与中间件大考验》

伟大的攻城狮
38 阅读11分钟

互联网大厂 Java 面试：核心知识、框架与中间件大考验

严肃的面试官坐在桌前，面前放着求职者王铁牛的简历。王铁牛有些紧张地走进面试房间，坐下后，面试正式开始。

第一轮面试

面试官：我们先从 Java 核心知识开始。你能说一下 Java 中基本数据类型有哪些吗？ 王铁牛：可以，Java 基本数据类型有 byte、short、int、long、float、double、char、boolean。 面试官：不错，回答得很准确。那在 Java 里，重载和重写的区别是什么呢？ 王铁牛：重载是指在同一个类中，方法名相同但参数列表不同；重写是子类对父类中允许访问的方法的实现过程进行重新编写，方法名、参数列表和返回类型都要和父类被重写的方法一致。 面试官：非常好，看来你基础很扎实。那 Java 中的多态是如何实现的呢？ 王铁牛：多态主要通过继承、接口和方法重写来实现。父类的引用可以指向子类的对象，这样在调用方法时，会根据实际对象的类型来调用相应的方法。 面试官：回答得很清晰，这一轮你表现得很棒。

第二轮面试

面试官：接下来聊聊 JUC、JVM 和多线程。JUC 包是什么，有什么作用？ 王铁牛：JUC 就是 java.util.concurrent 包，它提供了在并发编程中常用的工具类，比如线程池、并发集合等，可以方便我们进行多线程编程。 面试官：那你说说 JVM 的内存模型是怎样的？ 王铁牛：JVM 内存主要分为堆、栈、方法区等。堆是存储对象实例的地方；栈主要存储局部变量和方法调用的信息；方法区存储类的信息、常量、静态变量等。 面试官：在多线程编程中，什么是线程安全问题，如何解决呢？ 王铁牛：线程安全问题就是多个线程同时访问共享资源时，可能会导致数据不一致等问题。可以使用 synchronized 关键字或者 Lock 接口来解决。 面试官：回答得不错，继续保持。那线程池的好处有哪些呢？ 王铁牛：线程池可以复用线程，减少线程创建和销毁的开销，提高性能，还可以控制线程的数量，避免过多线程导致系统资源耗尽。

第三轮面试

面试官：现在来谈谈一些常用的数据结构和框架。HashMap 的底层实现原理是什么？ 王铁牛：嗯……HashMap 好像是用数组和链表实现的，还有个啥红黑树，反正就是存键值对的。 面试官：看来你知道一些，但说得不太清楚。那 ArrayList 的扩容机制是怎样的？ 王铁牛：这个……好像就是满了就扩容，具体咋扩我有点记不清了。 面试官：我们再聊聊框架，Spring 的 IOC 和 AOP 是什么？ 王铁牛：IOC 就是控制反转，AOP 就是面向切面编程，具体咋实现我不太能说清楚。 面试官：那 Spring Boot 和 MyBatis 结合使用时，有哪些优势呢？ 王铁牛：这个……好像就是用起来方便，具体的我说不明白。

面试官扶了扶眼镜，看着王铁牛说：“今天的面试就到这里，你回去等通知吧。整体来看，你对一些基础的 Java 知识掌握得还可以，在回答简单问题时表现不错，能看出你有一定的知识储备。但对于一些复杂的知识点，比如 HashMap 底层原理、ArrayList 扩容机制以及框架的深入应用等，回答得不够清晰准确，还需要进一步加强学习。我们会综合评估所有面试者的情况，之后会有工作人员跟你联系，祝你好运。”

问题答案

  1. Java 中基本数据类型有哪些：
    • Java 有 8 种基本数据类型，分为 4 类。
    • 整数类型：byte（1 字节）、short（2 字节）、int（4 字节）、long（8 字节）。
    • 浮点类型：float（4 字节）、double（8 字节）。
    • 字符类型：char（2 字节）。
    • 布尔类型：boolean（理论上 1 位，但在 Java 中通常按 1 字节处理）。
  2. Java 里重载和重写的区别：
    • 重载（Overloading）：发生在同一个类中，方法名相同，但参数列表不同（参数的类型、个数、顺序不同），与返回值类型无关。例如：
public class OverloadExample {
    public int add(int a, int b) {
        return a + b;
    }
    public double add(double a, double b) {
        return a + b;
    }
}

- 重写（Overriding）：发生在子类和父类之间，子类重写父类的方法。方法名、参数列表和返回类型必须和父类被重写的方法一致，访问修饰符不能比父类的更严格，抛出的异常不能比父类的更宽泛。例如：

class Parent {
    public void print() {
        System.out.println("Parent");
    }
}
class Child extends Parent {
    @Override
    public void print() {
        System.out.println("Child");
    }
}
  1. Java 中的多态是如何实现的：
    • 多态是指同一个行为具有多个不同表现形式或形态的能力。在 Java 中主要通过以下方式实现：
    • 继承：子类继承父类，重写父类的方法。
    • 接口：类实现接口，实现接口中的方法。
    • 方法调用：父类的引用可以指向子类的对象，在调用方法时，会根据实际对象的类型来调用相应的方法。例如：
class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}
class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}
public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sound(); // 输出 "Dog barks"
    }
}
  1. JUC 包是什么，有什么作用：
    • JUC 即 java.util.concurrent 包，是 Java 为了简化并发编程而提供的工具包。
    • 作用包括：提供了线程池（如 ExecutorService），可以方便地管理线程的创建、执行和销毁；提供了并发集合（如 ConcurrentHashMap），在多线程环境下可以安全地进行操作；提供了锁机制（如 ReentrantLock），可以更灵活地控制线程的同步；还有一些同步工具类（如 CountDownLatch、CyclicBarrier），可以帮助协调多个线程的执行顺序。
  2. JVM 的内存模型是怎样的：
    • JVM 内存主要分为以下几个区域：
    • 堆（Heap）：是 JVM 中最大的一块内存区域，所有对象实例和数组都在这里分配内存。堆是线程共享的，垃圾回收主要就是针对堆进行的。
    • 栈（Stack）：每个线程都有自己的栈，栈中存储局部变量、方法调用的信息等。栈是线程私有的，每个方法在执行时会创建一个栈帧，用于存储局部变量表、操作数栈等信息。
    • 方法区（Method Area）：存储类的信息、常量、静态变量等。方法区也是线程共享的，在 JDK 1.8 之后，方法区被元空间（Metaspace）取代。
    • 程序计数器（Program Counter Register）：记录当前线程执行的字节码的行号指示器，是线程私有的。
    • 本地方法栈（Native Method Stack）：与栈类似，不过它是为执行本地方法（使用 native 关键字修饰的方法）服务的。
  3. 在多线程编程中，什么是线程安全问题，如何解决呢：
    • 线程安全问题是指多个线程同时访问共享资源时，可能会导致数据不一致、脏读、幻读等问题。例如，多个线程同时对一个共享的变量进行读写操作，可能会出现数据覆盖的情况。
    • 解决方法有：
    • 使用 synchronized 关键字：可以修饰方法或代码块，保证同一时刻只有一个线程可以访问被修饰的方法或代码块。例如：
public class SynchronizedExample {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
}

- 使用 Lock 接口：如 ReentrantLock，它比 synchronized 更灵活，可以实现公平锁、可重入锁等。例如：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}
  1. 线程池的好处有哪些：
    • 复用线程：减少线程创建和销毁的开销，提高系统性能。创建和销毁线程需要消耗一定的系统资源，使用线程池可以避免频繁地创建和销毁线程。
    • 控制线程数量：可以根据系统的资源情况和业务需求，合理地控制线程的数量，避免过多线程导致系统资源耗尽。
    • 提高响应速度：当有任务提交时，线程池中如果有空闲线程，可以立即执行任务，而不需要等待线程的创建。
    • 便于管理：线程池可以对线程进行统一的管理，如监控线程的状态、定时执行任务等。
  2. HashMap 的底层实现原理是什么：
    • HashMap 在 JDK 1.8 之前是由数组和链表实现的，JDK 1.8 之后是由数组、链表和红黑树实现的。
    • 数组：也称为哈希桶，每个位置存储一个链表或红黑树的头节点。数组的长度是 2 的幂次方。
    • 链表：当多个键的哈希值相同（发生哈希冲突）时，这些键值对会以链表的形式存储在同一个哈希桶中。
    • 红黑树：当链表的长度超过 8 且数组长度大于 64 时，链表会转换为红黑树，以提高查找效率。红黑树是一种自平衡的二叉搜索树，查找、插入和删除操作的时间复杂度为 O(log n)。
    • 工作原理：当调用 put 方法插入键值对时，首先计算键的哈希值，然后根据哈希值找到对应的哈希桶位置。如果该位置为空，则直接插入新节点；如果该位置已经有节点，则遍历链表或红黑树，查找是否已经存在相同的键，如果存在则更新其值，否则插入新节点。当调用 get 方法获取键对应的值时，同样先计算键的哈希值，找到对应的哈希桶位置，然后遍历链表或红黑树查找该键。
  3. ArrayList 的扩容机制是怎样的：
    • ArrayList 是基于数组实现的动态数组，它的初始容量为 10。
    • 当向 ArrayList 中添加元素时，如果数组已满，就需要进行扩容。扩容的步骤如下：
    • 计算新的容量：新容量为旧容量的 1.5 倍（oldCapacity + (oldCapacity >> 1)）。
    • 创建新数组：根据新容量创建一个新的数组。
    • 复制元素：将旧数组中的元素复制到新数组中。
    • 更新引用：将 ArrayList 内部的数组引用指向新数组。
    • 例如，以下是 ArrayList 扩容的部分源码：
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}
  1. Spring 的 IOC 和 AOP 是什么：
    • IOC（Inversion of Control，控制反转）：是一种设计思想，将对象的创建和依赖关系的管理从代码中转移到外部容器中。在 Spring 中，IOC 容器负责创建对象、管理对象的生命周期和依赖关系。通过 IOC，我们可以降低代码的耦合度，提高代码的可维护性和可测试性。例如，我们可以通过 XML 配置文件或注解来告诉 Spring 如何创建和管理对象。
// 定义一个接口
interface UserService {
    void sayHello();
}
// 实现接口
class UserServiceImpl implements UserService {
    @Override
    public void sayHello() {
        System.out.println("Hello");
    }
}
// 通过 Spring 配置文件或注解将对象交给 Spring 管理

- AOP（Aspect-Oriented Programming，面向切面编程）：是一种编程范式，它允许我们在不修改原有业务逻辑的基础上，对程序进行增强。AOP 的主要概念包括切面（Aspect）、通知（Advice）、连接点（Join Point）和切入点（Pointcut）。切面是包含通知和切入点的模块，通知定义了在何时（如方法执行前、执行后）执行增强逻辑，连接点是程序执行过程中可以插入增强逻辑的点，切入点是一组连接点的集合。例如，我们可以使用 AOP 来实现日志记录、事务管理等功能。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethods() {}

    @Before("serviceMethods()")
    public void beforeServiceMethod() {
        System.out.println("Before service method execution");
    }
}
  1. Spring Boot 和 MyBatis 结合使用时，有哪些优势呢：
    • 简化配置：Spring Boot 提供了自动配置的功能，结合 MyBatis 时，可以减少大量的配置文件。只需要添加相应的依赖，Spring Boot 会自动配置 MyBatis 的数据源、SqlSessionFactory 等。
    • 快速开发：Spring Boot 的 Starter 依赖可以帮助我们快速集成 MyBatis，开发人员可以专注于业务逻辑的实现。同时，MyBatis 的映射文件可以方便地进行 SQL 语句的编写和管理。
    • 微服务支持：Spring Boot 是构建微服务的理想框架，与 MyBatis 结合可以方便地构建基于数据库的微服务。
    • 易于测试：Spring Boot 提供了丰富的测试工具和注解，结合 MyBatis 可以方便地进行单元测试和集成测试。例如，可以使用 @SpringBootTest 注解来启动 Spring Boot 应用进行测试。
avatar
文章
阅读
粉丝