Java面试黄金宝典7

已于 2025-03-21 11:18:26 修改
阅读量2.1k 收藏 6
点赞数 86
分类专栏： Java面试黄金宝典 文章标签： java python 开发语言 面试 面经 职场和发展
于 2025-03-21 11:17:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ylfhpy/article/details/146414856
版权

1. 多线程如何避免死锁

  • 定义

死锁指的是两个或多个线程在执行期间，因争夺资源而出现互相等待的状况，致使这些线程无法继续执行。为避免死锁，可从以下方面着手：

  • 按顺序加锁：多个线程对多个锁加锁时，要保证加锁顺序一致。例如线程 A 和线程 B 都需获取锁 L1 和 L2，那么都要按先获取 L1 再获取 L2 的顺序操作。示例代码如下：

java

// 定义两个锁
Object lock1 = new Object();
Object lock2 = new Object();

// 线程 A
Thread threadA = new Thread(() -> {
    synchronized (lock1) {
        System.out.println("Thread A acquired lock1");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (lock2) {
            System.out.println("Thread A acquired lock2");
        }
    }
});

// 线程 B
Thread threadB = new Thread(() -> {
    synchronized (lock1) {
        System.out.println("Thread B acquired lock1");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (lock2) {
            System.out.println("Thread B acquired lock2");
        }
    }
});

threadA.start();
threadB.start();

  • 限时加锁：运用带有超时时间的锁获取方法，像 ReentrantLock 的 tryLock(long timeout, TimeUnit unit) 方法。若在规定时间内未获取到锁，线程可放弃，避免无限期等待。示例代码如下：

java

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

public class TimeLimitedLockExample {
    private final ReentrantLock lock = new ReentrantLock();

