Fullstack 面试复习笔记：Java 基础语法 / 核心特性体系化总结

news2025/11/10 18:35:10

Fullstack 面试复习笔记：Java 基础语法 / 核心特性体系化总结

上一篇笔记：Fullstack 面试复习笔记：操作系统 / 网络 / HTTP / 设计模式梳理

目前上来说，这个系列的笔记本质上来说，是对不理解的知识点进行的一个梳理，而不是是更细节的八股文备战。可以基于这个蓝图做延伸，去找对应的八股文，但是为了方便更快地过一遍面试准备——我基本上做好一周内要ready的打算，就不包含八股文了……

基础结构 & 语法机制

基础类型（primitive type）

这里简单的回顾一下primitive type的基础，java中有的primitive type有：

类型字节数默认值范围 or 特性
byte10-128 ~ 127
short20-32,768 ~ 32,767
int40-2^31 ~ 2^31-1（默认整数类型）
long80L-2^63 ~ 2^63-1（必须加 L 后缀）
float40.0f单精度（精度约为 7 位）
double80.0d双精度（默认浮点数，约 15 位精度）
char2‘\u0000’Unicode 字符编码（不是 ASCII）
boolean1falsetrue / false
  • 自动装箱 & 拆箱（autuboxing/unboxing）

    • Java会对 -128 到 127 这个区间的数字进行缓存，如：

      Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true

Integer a = 128;
Integer b = 128;
System.out.println(a == b); // false

      除了 byte, boolean 和 float/ double 外的其他wrapper clas都适用

    • 装箱对象的比较必须用 .equals()，不要用 ==

常用集合

  • HashMap vs Hashtable vs ConcurrentHashMap（线程安全机制）

    • HashMap：非线程安全，性能好，适合单线程或通过 Collections.synchronizedMap、ConcurrentHashMap 实现安全
    • Hashtable：线程安全，但通过方法加锁（synchronized），效率低，已过时
    • ConcurrentHashMap : 线程安全, 最新实现，代替 Hashtable

  • ArrayList vs LinkedList

    重点放在操作复杂度（时间复杂度）上

  • HashSet, TreeSet, TreeMap

    特性HashSetTreeSetTreeMap
    类型Set（不重复元素）Set（有序、不重复元素）Map（有序键值对）
    底层结构HashMapTreeMap（基于红黑树）红黑树（Red-Black Tree）
    是否排序❌ 否（无序）✅ 是（元素有序）✅ 是（key 有序）
    允许 null✅ 允许一个 null 元素✅ 默认支持一个 null 元素（但不可比较）✅ key 允许 null（但排序会报错）
    插入性能🚀 快（O(1) 平均）🐢 较慢（O(log n)，因排序）🐢 较慢（O(log n)，因排序）
    是否线程安全❌ 否❌ 否❌ 否

  • Comparable vs Comparator

    方式用法场景说明
    Comparable实现类内部排序（默认规则）实现 compareTo() 方法，修改类本身，例如：User implements Comparable<User>
    Comparator外部传入排序规则（灵活定制）传入 TreeSet 或 TreeMap 构造器，可避免修改类

  • BigDecimal

    BigDecimal bd = new BigDecimal("123.45");
// intVal = 12345
// scale = 2
// => intVal × 10^(-scale) = 123.45

对象机制

  • equals/hashCode 原则

    若两个对象通过 equals() 判断为相等，则它们的 hashCode() 也必须相等；否则会破坏集合类（如 HashMap、HashSet）的查找一致性

  • Java 内存结构 + 对象引用类型（强/软/弱/虚）

    类型是否参与GC前回收典型用途特点说明
    强引用❌ 不可回收常规对象引用默认引用类型，只有失去所有强引用才会GC
    软引用✅ 内存不足时回收缓存（如图片）有可能在OOM前被GC，适合做内存敏感缓存
    弱引用✅ 下一次GC就回收ThreadLocal等生命周期短，不影响GC回收
    虚引用✅ 随时可回收跟踪对象回收无法通过它访问对象，需配合 ReferenceQueue

