Java最新2021年面试题及答案，汇总版

迈不过友情╰ 2023-01-19 08:06 18阅读 0赞

# Java最新2021年面试题及答案，汇总版 #

其实，博主还整理了，更多大厂面试题，直接下载吧

下载链接：[高清172份，累计 7701 页大厂面试题 PDF][172_ 7701 _ PDF]

### 1、如何判断一个对象是否存活 ###

**判断一个对象是否存活有两种方法：**

**1、** 引用计数法

所谓引用计数法就是给每一个对象设置一个引用计数器，每当有一个地方引用这个对象时，就将计数器加一，引用失效时，计数器就减一。当一个对象的引用计数器为零时，说明此对象没有被引用，也就是“死对象”,将会被垃圾回收、

引用计数法有一个缺陷就是无法解决循环引用问题，也就是说当对象 A 引用对象 B，对象 B 又引用者对象 A，那么此时 A、B 对象的引用计数器都不为零，也就造成无法完成垃圾回收，所以主流的虚拟机都没有采用这种算法。

**2、** 可达性算法（引用链法）

该算法的思想是：从一个被称为 GC Roots 的对象开始向下搜索，如果一个对象到 GC Roots 没有任何引用链相连时，则说明此对象不可用。

**在 Java 中可以作为 GC Roots 的对象有以下几种：**

**1、** 虚拟机栈中引用的对象

**2、** 方法区类静态属性引用的对象

**3、** 方法区常量池引用的对象

**4、** 本地方法栈JNI引用的对象

虽然这些算法可以判定一个对象是否能被回收，但是当满足上述条件时，一个对象比不一定会被回收。当一个对象不可达 GC Root 时，这个对象并不会立马被回收，而是出于一个死缓的阶段，若要被真正的回收需要经历两次标记、

如果对象在可达性分析中没有与 GC Root 的引用链，那么此时就会被第一次标记并且进行一次筛选，筛选的条件是是否有必要执行 finalize() 方法。当对象没有覆盖 finalize() 方法或者已被虚拟机调用过，那么就认为是没必要的。 如果该对象有必要执行 finalize() 方法，那么这个对象将会放在一个称为 F-Queue 的对队列中，虚拟机会触发一个 Finalize() 线程去执行，此线程是低优先级的，并且虚拟机不会承诺一直等待它运行完，这是因为如果 finalize() 执行缓慢或者发生了死锁，那么就会造成 F-Queue 队列一直等待，造成了内存回收系统的崩溃。GC 对处于 F-Queue 中的对象进行第二次被标记，这时，该对象将被移除” 即将回收” 集合，等待回收。

### 2、Int与integer的区别 ###

Integer是int的包装类型。

Int的默认值是0，integer的默认值是null

### 3、Servlet的生命周期？ ###

**1、** 加载：判断servlet实例是否存在，如果不存在，就加载serlvet

**2、** 实例化：

**3、** 初始化

4、服务

5、销毁

### 4、怎么唤醒一个阻塞的线程 ###

如果线程是因为调用了wait()、sleep()或者join()方法而导致的阻塞，可以中断线程，并且通过抛出InterruptedException来唤醒它；如果线程遇到了IO阻塞，无能为力，因为IO是操作系统实现的，Java代码并没有办法直接接触到操作系统。

### 5、虚拟DOM的优劣如何? ###

**优点:**

**1、** 保证性能下限: 虚拟DOM可以经过diff找出最小差异,然后批量进行patch,这种操作虽然比不上手动优化,但是比起粗暴的DOM操作性能要好很多,因此虚拟DOM可以保证性能下限

**2、** 无需手动操作DOM: 虚拟DOM的diff和patch都是在一次更新中自动进行的,我们无需手动操作DOM,极大提高开发效率

**3、** 跨平台: 虚拟DOM本质上是JavaScript对象,而DOM与平台强相关,相比之下虚拟DOM可以进行更方便地跨平台操作,例如服务器渲染、移动端开发等等

**缺点:**

无法进行极致优化: 在一些性能要求极高的应用中虚拟DOM无法进行针对性的极致优化,比如VScode采用直接手动操作DOM的方式进行极端的性能优化

### 6、双亲委派模型是什么？ ###

类加载器具有等级制度但非继承关系，以组合的方式复用父加载器的功能。双亲委派模型要求除了顶层的启动类加载器外，其余类加载器都应该有自己的父加载器。

一个类加载器收到了类加载请求，它不会自己去尝试加载，而将该请求委派给父加载器，每层的类加载器都是如此，因此所有加载请求最终都应该传送到启动类加载器，只有当父加载器反馈无法完成请求时，子加载器才会尝试。

类跟随它的加载器一起具备了有优先级的层次关系，确保某个类在各个类加载器环境中都是同一个，保证程序的稳定性。

### 7、静态嵌套类(Static Nested Class)和内部类（Inner Class）的不同？ ###

Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化，其语法看起来挺诡异的，如下所示。