    public void doSomething() {
        try {
            if (lock.tryLock(1, TimeUnit.SECONDS)) {
                try {
                    // 执行需要加锁的操作
                    System.out.println("Lock acquired, doing something...");
                } finally {
                    lock.unlock();
                }
            } else {
                System.out.println("Failed to acquire lock within 1 second.");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) {
        TimeLimitedLockExample example = new TimeLimitedLockExample();
        example.doSomething();
    }
}

  • 减少锁的持有时间：尽可能缩短线程持有锁的时长，尽快释放锁，从而降低死锁概率。例如，把无需加锁的操作置于加锁代码块之外。示例代码如下：

java

public class ReduceLockHoldingTime {
    private final Object lock = new Object();

    public void process() {
        // 不需要加锁的操作
        System.out.println("Doing some non - locked work...");

        synchronized (lock) {
            // 需要加锁的操作
            System.out.println("Acquired lock, doing locked work...");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 不需要加锁的操作
        System.out.println("Doing more non - locked work...");
    }

    public static void main(String[] args) {
        ReduceLockHoldingTime example = new ReduceLockHoldingTime();
        example.process();
    }
}

  • 使用资源分级：对资源进行分级，线程按资源等级顺序依次获取资源，避免循环等待。

  • 原理

死锁的产生需满足四个必要条件：互斥条件、请求和保持条件、不剥夺条件和循环等待条件。避免死锁就是要破坏其中一个或多个条件。按顺序加锁和资源分级破坏了循环等待条件；限时加锁破坏了不剥夺条件；减少锁的持有时间可降低死锁发生概率。

  • 要点

  1. 加锁顺序要一致，防止循环等待。
  2. 合理设置锁的超时时间，避免无限期等待。
  3. 尽量缩短锁的持有时间，提升并发性能。
  4. 合理对资源分级，避免循环依赖。

  • 应用

可深入了解死锁的检测和恢复机制，如使用 jstack 工具检测死锁，以及在检测到死锁后如何进行恢复操作。还可研究分布式系统中的死锁问题及解决办法。

2. 多线程的好处以及问题

  • 好处

    1. 提高性能：能充分利用多核处理器资源，并行执行多个任务，提升程序整体性能。例如在数据处理任务中，可将数据分成多部分，每个线程处理一部分，最后合并结果。
    2. 提高响应性：在 GUI 程序里，使用多线程可避免主线程长时间阻塞，保证界面响应性。比如文件下载的 GUI 程序，将下载任务放于子线程执行，主线程可继续响应用户其他操作。
    3. 资源共享：多个线程可共享进程资源，减少资源开销。例如多个线程可共享同一个数据库连接池。

  • 问题

    1. 死锁：如前文所述，多个线程因争夺资源而互相等待。
    2. 竞态条件：多个线程同时访问和修改共享资源，会导致数据不一致。例如多个线程同时对一个计数器进行自增操作，可能使计数器值不准确。
    3. 上下文切换开销：线程切换需保存和恢复上下文信息，会带来一定开销。线程数量过多时，上下文切换开销会显著增加，影响程序性能。

  • 原理

多线程借助操作系统的多任务处理能力，把一个程序分解为多个可并行执行的线程，以此提高程序执行效率。但多个线程同时访问共享资源时，若没有正确的同步机制，就会出现数据不一致问题。线程切换需操作系统调度，会消耗一定时间和资源。

  • 要点

  1. 好处有提高性能、响应性和资源共享。
  2. 问题包括死锁、竞态条件和上下文切换开销。

  • 应用

可了解多线程的同步机制，如 synchronized 关键字、Lock 接口等，以及如何运用这些机制解决多线程问题。还可研究线程池的使用，更好地管理线程资源。

3. 多线程共用一个数据变量需要注意什么？

  • 线程安全：多个线程同时访问和修改共享数据变量时，要保证数据的一致性和完整性。可使用同步机制，如 synchronized 关键字、Lock 接口、Atomic 类等。示例代码如下：

java

import java.util.concurrent.atomic.AtomicInteger;

// 使用 AtomicInteger 保证线程安全
public class SharedVariableExample {
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void increment() {
        counter.incrementAndGet();
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Counter value: " + counter.get());
    }
}

  • 可见性：一个线程对共享数据变量的修改，要确保其他线程能及时看到。可使用 volatile 关键字保证变量的可见性。示例代码如下：

java

public class VolatileExample {
    private static volatile boolean flag = false;

    public static void main(String[] args) {
        Thread writer = new Thread(() -> {
            flag = true;
            System.out.println("Flag is set to true");
        });

        Thread reader = new Thread(() -> {
            while (!flag) {
                // 等待 flag 变为 true
            }
            System.out.println("Flag is now true");
        });

        reader.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        writer.start();
    }
}

  • 避免死锁：使用同步机制时，要留意避免死锁发生。

  • 原理

多个线程同时访问和修改共享数据变量时，若没有正确的同步机制，就会出现数据不一致问题。synchronized 关键字和 Lock 接口能保证同一时间只有一个线程可访问共享数据变量，从而保证数据一致性。volatile 关键字可保证变量的可见性，即一个线程对变量的修改会立即刷新到主内存中，其他线程能立即看到。

  • 要点

  1. 保证线程安全，使用同步机制。
  2. 保证变量的可见性，使用 volatile 关键字。
  3. 避免死锁的发生。

  • 应用

可深入了解并发容器，如 ConcurrentHashMap、CopyOnWriteArrayList 等，这些容器在多线程环境下可安全使用，无需额外的同步机制。

4. 什么是线程池

  • 定义

线程池是一种线程管理机制，它预先创建一定数量的线程，当有任务提交时，从线程池中获取一个空闲线程来执行任务。任务执行完毕后，线程不会销毁，而是返回线程池等待下一个任务。

  • 原理

线程池的核心是一个线程集合和一个任务队列。线程池初始化时会创建一定数量的线程，这些线程会不断从任务队列中获取任务并执行。当任务队列中有任务时，线程会立即执行；当任务队列中没有任务时，线程会进入等待状态。

  • 要点

  1. 预先创建线程，避免频繁创建和销毁线程的开销。
  2. 使用任务队列管理任务，提高任务处理效率。
  3. 可控制线程数量，避免系统资源过度消耗。

  • 应用

可了解 ThreadPoolExecutor 类的使用，它是 Java 中线程池的核心实现类，通过配置不同参数可实现不同类型的线程池。示例代码如下：

java

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Task " + taskId + " is completed.");
            });
        }

        // 关闭线程池
        executor.shutdown();
    }
}