异常机制

  • checked vs unchecked

    Checked 异常是受检异常，编译器要求你显式处理（try-catch 或 throws）；而 Unchecked 异常是运行时异常，可以不处理，但最好处理

    异常类型是否强制捕获继承体系使用场景示例
    Checked✅ 是Exception（但非 RuntimeException）受控环境、外部 IO、数据库等IOException, SQLException
    Unchecked❌ 否RuntimeException 及其子类程序逻辑错误、空指针等NullPointerException, IndexOutOfBoundsException

  • try-with-resources

    try-with-resources 是 Java 7 引入的新语法，用于在 try 块中自动关闭资源（实现了 AutoCloseable 接口的对象），避免 finally 中手动 close() 的繁琐与遗漏

    try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line = reader.readLine();
    System.out.println(line);
} catch (IOException e) {
    e.printStackTrace();
}

注解机制（Annotation）

  • 基本注解：@Override, @SuppressWarnings

  • 自定义注解

  • 元注解（Retention Policy）

    用于修饰注解本身，控制其生命周期、作用范围、能否继承等

    元注解含义（作用）
    @Retention注解保留到何时（编译时 / 运行时 / 类加载时）
    @Target注解可以放在哪些位置（类 / 方法 / 字段等）
    @Documented是否包含在 Javadoc 中
    @Inherited是否允许子类继承注解
    @Repeatable是否允许注解重复使用（Java 8+）

    提供一个案例简单说明一下：

    @Retention(RetentionPolicy.RUNTIME)  // 注解可以在运行时通过反射读取
@Target(ElementType.METHOD)          // 注解只能贴在方法上
public @interface MyCustomAnno {     // 自定义注解本体
    String value();
}

  • 常见使用场景：Spring 注解驱动

Java 8+ 核心特性

Lambda 表达式

是 函数式接口 的 实例 语法糖：简化匿名内部类

// comparator
List<String> names = Arrays.asList("Zhang", "Li", "Wang", "Zhao");

names.sort((a, b) -> a.compareTo(b));
names.sort((a, b) -> b.compareTo(a));

// runnable
Runnable task = () -> System.out.println("Hello from thread!");
Thread thread = new Thread(task);
thread.start();

// forEach
List<String> list = Arrays.asList("apple", "banana", "cherry");

list.forEach(item -> System.out.println("水果：" + item));

函数式接口（Functional Interface）

只包含一个抽象方法的接口，用于支持 Lambda 表达式，使方法行为可以像“函数”一样被传递

接口名参数返回用途示例说明
Runnable无无无参任务() -> System.out.println("Run")
Supplier<T>无T提供一个对象() -> "Hello"
Consumer<T>T无消费一个对象（只执行动作）(x) -> System.out.println(x)
Function<T,R>TR接收一个 T 返回一个 R(x) -> x.length()
Predicate<T>T布尔判断某个条件是否成立(x) -> x > 0
BiFunction<T,U,R>T,UR接收两个参数返回一个结果(a,b) -> a + b

出了上面的 Runnable 的例子，这里再提供一个 Comparator 的例子：

@FunctionalInterface
public interface StudentComparator {
    int compare(Student s1, Student s2);

    default void log() {
        System.out.println("Comparing students...");
    }

    static void staticHelper() {
        System.out.println("Static helper inside interface");
    }
}

public class Student {
    String name;
    int age;
    double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    // ...
}

List<Student> students = Arrays.asList(
    new Student("Alice", 20, 85.5),
    new Student("Bob", 22, 90.0),
    new Student("Charlie", 19, 78.0)
);

// 使用 Lambda 表达式来定义比较规则（按年龄升序）
students.sort((s1, s2) -> s1.age - s2.age);

// 也可以封装成函数式接口
StudentComparator byScore = (s1, s2) -> Double.compare(s1.score, s2.score);
students.sort(byScore::compare);