/
     * 扑克类（一副扑克）
     * @author 骆昊
     *
     */
    public class Poker {
        private static String[] suites = {"黑桃", "红桃", "草花", "方块"};
        private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
    
        private Card[] cards;
    
        /
         * 构造器
         * 
         */
        public Poker() {
            cards = new Card[52];
            for(int i = 0; i < suites.length; i++) {
                for(int j = 0; j < faces.length; j++) {
                    cards[i * 13 + j] = new Card(suites[i], faces[j]);
                }
            }
        }
    
        /
         * 洗牌 （随机乱序）
         * 
         */
        public void shuffle() {
            for(int i = 0, len = cards.length; i < len; i++) {
                int index = (int) (Math.random() * len);
                Card temp = cards[index];
                cards[index] = cards[i];
                cards[i] = temp;
            }
        }
    
        /
         * 发牌
         * @param index 发牌的位置
         * 
         */
        public Card deal(int index) {
            return cards[index];
        }
    
        /
         * 卡片类（一张扑克）
         * [内部类]
         * @author 骆昊
         *
         */
        public class Card {
            private String suite;   // 花色
            private int face;       // 点数
    
            public Card(String suite, int face) {
                this.suite = suite;
                this.face = face;
            }
    
            @Override
            public String toString() {
                String faceStr = "";
                switch(face) {
                case 1: faceStr = "A"; break;
                case 11: faceStr = "J"; break;
                case 12: faceStr = "Q"; break;
                case 13: faceStr = "K"; break;
                default: faceStr = String.valueOf(face);
                }
                return suite + faceStr;
            }
        }
    }

测试代码：

class PokerTest {
    
        public static void main(String[] args) {
            Poker poker = new Poker();
            poker.shuffle();                // 洗牌
            Poker.Card c1 = poker.deal(0);  // 发第一张牌
            // 对于非静态内部类Card
            // 只有通过其外部类Poker对象才能创建Card对象
            Poker.Card c2 = poker.new Card("红心", 1);    // 自己创建一张牌
    
            System.out.println(c1);     // 洗牌后的第一张
            System.out.println(c2);     // 打印: 红心A
        }
    }

> 面试题 - 下面的代码哪些地方会产生编译错误？

class Outer {
    
        class Inner {}
    
        public static void foo() { new Inner(); }
    
        public void bar() { new Inner(); }
    
        public static void main(String[] args) {
            new Inner();
        }
    }

> 注意：Java中非静态内部类对象的创建要依赖其外部类对象，上面的面试题中foo和main方法都是静态方法，静态方法中没有this，也就是说没有所谓的外部类对象，因此无法创建内部类对象，如果要在静态方法中创建内部类对象，可以这样做：

new Outer().new Inner();

### 8、如果对象的引用被置为null，垃圾收集器是否会立即释放对象占用的内存？ ###

**1、** 不会，在下一个垃圾回调周期中，这个对象将是被可回收的。

**2、** 也就是说并不会立即被垃圾收集器立刻回收，而是在下一次垃圾回收时才会释放其占用的内存。

### 9、JVM 出现 fullGC 很频繁，怎么去线上排查问题 ###

**这题就依据full GC的触发条件来做：**

**1、** 如果有perm gen的话(jdk1.8就没了)，要给perm gen分配空间，但没有足够的空间时，会触发full gc。

**2、** 所以看看是不是perm gen区的值设置得太小了。

**3、** `System.gc()`方法的调用

**4、** 这个一般没人去调用吧~~~

**5、** 当统计得到的Minor GC晋升到旧生代的平均大小大于老年代的剩余空间，则会触发full gc(这就可以从多个角度上看了)

**6、** 是不是频繁创建了大对象(也有可能eden区设置过小)(大对象直接分配在老年代中，导致老年代空间不足—>从而频繁gc)

**7、** 是不是老年代的空间设置过小了(Minor GC几个对象就大于老年代的剩余空间了)

### 10、JVM 内存区域 ###

JVM 内存区域主要分为线程私有区域【程序计数器、虚拟机栈、本地方法区】、线程共享区域【JAVA 堆、方法区】、直接内存。

线程私有数据区域生命周期与线程相同, 依赖用户线程的启动/结束 而 创建/销毁(在 Hotspot VM 内, 每个线程都与操作系统的本地线程直接映射, 因此这部分内存区域的存/否跟随本地线程的生/死对应)。

线程共享区域随虚拟机的启动/关闭而创建/销毁。

直接内存并不是 JVM 运行时数据区的一部分, 但也会被频繁的使用: 在 JDK 1.4 引入的 NIO 提供了基于Channel与 Buffer的IO方式, 它可以使用Native函数库直接分配堆外内存, 然后使用DirectByteBuffer 对象作为这块内存的引用进行操作(详见: Java I/O 扩展), 这样就避免了在 Java堆和 Native 堆中来回复制数据, 因此在一些场景中可以显著提高性能。

### 11、原型模式的使用方式 ###

### 12、简述一下你了解的设计模式。 ###

### 13、Java中有几种类型的流？ ###

### 14、Try.catch.finally是必须要存在的吗？ ###

### 15、你熟悉哪些垃圾收集算法？ ###

### 16、为什么HashTable是线程安全的？ ###

### 17、finalize()方法什么时候被调用？析构函数(finalization)的目的是什么？ ###

### 18、用最有效率的方法计算2乘以8？ ###

### 19、多线程应用场景 ###

### 20、List 和 Set 的区别 ###

### 21、实现可见性的方法有哪些？ ###

### 22、堆 ###