5. 什么是 Spring，有哪些优点

  • 定义

Spring 是一个轻量级的 Java 开发框架，提供了 IoC（控制反转）和 AOP（面向切面编程）等功能，有助于开发者更高效地构建企业级应用。

  • 优点
  1. IoC（控制反转）：将对象的创建和依赖关系管理交给 Spring 容器，降低代码耦合度。例如，一个类需要依赖另一个类的实例，通过 Spring 的 IoC 容器，可将依赖的实例注入到该类中，无需在类内部手动创建依赖对象。
  2. AOP（面向切面编程）：能在不修改原有代码的情况下对程序进行增强，如日志记录、事务管理等。例如，在方法执行前后添加日志记录代码，或在方法执行出现异常时进行事务回滚。
  3. 事务管理：提供统一的事务管理机制，简化事务处理代码。可通过注解或配置文件声明事务属性，Spring 会自动管理事务的开始、提交和回滚。
  4. 集成性好：可与其他框架如 Hibernate、MyBatis 等无缝集成。例如，在 Spring 项目中能方便地使用 Hibernate 进行数据库操作。
  5. 轻量级：Spring 框架的核心非常轻量级，对系统资源消耗较小。

  • 原理

IoC 通过依赖注入（DI）实现，Spring 容器负责创建和管理对象，并将对象间的依赖关系注入到对象中。AOP 通过代理模式实现，Spring 会在目标对象的方法执行前后插入额外代码，实现对目标对象的增强。

  • 要点

  1. IoC 降低代码耦合度。
  2. AOP 实现程序增强。
  3. 统一的事务管理机制。
  4. 良好的集成性。
  5. 轻量级。

  • 应用

可深入了解 Spring 的各种模块，如 Spring MVC、Spring Boot 等，以及它们的使用场景和优势。例如，Spring Boot 可帮助开发者快速搭建 Spring 应用，减少配置工作。

6. ApplicationContext 和 beanfactory 的区别

  1. 加载时机：BeanFactory 在需要获取 Bean 时才加载和实例化 Bean；而 ApplicationContext 在容器启动时就会加载和实例化所有的单例 Bean。
  2. 功能特性：ApplicationContext 除具备 BeanFactory 的基本功能外，还提供更多企业级功能，如国际化支持、事件发布、资源加载等。例如，使用 ApplicationContext 可方便地实现多语言支持，通过发布和监听事件实现组件间的通信。
  3. 使用场景：BeanFactory 适用于资源有限、对内存和性能要求较高的环境；ApplicationContext 适用于大多数企业级应用开发，提供更丰富的功能和更好的开发体验。

  • 原理

BeanFactory 是 Spring 框架的基础接口，定义了 Bean 的基本操作方法。ApplicationContext 是 BeanFactory 的子接口，继承其功能并进行了扩展。

  • 要点

  1. 加载时机不同，ApplicationContext 提前加载单例 Bean。
  2. ApplicationContext 功能更丰富。
  3. 根据不同使用场景选择合适的容器。

  • 应用

可了解 ApplicationContext 的不同实现类，如 ClassPathXmlApplicationContext、FileSystemXmlApplicationContext 等，以及它们的使用方法。

7. Spring Bean 生命周期

Spring Bean 的生命周期包含以下几个阶段：

  1. 实例化：Spring 容器依据 Bean 的定义创建 Bean 的实例，可通过构造函数、工厂方法等方式进行。
  2. 属性赋值：Spring 容器将 Bean 的属性值注入到 Bean 实例中，可通过 XML 配置、注解等方式实现。
  3. 初始化：调用 Bean 的初始化方法，如 InitializingBean 接口的 afterPropertiesSet() 方法或自定义的初始化方法。示例代码如下：

java

import org.springframework.beans.factory.InitializingBean;

public class MyBean implements InitializingBean {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Initializing MyBean with name: " + name);
    }
}

  1. 使用：Bean 可供应用程序使用。
  2. 销毁：当 Spring 容器关闭时，调用 Bean 的销毁方法，如 DisposableBean 接口的 destroy() 方法或自定义的销毁方法。示例代码如下：