// 对比传统开发，即不使用lambda和function interface的实现
// 方式一：匿名内部类（匿名实现 Comparator）
students.sort(new Comparator<Student>() {
    @Override
    public int compare(Student s1, Student s2) {
        return s1.age - s2.age;
    }
});

// 方式二：单独定义一个类
students.sort(new StudentScoreComparator()); // 比分数

// 单独定义一个类：实现 Comparator<Student>
class StudentScoreComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        return Double.compare(s1.score, s2.score);
    }
}

可以看到，通过lambda+functional interface的方式，代码实现变得更加的简洁可读。

推荐做法是添加 @FunctionalInterface 的注解，这样Java可以更好的做验证。如果不加的话，在interface中只有一个abstract method的情况下，Java也可以自动推导当前interface是 @FunctionalInterface

Stream API

依旧使用上面的 Student 作为案例：

List<Student> students = List.of(
    new Student("Alice", 18, 90),
    new Student("Bob", 20, 75),
    new Student("Carol", 19, 90),
    new Student("David", 20, 85)
);

  • 中间操作：map, filter, sorted, distinct

    // 转为名字列表
List<String> names = students.stream()
    .map(student -> student.name)
    .collect(Collectors.toList());

// 过滤出成绩 ≥ 85 的学生
List<Student> topStudents = students.stream()
    .filter(s -> s.score >= 85)
    .collect(Collectors.toList());

// 按年龄升序排序
List<Integer> distinctScores = students.stream()
    .map(s -> s.score)
    .distinct()
    .collect(Collectors.toList());

// 移除重复分数
List<Integer> distinctScores = students.stream()
    .map(s -> s.score)
    .distinct()
    .collect(Collectors.toList());

  • 终端操作：collect, reduce, count

    // 收集成列表
List<String> names = students.stream()
    .map(s -> s.name)
    .collect(Collectors.toList());

// 统计人数
long count = students.stream().count();

// 累加所有分数
int totalScore = students.stream()
    .map(s -> s.score)
    .reduce(0, Integer::sum); // or (a, b) -> a + b

  • 分组统计：Collectors.groupingBy, partitioningBy

    虽然分组也是 collect 的一部分，但它使用了 Collectors.groupingBy，语义更复杂，因此单独列出

    // 按分数分组
Map<Integer, List<Student>> groupedByScore = students.stream()
    .collect(Collectors.groupingBy(s -> s.score));

// 按年龄分组，并统计每组人数
Map<Integer, Long> ageCountMap = students.stream()
    .collect(Collectors.groupingBy(s -> s.age, Collectors.counting()));

// 按分数分组后，每组提取名字列表
Map<Integer, List<String>> scoreToNames = students.stream()
    .collect(Collectors.groupingBy(
        s -> s.score,
        Collectors.mapping(s -> s.name, Collectors.toList())
    ));

总结一下输出结果

场景代码片段输出类型
转字段列表map(...).collect(toList())List<T>
条件过滤filter(...).collect(toList())List<T>
分组统计groupingBy(..., counting())Map<K, Long>
分组后映射groupingBy(..., mapping(..., toList()))Map<K, List<V>>
规约求和reduce(0, Integer::sum)int
去重字段map(...).distinct()Stream<T>

Optional

  • Optional.of, Optional.empty, orElse, orElseGet, map
  • 避免 NPE、链式调用

举个例子：

public class User {
    private Address address;
    public Optional<Address> getAddress() {
        return Optional.ofNullable(address);
    }
}

public class Address {
    private String city;
    public Optional<String> getCity() {
        return Optional.ofNullable(city);
    }
}

// 传统写法
String city = null;
if (user != null && user.getAddress() != null && user.getAddress().getCity() != null) {
    city = user.getAddress().getCity();
}

// 使用Optional
String city = user.getAddress()
    .flatMap(Address::getCity)   // 注意是 flatMap，因为返回值是 Optional
    .orElse("Unknown");

