vivo面试-Java

一、JAVA八股

1、Java实现线程的三种方式

(1) 继承 Thread 类：

创建一个新类，该类继承自Thread类，并重写run方法。然后创建该类的实例，并调用它的start方法来启动线程。

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread using Thread class");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

(2) 实现 Runnable 接口：

创建一个新类，该类实现Runnable接口，并重写run方法。然后创建该类的实例，并将它传递给一个Thread对象，然后调用Thread对象的start方法来启动线程。

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread using Runnable interface");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

(3) 实现 Callable 接口：

创建一个新类，该类实现Callable接口，并重写call方法。然后可以使用FutureTask类来包装Callable对象，并将FutureTask对象传递给一个Thread对象来启动线程。这种方式的优点是可以获取线程的返回值和异常。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class MyCallable implements Callable {
    public String call() throws Exception {
        return "Thread using Callable interface";
    }
}

public class Main {
    public static void main(String[] args) {
        MyCallable callable = new MyCallable();
        FutureTask futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        
        try {
            String result = futureTask.get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2、Java线程池

（1）线程池参数：

（2）线程池执行流程

3、JAVA的设计模式

• 创建型设计模式：

  • 单例模式（Singleton Pattern）
  • 工厂方法模式（Factory Method Pattern）
  • 抽象工厂模式（Abstract Factory Pattern）
  • 建造者模式（Builder Pattern）
  • 原型模式（Prototype Pattern）

• 结构型设计模式：

  • 适配器模式（Adapter Pattern）
  • 桥接模式（Bridge Pattern）
  • 组合模式（Composite Pattern）
  • 装饰器模式（Decorator Pattern）
  • 外观模式（Facade Pattern）
  • 享元模式（Flyweight Pattern）
  • 代理模式（Proxy Pattern）

• 行为型设计模式：

  • 责任链模式（Chain of Responsibility Pattern）
  • 命令模式（Command Pattern）
  • 解释器模式（Interpreter Pattern）
  • 迭代器模式（Iterator Pattern）
  • 中介者模式（Mediator Pattern）
  • 备忘录模式（Memento Pattern）
  • 观察者模式（Observer Pattern）
  • 状态模式（State Pattern）
  • 策略模式（Strategy Pattern）
  • 模板方法模式（Template Method Pattern）
  • 访问者模式（Visitor Pattern）

4、单例模式为什么是线程安全的

（1）饿汉式（Eager Initialization）：在这种实现中，实例是在类加载时创建的，这确保了线程安全性。

​
public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

​

（2） 双重检查锁定（Double-Checked Locking）：在这种实现中，我们使用synchronized块和两次null检查来确保线程安全性。

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

（3）静态内部类（Static Inner Class）：在这种实现中，我们使用一个静态内部类来持有单例的实例，这利用了类加载机制来保证线程安全性。

public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

 （4）枚举（Enum）：使用枚举是创建单例的最简单和最安全的方法，它本身就是线程安全的，并且能防止反序列化创建新的对象。

public enum Singleton {
    INSTANCE;

    public void doSomething() {
        // ...
    }
}

5、单例模式和工厂模式实现

（1）单例模式（懒汉式，线程安全）

public class Singleton {
    private static volatile Singleton instance;

    // 私有化构造器，防止外部实例化
    private Singleton() {}

    // 提供一个全局的访问点
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

运用场景：

• 配置管理：在一个系统中，配置信息是唯一的，我们可以使用单例模式来保证配置对象的唯一性，避免频繁地创建和销毁。
• 连接池：例如数据库连接池，线程池等，它们管理的资源是有限的，通过单例模式来确保整个应用中有一个统一的资源访问入口。
• 日志记录器：日志记录器通常也会是单例的，以保证日志的连贯性和性能。
• 缓存系统：在一个应用中，缓存对象通常也是唯一的，可以使用单例模式来保证缓存系统的一致性。
• Spring框架中的Bean：在Spring框架中，Bean默认是单例的，这样可以节省资源和提高效率。

 （2） 工厂模式

public interface Product {
    void create();
}

public class ProductA implements Product {
    @Override
    public void create() {
        System.out.println("Product A created");
    }
}

public class ProductB implements Product {
    @Override
    public void create() {
        System.out.println("Product B created");
    }
}

public class ProductFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ProductA();
        } else if ("B".equals(type)) {
            return new ProductB();
        } else {
            throw new IllegalArgumentException("Unknown product type");
        }
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Product productA = ProductFactory.createProduct("A");
        productA.create();

        Product productB = ProductFactory.createProduct("B");
        productB.create();
    }
}

运用场景：

• 创建库和框架：当创建一个库或框架时，你可能希望提供一种方法给使用者创建某个接口的实例，但不想让他们知道具体的实现类。

• UI库：许多UI库使用工厂模式来创建控件。例如，在一个跨平台的UI库中，你可能有一个Button接口和多个具体的实现类（如WindowsButton, MacButton等）。使用工厂模式可以根据运行的操作系统创建正确的按钮类型。

• 支持多种支付方法：例如，如果你正在开发一个电商平台，你可能有一个PaymentProcessor接口和多个具体的实现类（如CreditCardProcessor, PaypalProcessor等）。使用工厂模式可以根据用户选择创建正确的支付处理器。

• 加载和注册插件或驱动程序：应用程序可能使用工厂模式动态地加载和注册插件或驱动程序。

• 数据库访问：应用程序可能需要与多种数据库进行交互。使用工厂模式，可以为不同的数据库创建适当的数据库连接和查询对象

6、Java的几个特性,说说你对Java多态怎么理解

• 面向对象：Java是一个面向对象的编程语言，它支持类和对象的概念，以及继承、封装和多态这些面向对象的基本特性。
• 平台无关：Java程序（字节码）可以在任何装有Java虚拟机（JVM）的设备上运行，无论该设备的操作系统是什么。
• 强类型：在Java中，每个变量都必须有一个预先定义的数据类型，这有助于提高代码的健壮性和可预测性。
• 多线程支持：Java内置了多线程支持，允许你开发高效并发的应用程序。
• 内存管理：Java有一个垃圾收集系统，它自动回收不再使用的内存，这有助于防止内存泄漏。

Java多态实现：

• 方法重载（Overloading） - 编译时多态: 在同一个类中，你可以有多个方法共享同一个名称，但是有不同的参数列表（不同类型或不同数量的参数）。这称为方法重载，它是编译时多态的一种形式。
• 方法重写（Overriding） - 运行时多态: 子类可以提供一个特定实现来重写父类的方法。这是运行时多态的一种形式，因为具体调用哪个方法是在运行时决定的。

7、GC垃圾回收算法，jvm GC如何清除一个对象，判断是否清除该对象的方法、

(1) GC垃圾回收算法

• 标记-清除算法（Mark-Sweep）