java

import org.springframework.beans.factory.DisposableBean;

public class MyDisposableBean implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        System.out.println("Destroying MyDisposableBean");
    }
}

  • 原理

Spring 容器负责管理 Bean 的生命周期，通过反射机制创建 Bean 的实例，并使用依赖注入的方式为 Bean 的属性赋值。在 Bean 的初始化和销毁阶段，Spring 会调用相应的方法，开发者可在这些方法中进行初始化和清理工作。

  • 要点

  1. 实例化、属性赋值、初始化、使用和销毁是 Bean 生命周期的主要阶段。
  2. 可通过实现特定接口或配置自定义方法参与 Bean 的初始化和销毁过程。

  • 应用

可深入了解 Spring 的 Bean 后置处理器，它能在 Bean 生命周期的各个阶段进行干预，实现更复杂的功能。

8. 事务的实现方式

在 Spring 中，事务的实现方式主要有两种：

  • 编程式事务管理：通过编写代码管理事务的开始、提交和回滚。可使用 TransactionTemplate 或 PlatformTransactionManager 实现。示例代码如下：

java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

@Service
public class ProgrammaticTransactionService {
    @Autowired
    private PlatformTransactionManager transactionManager;

    public void doTransaction() {
        TransactionDefinition def = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(def);
        try {
            // 执行数据库操作
            System.out.println("Doing database operations...");
            transactionManager.commit(status);
        } catch (Exception e) {
            transactionManager.rollback(status);
        }
    }
}

  • 声明式事务管理：通过配置文件或注解声明事务属性，Spring 会自动管理事务的开始、提交和回滚。常用注解有 @Transactional。示例代码如下：

java

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class DeclarativeTransactionService {
    @Transactional
    public void doTransaction() {
        // 执行数据库操作
        System.out.println("Doing database operations...");
    }
}

  • 原理

编程式事务管理通过手动调用事务管理器的方法控制事务流程。声明式事务管理通过 AOP 实现，Spring 会在目标方法执行前后插入事务管理代码，实现对事务的自动管理。

  • 要点

  1. 编程式事务管理灵活性高，但代码复杂度高。
  2. 声明式事务管理代码简洁，易于维护，但灵活性相对较低。

  • 应用

可了解不同的事务管理器，如 DataSourceTransactionManager、JtaTransactionManager 等，以及它们的使用场景。

9. 事务的传播级别

  • 定义

事务的传播级别定义了一个事务方法调用另一个事务方法时，事务的行为方式。Spring 提供了 7 种事务传播级别：

  1. PROPAGATION_REQUIRED：若当前存在事务，则加入该事务；若当前没有事务，则创建一个新的事务。这是最常用的传播级别。
  2. PROPAGATION_SUPPORTS：若当前存在事务，则加入该事务；若当前没有事务，则以非事务方式执行。
  3. PROPAGATION_MANDATORY：若当前存在事务，则加入该事务；若当前没有事务，则抛出异常。
  4. PROPAGATION_REQUIRES_NEW：创建一个新的事务，若当前存在事务，则将当前事务挂起。
  5. PROPAGATION_NOT_SUPPORTED：以非事务方式执行，若当前存在事务，则将当前事务挂起。
  6. PROPAGATION_NEVER：以非事务方式执行，若当前存在事务，则抛出异常。
  7. PROPAGATION_NESTED：若当前存在事务，则在嵌套事务内执行；若当前没有事务，则创建一个新的事务。

  • 原理

事务的传播级别通过事务管理器实现，事务管理器会根据传播级别的定义决定如何处理事务。

  • 要点

  1. 不同的传播级别适用于不同的业务场景。
  2. 理解传播级别的含义和行为，正确选择传播级别。

  • 应用

可深入了解嵌套事务的实现原理和使用场景，以及在不同数据库中的支持情况。

10. 事务的嵌套失效