补充一个常见的错误用法 vs 正确用法：

Optional<String> name = Optional.of("Tom");
if (name.isPresent()) {
    System.out.println(name.get()); // 虽然可以，但违背了 Optional 的设计初衷
}

// 更推荐写成
name.ifPresent(System.out::println);

// 或者
String result = name.orElse("Default");

接口默认方法 & 静态方法

  • default method 用于向后兼容

    interface中可以使用 default 添加新方法，继承原本的interface 的client端不需要实现新的 default 方法，需要使用对应方法的新用户也可以实现 overload

  • static method in interfaces

这里用截图举个例子说明比较简单：

ConcurrentHashMap（Java 8 重构点）

  • Java 8 改成了分段锁 + CAS（Compare-And-Swap，一种乐观锁，比起之前的 ReentrantLock 相比重试更快，也不会抢锁），取消了 Segment

    具体修改包括：

    特性Java 8 做了什么
    ❌ 取消 Segment不再有 Segment 数组，直接用 Node[] table
    ✅ 引入 CAS + synchronized取代 ReentrantLock 的粒度控制
    ✅ 链表转红黑树当链表长度超过阈值（默认 8）转为红黑树，提高查询效率（O(n) → O(log n)）
    ✅ 支持 computeIfAbsent()、forEach() 等并发友好新方法
    ✅ 更轻量的锁机制每个 bucket（table[i]）单独加锁，或使用 CAS，无需全表锁定

  • computeIfAbsent 是高频问点

    • 工作流程：
      1. 如果 key 不存在，则执行 Lambda，生成新值（如 new ArrayList<>()）；
      2. 用 CAS 或 synchronized（针对单个桶） 安全地插入；
      3. 避免了 putIfAbsent() + get() 的双查找问题。
    • 高频面试陷阱：
      • Lambda 表达式可能会被重复调用（并发争抢下），但只有一个结果会被真正放进去；
      • 所以 Lambda 中逻辑要无副作用（side-effect-free）；

  • 与 synchronizedMap 对比

    特性ConcurrentHashMapCollections.synchronizedMap
    锁机制分段+CAS+局部 synchronized粗粒度同步（整个 Map 加锁）
    性能高并发读写表现优异写操作竞争大，性能差
    Null 支持❌ 不支持 key/value 为 null✅ 支持 null
    Java 推荐✅ 推荐🚫 已过时（在并发环境）

JUC

核心线程池类（基础构建块）

  • ExecutorService：线程池接口，支持任务提交、关闭、回收线程资源
  • Future：用于获取异步任务的返回结果，支持取消任务
  • Callable<T>：可返回结果并抛出异常的任务（对比 Runnable）

并发工具类（线程同步控制）

  • CountDownLatch：等待多个线程完成，适合“倒计时”场景（如等待所有子任务执行完毕）
  • CyclicBarrier：多个线程在屏障点等待，适合阶段性同步（如并行计算后统一合并）
  • Semaphore：控制并发线程数（如数据库连接池限流）
  • ReentrantLock：可重入锁，支持公平/非公平机制，可精细控制加锁与释放
  • ThreadLocal：为每个线程维护独立变量副本，常用于用户上下文、连接隔离

Java 8+ 并发增强（异步编排）

  • CompletableFuture：链式异步任务编排工具，支持组合多个异步结果，替代传统 Future
  • ForkJoinPool：用于递归任务分割并行计算，Java 8 中 parallelStream() 默认使用
  • parallelStream()：简化并行流处理，使用 ForkJoinPool.commonPool() 背后实现

线程池实现与调优点

  • ThreadPoolExecutor：线程池核心实现类，支持核心线程数、最大线程数、队列容量、拒绝策略等参数配置
  • ScheduledExecutorService：定时任务调度器，支持延迟/周期执行任务，替代老旧的 Timer

Java 内存可见性与原子性关键词（高频知识点）

  • volatile：保证变量可见性，不保证原子性（常用于双重检查锁 DCL 中）
  • synchronized：内置锁，保证原子性和可见性，支持对象级与类级加锁