  • 标记阶段：标记所有从根节点可达的对象。
  • 清除阶段：清除所有未被标记的对象。

• 标记-整理算法（Mark-Compact）

  • 标记阶段：标记所有从根节点可达的对象。
  • 整理阶段：将所有活动对象移动到内存的一端，然后清除剩余的内存空间。

• 分代收集算法（Generational Collection）

  • 将内存分为几个代（如年轻代和老年代）并根据对象的年龄对其进行不同的垃圾收集策略。

• 引用计数算法（Reference Counting）

  • 这种算法在每个对象中维护一个引用计数，当计数为零时，对象被视为垃圾。

(2) 判断是否应清除一个对象

• 可达性分析

  • 从一组根对象开始，如果一个对象不能通过任何引用链从根对象到达，它就是不可达的，因此可以被回收。

• 引用类型

  • Java 提供了几种不同的引用类型（强引用、软引用、弱引用和虚引用），它们对垃圾收集的影响也是不同的。
  • 强引用：只要对象有强引用指向它，它就不会被回收。
  • 软引用：对象只有软引用时，它可以被GC回收，但通常是在内存不足的时候才会被回收。
  • 弱引用：对象只有弱引用时，它会更容易被GC回收。
  • 虚引用：对象有虚引用时，基本不影响其生命周期，虚引用主要用于跟踪对象被GC回收的活动。

• 循环引用

  • 即使对象之间存在循环引用，但如果整个引用链不可达，那么这些对象仍然可以被视为垃圾。

• finalize 方法

  • 对象提供了 finalize 方法来进行清理操作。这个方法会在对象被GC回收前被调用一次。但是要注意，这个方法不推荐使用，因为它可以拖延对象的回收时间，并且有可能导致对象复活。

8、JVM内存

• 方法区（Method Area）

  • 类信息存储：这里存储了每一个加载到JVM中的类的信息，包括类的元数据、静态成员变量、常量池等。
  • 运行时常量池：这部分内存包含了编译时期生成的各种字面量和符号引用，这些内容会在类加载后进入方法区的运行时常量池中。

• 堆区（Heap）

  • 对象存储：这是JVM管理的最大一块内存区域，几乎所有的对象实例以及数组都在这里分配内存。
  • 垃圾收集区：这个区域是垃圾收集器工作的重点区域。
  • 年轻代（Young Generation）：新创建的对象首先分配在年轻代，这个区域分为一个Eden区和两个Survivor区（S0和S1）。
  • 老年代（Old Generation或Tenured Generation）：对象在年轻代经过一定次数的垃圾收集后（如果还存活），会被移到老年代。

• 栈区（Stack）