事务嵌套失效通常由以下原因导致：

  • 方法调用问题：在同一个类中，一个非事务方法调用另一个事务方法，事务会失效。因为 Spring 的事务是通过 AOP 代理实现的，同一个类中的方法调用不会经过代理对象，所以事务不会生效。可将事务方法提取到另一个类中来解决此问题。
  • 异常处理问题：若事务方法中捕获了异常但没有重新抛出，事务不会回滚。因为 Spring 的事务管理基于异常触发回滚，若没有异常抛出，事务会正常提交。需确保在事务方法中捕获异常后重新抛出，或在 @Transactional 注解中指定需要回滚的异常类型。
  • 传播级别设置问题：若传播级别设置不当，也会导致事务嵌套失效。例如，使用 PROPAGATION_NOT_SUPPORTED 传播级别，会以非事务方式执行，即使在事务方法中调用也不会生效。需根据业务需求正确设置传播级别。

  • 原理

Spring 的事务管理通过 AOP 代理实现，只有通过代理对象调用事务方法，事务才会生效。事务的回滚基于异常触发，若没有异常抛出，事务会正常提交。

  • 要点

  1. 避免在同一个类中进行非事务方法调用事务方法。
  2. 正确处理异常，确保异常能够被抛出。
  3. 合理设置事务的传播级别。

  • 应用

可了解如何通过 AOP 代理解决同一个类中方法调用事务失效的问题，以及如何使用 @Transactional 注解的 rollbackFor 属性指定需要回滚的异常类型。

 友情提示：本文已经整理成文档，可以到如下链接免积分下载阅读

https://download.youkuaiyun.com/download/ylfhpy/90516132