反射 / 动态代理（Reflection & Dynamic Proxy）

基础 API（Class 对象）

  • Class<?> clazz = Class.forName("com.example.MyClass")
  • clazz.getDeclaredFields() / getDeclaredMethods()：反射读取字段和方法
  • field.setAccessible(true)：访问私有字段
  • 常用于通用框架 / 动态注册 / 对象转换等场景

动态代理（Proxy）

  • Proxy.newProxyInstance(classLoader, interfaces, handler)：生成实现接口的代理对象

  • InvocationHandler 接口用于定义方法增强逻辑

    public class MyHandler implements InvocationHandler {
    private final Object target;
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // before
        Object result = method.invoke(target, args); // 调用真实方法
        // after
        return result;
    }
}

  • 🌟 用于 AOP、RPC Stub 构造、权限校验、日志追踪等

  • 只能代理 接口（类代理推荐用 CGLIB）

SPI 机制（Service Provider Interface）

  • Java 原生插件机制，用于服务发现与自动加载
  • 使用方式：
    • META-INF/services/com.example.InterfaceName 文件中声明实现类
    • 加载方式：ServiceLoader.load(InterfaceName.class)
  • 示例：JDBC 驱动加载、Spring Boot Starter 自动注册、Netty Codec 插件

注解处理器 / 自定义注解

这部分和上面的有一点重复，算是稍微多加一点补充吧……

注解元注解（原注解）

  • @Target：注解可用于哪些位置（如 TYPE, METHOD, FIELD）

  • @Retention：注解保留到哪个阶段（SOURCE、CLASS、RUNTIME）

    @Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogExecutionTime {}

注解处理器（Annotation Processor）

  • 编译期注解处理工具（APT），可用于代码生成
  • 实现 javax.annotation.processing.Processor 或使用 AbstractProcessor
  • 常见场景：Lombok、MapStruct、Dagger、Spring Configuration Processor

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2400741.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

安卓Compose实现鱼骨加载中效果

安卓Compose实现鱼骨加载中效果

安卓Compose实现鱼骨加载中效果 文章目录 安卓Compose实现鱼骨加载中效果背景与简介适用场景Compose骨架屏与传统View实现对比Shimmer动画原理简介常见问题与优化建议参考资料 本文首发地址 https://h89.cn/archives/404.html 背景与简介 在移动应用开发中&#xff0c;加载中占…
阅读更多...
【使用JAVA调用deepseek】实现自能回复

【使用JAVA调用deepseek】实现自能回复

在Spring Boot系统中接入DeepSeek服务&#xff0c;并将其提供给用户使用&#xff0c;通常需要以下步骤&#xff1a; 一、准备工作 &#xff08;1&#xff09;注册DeepSeek开发者账号 访问DeepSeek官网&#xff0c;注册并创建应用&#xff0c;获取API Key。 API文档&#xff1…
阅读更多...
【Linux系列】rsync命令详解与实践

【Linux系列】rsync命令详解与实践

博客目录 高效文件同步的艺术&#xff1a;rsync 命令详解与实践rsync 命令解析rsync 的核心优势1. 增量传输&#xff1a;效率的革命2. 归档模式(-a)&#xff1a;保留文件所有属性3. 人性化输出(-h)与进度显示(--progress) 实际应用场景1. 文件备份与版本管理2. 跨设备同步3. 大…
阅读更多...
Windows系统工具：WinToolsPlus 之 SQL Server Suspect/质疑/置疑/可疑/单用户等 修复

Windows系统工具：WinToolsPlus 之 SQL Server Suspect/质疑/置疑/可疑/单用户等 修复

数据库在数据库列表状态是 Suspect/质疑/置疑/可疑/单用户等 非正常状态时&#xff0c; 使用WinToolsPlus 数据库页签 先设置 数据源 &#xff0c; 选择 需要清理日志的数据库&#xff0c; 点击 Suspect/质疑/置疑/可疑/单用户 按钮即可进修复。 修复过程会有数据库服务停止和启…
阅读更多...
C++——智能指针 unique_ptr