  • 局部变量表：用于存储方法中的局部变量。
  • 操作数栈：一个基于栈的计算区域，用于存储方法执行过程中的中间结果。
  • 动态链接和返回地址：存储了方法执行的动态链接信息和返回地址信息。

• 程序计数器（Program Counter Register）

  • 当前线程执行字节码的行号指示器：每个线程都有一个程序计数器，用于记录当前线程正在执行的字节码指令的地址。

• 本地方法栈（Native Method Stack）

  • 本地方法调用：与栈区相似，但是它是为本地方法（使用native关键字声明的方法）服务的

9、Java内存泄漏怎么造成的，怎么排查

在Java中，内存泄漏通常是由于以下几种原因造成的：

• 对象的长时间引用：一些对象被长时间持有引用，导致它们不能被垃圾回收器回收。
• 集合类的不当使用：比如往集合类（如HashMap）中添加对象但不移除它们。
• 监听器未被正确移除：注册了一些监听器或回调函数但没有正确地注销它们。
• 静态字段的滥用：静态字段的生命周期与类的生命周期相同，如果静态字段持有对象的引用，那么这个对象就不会被回收，直到程序结束。
• 线程泄漏：创建了大量线程但没有正确地关闭它们，这也会造成内存泄漏。
• 内部类和外部类之间的引用：非静态内部类会持有外部类的引用，如果不当使用，可能会导致内存泄漏。

排查Java内存泄漏，通常可以使用以下几种方法：

• 使用内存分析工具：

  这些工具可以帮助你监视Java应用程序的内存使用情况，找出内存泄漏的来源。

  • VisualVM
  • Eclipse Memory Analyzer (MAT)
  • JProfiler

• 查看Heap Dump： 通过获取Heap Dump来分析哪些对象占用了大量的内存和它们的引用链。可以使用jmap工具或者内存分析工具来获取Heap Dump。

• 分析GC日志： 通过分析GC日志来查看对象的分配和回收情况。你可以使用-XX:+PrintGCDetails和-XX:+PrintGCTimeStamps等JVM选项来启用GC日志。

• 代码审查： 手动检查代码中可能存在内存泄漏的地方，特别是注意那些长时间持有对象引用的地方。

• 创建测试用例： 创建特定的测试用例来复现潜在的内存泄漏情况，然后使用内存分析工具来分析内存使用情况。

• 使用监控系统： 在生产环境中使用监控系统来监控Java应用程序的内存使用情况，这样可以及时发现内存泄漏问题。

10、Java怎么实现线程同步

（1）synchronized 关键字

public void method() {
    synchronized(this) {
        // ... 同步代码块
    }
}

（2）CountDownLatch可以用来实现一个或多个线程等待其他线程完成操作。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    private final CountDownLatch latch = new CountDownLatch(1);

    public void method() throws InterruptedException {
        latch.await();
        // ... 受保护的代码块
    }

    public void release() {
        latch.countDown();
    }
}

11、Java有哪些集合，分别作用于哪些场景

（1）List 接口：

ArrayList

• 场景：动态数组实现，适用于随机访问元素的场景。
• 特点：支持快速随机访问，但插入和删除元素（尤其是在列表中间）可能较慢。

LinkedList

• 场景：双向链表实现，适用于频繁插入和删除元素的场景。
• 特点：插入和删除元素快速，但随机访问元素较慢

（2）Set 接口

HashSet

• 场景：无序集合，适用于存储不允许重复的元素的场景。
• 特点：提供快速的添加、删除和查找操作，但不保证元素的顺序。

TreeSet

• 场景：有序集合，适用于需要按某种顺序存储元素的场景。
• 特点：元素按照自然顺序或自定义比较器的顺序进行排序。

（3）Queue 接口

LinkedList

• 场景：可以作为队列使用，适用于FIFO（先进先出）场景。
• 特点：实现了 Queue 接口，可以作为双端队列使用。

PriorityQueue

• 场景：优先队列，适用于需要根据元素的自然顺序或自定义比较器排序的场景。
• 特点：元素可以按照优先级进行排序和检索。

Map 接口

HashMap

• 场景：无序映射，适用于需要快速查找键-值对的场景。
• 特点：提供快速的添加和查找操作，但不保证键的顺序。

TreeMap

• 场景：有序映射，适用于需要根据键的自然顺序或自定义比较器排序的场景。
• 特点：键按照自然顺序或自定义比较器的顺序进行排序。

LinkedHashMap

• 场景：保持插入顺序的映射，适用于需要记录键-值对插入顺序的场景。
• 特点：保持键的插入顺序。

12、Java有哪些引用类型,Java里一个对象没有被引用了会被丢弃吗？什么时候丢弃？

(1) 强引用（Strong Reference）:常见的对象引用就是强引用，即创建一个对象并赋值给一个变量。

Object obj = new Object();

(2) 软引用（Soft Reference）软引用可以让对象在内存不足时被垃圾收集器回收。

SoftReference