Java面试黄金宝典：数据结构与算法实现详解
03-27
适合人群：具备一定编程基础，尤其是准备参加 Java 技术面试的研发人员。 使用场景及目标：帮助开发者深入理解常见数据结构和算法的工作原理，掌握其实现技巧，提升解决问题的能力。适用于面试准备和技术能力提升。 ...
Java面试黄金宝典：经典排序算法与数据结构详解
03-31
适合人群：准备参加Java相关岗位面试的技术人员，尤其是希望深入了解排序算法和常见数据结构的求职者。 使用场景及目标：帮助面试者掌握各种排序算法的工作原理、优缺点及适用场景，熟悉常用数据结构的特点和实现...
Java面试黄金宝典12
ylfhpy的博客
03-23 942
同时，不同的类加载器可以实现不同的加载策略，从而满足不同的应用场景需求，像在模块化开发中，每个模块可以使用独立的类加载器来加载自身的类。JVM 调优的核心是根据应用程序的内存使用情况和性能需求，合理分配资源，减少垃圾回收的频率和时间，提高程序的响应速度和吞吐量。Java 堆的实现是基于分代收集的思想，根据对象的存活时间将内存划分为不同的区域，不同的区域采用不同的垃圾回收算法，以提高垃圾回收的效率。例如，在类的方法中调用另一个类的方法时，最初使用的是符号引用，解析阶段会将其转换为实际的内存地址引用。
Java面试黄金宝典19
ylfhpy的博客
03-28 2964
它与快速排序算法有关，利用了快速排序中分区的思想，通过不断缩小搜索范围，只在包含目标元素的那一部分继续进行分区操作，从而避免对整个数组进行排序。通过二分查找在较短的数组上找到一个合适的分割点，使得两个数组分割后的左右两部分元素个数相等，并且左边部分的最大值小于等于右边部分的最小值，从而计算出两个有序数组的中位数。从三维数组的某个角开始，根据元素的大小关系，在三个维度上进行移动，直到找到目标元素或超出数组范围。利用二分查找的思想，通过比较中间元素和最右边元素的大小关系，不断缩小搜索范围，找到翻转点的下标。
Java面试黄金宝典21
ylfhpy的博客
03-29 745
然后找到这个异或结果中任意一位为 1 的位，根据这一位是否为 1 将数组中的元素分为两组，这样这两个只出现一次的数就会被分到不同的组中，最后分别对这两组元素进行异或运算，得到这两个只出现一次的数。对于一个数组，从第一个位置开始，依次将每个元素放到该位置，然后递归地对剩余的元素进行全排列，在递归过程中，若发现当前的选择无法得到有效的解，则回溯到上一步，尝试其他选择。根据异或运算的交换律和结合律，对数组中的所有元素进行异或运算，相同的元素异或结果为 0，最终剩下的就是只出现一次的数。
Java面试黄金宝典18
ylfhpy的博客
03-27 950
定义图算法是用于处理图数据结构的一系列算法。图由顶点和边构成，图算法能够解决图的遍历、最短路径、连通性、拓扑排序等问题。常见图算法深度优先搜索（DFS）：沿着图的深度遍历节点，尽可能深地搜索分支。广度优先搜索（BFS）：从起始节点开始，逐层地访问节点。Dijkstra 算法：用于求解单源最短路径问题。Floyd - Warshall 算法：用于求解所有节点对之间的最短路径问题。Kruskal 算法和 Prim 算法：用于求解最小生成树问题。应用社交网络分析：如好友推荐、社区发现。地图导航。
Java面试黄金宝典25
ylfhpy的博客
03-31 909
它先将原始数据分成多个子序列，对每个子序列进行插入排序，然后逐渐缩小子序列的间隔，直至间隔为 1，此时进行一次普通的插入排序。在内存有限（100M）的情况下，处理三个大于 10G 且每行包含一个数字的文件，找出在三个文件中都出现且出现次数最多的前 10 个数字。冒泡排序是一种简单的排序算法，其基本思想是重复遍历待排序数列，依次比较相邻的两个元素，若顺序错误则交换它们的位置，直到整个数列有序。归并排序：时间复杂度稳定为 O(nlogn)，空间复杂度为 O(n)，排序稳定，但需要额外空间。
Java面试黄金宝典4
ylfhpy的博客
03-19 529
泛型是 Java 编程语言中的一个强大特性，它提供了编译时类型安全检查机制，允许在定义类、接口和方法时使用类型参数。当调用方法时，会将对象的引用复制一份传递给方法的形式参数，方法内部可以通过这个引用修改对象的状态，但不能改变引用本身的值（即不能让引用指向另一个对象）。等）的参数传递是值传递。当调用方法时，会将实际参数的值复制一份传递给方法的形式参数，方法内部对形式参数的修改不会影响实际参数的值。进行了优化，引入了红黑树来处理哈希冲突，当链表长度超过一定阈值时，会将链表转换为红黑树，提高了查找效率。
Java面试黄金宝典17
ylfhpy的博客
03-27 428
图是由顶点和边组成的数据结构。在二维矩阵中，若该矩阵为图的邻接矩阵，矩阵的行和列对应图的顶点，矩阵元素值为 1 表示对应顶点间有边相连。一个合法的无向图邻接矩阵需满足：矩阵为方阵（n * n）；矩阵对称，即。
Java面试黄金宝典10
ylfhpy的博客
03-22 636
Hibernate 是一个全功能的对象关系映射（ORM）框架，将 Java 对象和数据库表进行映射，开发者可以通过操作 Java 对象来完成数据库的增删改查操作，而无需编写 SQL 语句。例如，当测试一个服务类时，该服务类依赖于一个数据库访问类，可以使用 Mockito 模拟数据库访问类的行为，提高测试的效率和准确性。可以根据不同的业务需求选择合适的技术和工具进行组合使用。：Mockito 是一个用于 Java 测试的模拟框架，它可以创建模拟对象，模拟对象的行为和方法调用，方便进行单元测试和集成测试。
Java面试黄金宝典：经典算法与数据结构实现详解
03-26
内容概要：本文档详细介绍了 Java 编程中常见的面试题目及其解决方案，涵盖了二分查找、哈希表、位图、最小堆、自定义排序、快速排序、堆排序、括号匹配等多个经典算法和数据结构的应用。具体包括：如何在增序数组中...
Java面试黄金宝典：经典算法与数据结构详解及其应用场景
03-29
适合人群：具备一定编程基础，尤其是准备 Java 技术面试的研发人员和技术爱好者。 使用场景及目标：①帮助读者掌握常见算法和数据结构的基本概念和实现方法；②提供实际应用场景，加深对算法的理解和运用能力；③为...
Component 与 Bean 的深度解析：详细讲解Component和bean的异同以及与其搭配使用的其他注解及其使用场景
最新发布
lijingxiaov5的博客
04-02 374
Component 与 Bean 的深度解析：详细讲解Component和bean的异同以及与其搭配使用的其他注解及其使用场景
如何用Java实现100以内素数的判断并输出
算法与编程之美
03-30 263
针对平时经常遇到的问题，我们应该先分析，然后将问题划为不同的几部分，对不同的部分分别分析，然后合理使用方法。此问题中我们主要运用了for语句以及判断语句，在看似不难的问题下，其实还需要多加思考，先理清问题的思路，再找到合理的方法。在以后的使用中，我们应该注意此类问题的通性以及这种用法的使用区域，我们还需要注意此类问题的其他解决方法。进行多层嵌套递归将变量i设为100以内从3开始递增的奇数，j设为另一变量作i的被除数，j小于i的算术平方根，在做运算后自动加1，运用判断语句判断i和j的关系，最后输出。
基于srpingboot智慧校园管理服务平台的设计与实现(源码+文档+部署讲解）
qiuyeyyy的博客
03-31 966
管理员在系统中扮演着核心管理角色，其功能涵盖多个重要方面。通过管理员用例图，可以清晰地看到管理员具备对教师信息的全面管理能力，包括教师的入职、离职、信息更新以及权限分配等操作；对学生信息的管理，从学生的入学注册到毕业离校，全程跟踪管理学生的个人信息、学业成绩等；课程管理方面，管理员可以创建、编辑和删除课程，安排课程表，确保教学计划的顺利实施；轮播图信息管理，用于展示校园重要通知、活动信息等，吸引师生关注；此外，管理员还负责学生成绩信息的管理，确保成绩数据的准确性和安全性。
ApplicationContext与BeanFactory的用法区别
zhglhy的专栏
04-01 421
/ 首次调用时初始化。// 自动注入依赖（@Service/@Autowired）：基础 DI vs 全栈支持（AOP、事件、国际化等）。// 自动加载并初始化所有单例 Bean（预加载）// 获取 Bean（懒加载，首次调用时初始化）无需 Spring 的高级功能（如 AOP）。需要注解驱动、AOP、事务管理等高级功能。：支持注解、AOP、国际化、资源访问等。// 适用于资源受限环境（如嵌入式设备）：不支持注解、AOP、事件等高级特性。// 直接获取已初始化的 Bean。// 发布事件（观察者模式）
怎样理解bazel构建的项目
u011091936的博客
04-02 604
当你接触一个 Bazel 项目时，首先查看 WORKSPACE 文件了解外部依赖，然后深入到各个子目录的 BUILD 文件，理解代码是如何被组织成库、二进制文件和测试的。构建过程在受控、隔离的环境中进行，尽可能减少外部环境（如本地安装的库、环境变量）的影响。通过精细的依赖分析、高级缓存（本地和远程共享）、并行执行和增量构建，最大化构建和测试的速度。Bazel 根据目标及其依赖关系，构建完整的依赖图，确定每个目标需要执行哪些具体的构建动作（编译、链接等），并检查依赖是否满足。支持分布式构建和缓存。
【数据结构与算法】Java描述：第六节：排序算法（直接插入排序，希尔排序）
qq_75234423的博客
03-29 956
排序算法简单来说就是把一串数据，以想要的顺序排列起来，例如从大到小，从小到大，这篇文章来介绍一下 常见排序算法中的 插入排序算法。
Dubbo（31）如何优化Dubbo的启动速度？
qq_43012298的博客
04-02 492
减少不必要的依赖：在项目中引入必要的依赖，避免引入不必要的库。优化配置：在中进行必要的优化配置，如设置合理的超时时间和延迟暴露服务。使用并行初始化：通过配置线程池来实现并行初始化，加快服务启动速度。选择高效的注册中心：选择高效的注册中心，如Nacos，来替代ZooKeeper。使用懒加载：通过懒加载来减少启动时的初始化时间。调整服务暴露和引用方式：通过调整服务暴露和引用方式来优化启动速度。通过这些优化措施，可以显著提高Dubbo服务的启动速度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值