C++——智能指针 unique_ptr

unique_ptr的实现原理&#xff1a;简单粗暴的防拷贝 目录 一、使用C11中的新用法unique_ptr 二、使用c11模拟实现 三、使用c98特性实现 四、模拟实现unique_ptr 五、发现问题 一、使用C11中的新用法unique_ptr 由于限制了拷贝以及赋值 导致缺陷&#xff1a;unique_ptr管理…
阅读更多...
【Python训练营打卡】day43 @浙大疏锦行

【Python训练营打卡】day43 @浙大疏锦行

DAY 43 复习日 作业&#xff1a; kaggle找到一个图像数据集&#xff0c;用cnn网络进行训练并且用grad-cam做可视化 进阶&#xff1a;并拆分成多个文件 我选择的是music_instruments 链接&#xff1a;Musical Instruments (kaggle.com) #导包 import torch import torch.nn as…
阅读更多...
1-【源码剖析】kafka核心概念

1-【源码剖析】kafka核心概念

从今天开始开始在csdn上记录学习的笔记&#xff0c;主要包括以下几个方面&#xff1a; kafkaflinkdoris 本系列笔记主要记录Kafka学习相关的内容。在进行kafka源码学习之前&#xff0c;先介绍一下Kafka的核心概念。 消息 消息是kafka中最基本的数据单元&#xff0c;由key和…
阅读更多...
思科设备网络实验

思科设备网络实验

一、 总体拓扑图 图 1 总体拓扑图 二、 IP地址规划 表格 1 接口地址规划 设备名称 接口/VLAN IP 功能 PC0 VLAN580 10.80.1.1 访问外网 PC1 VLAN581 10.80.2.1 访问外网 PC2 Fa0 20.80.1.100 端口镜像监控流量 PC3 VLAN585 10.80.6.1 远程登陆多层交换机0…
阅读更多...
AWS之数据分析

AWS之数据分析

目录 数据分析产品对比 1. Amazon Athena 3. AWS Lake Formation 4. AWS Glue 5. Amazon OpenSearch Service 6. Amazon Kinesis Data Analytics 7. Amazon Redshift 8.Amazon Redshift Spectrum 搜索服务对比 核心功能与定位对比 适用场景 关键差异总结 注意事项 …
阅读更多...
C# Onnx 动漫人物头部检测

C# Onnx 动漫人物头部检测

目录 效果 模型信息 项目 代码 下载 参考 效果 模型信息 Model Properties ------------------------- date&#xff1a;2024-10-19T12:32:20.920471 description&#xff1a;Ultralytics best model trained on /root/datasets/yolo/anime_head_detection/data.yaml au…
阅读更多...
【Ragflow】24.Ragflow-plus开发日志：增加分词逻辑，修复关键词检索失效问题

【Ragflow】24.Ragflow-plus开发日志：增加分词逻辑，修复关键词检索失效问题

概述 在RagflowPlus v0.3.0 版本推出之后&#xff0c;反馈比较多的问题是&#xff1a;检索时&#xff0c;召回块显著变少了。 如上图所示&#xff0c;进行检索测试时&#xff0c;关键词相似度得分为0&#xff0c;导致混合相似度(加权相加得到)也被大幅拉低&#xff0c;低于设定…
阅读更多...
Zookeeper 集群部署与故障转移

Zookeeper 集群部署与故障转移

Zookeeper 介绍 Zookeeper 是一个开源的分布式协调服务&#xff0c;由Apache基金会维护&#xff0c;专为分布式应用提供高可用、强一致性的核心基础能力。它通过简单的树形命名空间&#xff08;称为ZNode树&#xff09;存储数据节点&#xff08;ZNode&#xff09;&#xff0c;…
阅读更多...
Redis最佳实践——电商应用的性能监控与告警体系设计详解

Redis最佳实践——电商应用的性能监控与告警体系设计详解

Redis 在电商应用的性能监控与告警体系设计 一、原子级监控指标深度拆解 1. 内存维度监控 核心指标&#xff1a; # 实时内存组成分析&#xff08;单位字节&#xff09; used_memory: 物理内存总量 used_memory_dataset: 数据集占用量 used_memory_overhead: 管理开销内存 us…
阅读更多...
区域徘徊检测算法AI智能分析网关V4助力公共场所/工厂等多场景安全升级

区域徘徊检测算法AI智能分析网关V4助力公共场所/工厂等多场景安全升级

一、项目背景 随着数字化安全管理需求激增&#xff0c;重点场所急需强化人员异常行为监测。区域徘徊作为潜在安全威胁的早期征兆&#xff0c;例如校园围墙外的陌生逗留者&#xff0c;都可能引发安全隐患。传统人工监控模式效率低、易疏漏&#xff0c;AI智能分析网关V4的区域徘…
阅读更多...
修复与升级suse linux

修复与升级suse linux

suse linux enterprise desktop 10提示&#xff1a;xxx service failed when loaded shared lib . error ibgobject.so.2.0:no such file or directory. suse linux enterprise server 12.iso 通过第一启动项引导&#xff0c;按照如下方式直接升级解决。
阅读更多...
电力高空作业安全检测（2）数据集构建

电力高空作业安全检测（2）数据集构建

数据集构建的重要性 在电力高空作业安全检测领域&#xff0c;利用 计算机视觉技术 进行安全监测需要大量的图像数据&#xff0c;这些数据需要准确标注不同的安全设备与作业人员行为。只有构建出包含真实场景的高质量数据集&#xff0c;才能通过深度学习等算法对高空作业中的潜…
阅读更多...
嵌入式开发之STM32学习笔记day18

嵌入式开发之STM32学习笔记day18

STM32F103C8T6 SPI通信读写W25Q64 1 W25Q64简介 W25Qxx系列是一种低成本、小型化且易于使用的非易失性存储器&#xff08;NOR Flash&#xff09;&#xff0c;它广泛应用于需要持久化存储数据的各种场景&#xff0c;如数据存储、字库存储以及固件程序存储等。该系列存储器采用…
阅读更多...
[论文阅读]PPT: Backdoor Attacks on Pre-trained Models via Poisoned Prompt Tuning

[论文阅读]PPT: Backdoor Attacks on Pre-trained Models via Poisoned Prompt Tuning

PPT: Backdoor Attacks on Pre-trained Models via Poisoned Prompt Tuning PPT: Backdoor Attacks on Pre-trained Models via Poisoned Prompt Tuning | IJCAI IJCAI-22 发表于2022年的论文&#xff0c;当时大家还都在做小模型NLP的相关工作&#xff08;BERT&#xff0c;Ro…
阅读更多...
汽车安全：功能安全FuSa、预期功能安全SOTIF与网络安全Cybersecurity 解析

汽车安全：功能安全FuSa、预期功能安全SOTIF与网络安全Cybersecurity 解析

汽车安全的三重防线&#xff1a;深入解析FuSa、SOTIF与网络安全技术 现代汽车已成为装有数千个传感器的移动计算机&#xff0c;安全挑战比传统车辆复杂百倍。 随着汽车智能化、网联化飞速发展&#xff0c;汽车电子电气架构已从简单的分布式控制系统演变为复杂的移动计算平台。现…
阅读更多...
【C++高级主题】虚继承

【C++高级主题】虚继承

目录 一、菱形继承&#xff1a;虚继承的 “导火索” 1.1 菱形继承的结构与问题 1.2 菱形继承的核心矛盾&#xff1a;多份基类实例 1.3 菱形继承的具体问题&#xff1a;二义性与数据冗余 二、虚继承的语法与核心目标 2.1 虚继承的声明方式 2.2 虚继承的核心目标 三、虚继…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023