Java 泛型详细解析

泛型的定义

泛型类的定义

下面定义了一个泛型类 Pair，它有一个泛型参数 T。

public class Pair<T> {
	private T start;
	private T end;
}

实际使用的时候就可以给这个 T 指定任何实际的类型，比如下面所示，就指定了实际类型为 LocalDate，泛型给了我们一个错觉就是通过个这个模板类 Pair<T>，我们可以在实际使用的时候动态的派生出各种实际的类型，比如这里的 Pair<LocalDate> 类。

Pair<LocalDate> period = new Pair<>();

泛型类的继承

子类是一个泛型类的定义方法如下：

public class Interval<T> extend Pair<T> {}

这里的 Interval<T> 类是一个泛型类，也可以像上面使用 Pair<T> 类一样给它指定实际的类型。

子类是一个具体类的定义方法如下：

public class DateInterval extends Pair<LocalDate> {}

这里的 DateInterval 类就是一个具体的类，而不再是一个泛型类了。这里的语义是 DateInteral 类继承了 Pair<LocalDate> 类，这里的 Pair<LocalDate> 类也是一个具体类。但是由于 Java 的泛型实现机制，这里会带来多态上的一个问题，见下面的分析。

而像下面的这种定义具体类的写法是错误的：

public class DateInterval<LocalDate> extends Pair<LocalDate> {}

泛型方法的定义

泛型方法定义时，类型变量放在修饰符的后面，返回值的前面。泛型方法既可以泛型类中定义，在普通类中定义。

public static <T> T genericMethod(T a) {}

这里顺便记录一下，因为是使用擦除来实现的泛型，因此字节码中的方法的签名是不会包含泛型信息的。对于泛型方法会多生成一个 Signature 的属性，用于记录方法带泛型信息的签名，反编译器也可以根据这个信息将泛型方法还原回来。
image.png
请添加图片描述

构造函数泛型

下面的代码定义了一个泛型类 ConstructorGeneric，它的泛型参数是 T，这个类的构造函数也是泛型的，它有一个泛型参数 X。

class ConstructorGeneric<T> {
	public <X> ConstructorGeneric(X a) {}
}

创建该对象的代码如下：

ConstructorGeneric<Number> t = new <String>ConstructorGeneric<Number>("123");

这里 new 后面的 String 是传给构造器的泛型 X 的，即 X 的实际类型为 String；类的范型参数是由 Number 传递的，即 T 的实际类型是 Number。这里两个都是省略，写在这里是为了显示区分出两个参数传递的位置。

类型变量的限定

带单个上界限定：
下面的代码定义了一个 NatualNumber 类，它的泛型参数 T 限制为 Integer 或者 Integer 的子类。

public class NaturalNumber<T extends Integer> {
    private T n;

    public NaturalNumber(T n)  { this.n = n; }

    public boolean isEven() {
        return n.intValue() % 2 == 0;
    }
}

调用代码如下：

// 正常
NaturalNumber<Integer> natural1 = new NaturalNumber<>(1);  

// 无法编译，因为这里和泛型类定义的上界不符合
NaturalNumber<Double> natualral2 = new NaturalNumber<>(1.0);

带多个上界的限定：
多个上界之间使用 & 符号进行分隔，如果多个限定中有类，则类需要排在接口后面（因为 Java 不支持多继承，所以不存在有多个限定的类的情况）。使用时需要满足所有的限定条件才能执行，这个校验应该是在编译时期做的，因为擦除之后，只会保留第一个限定界。

class A {}
interface B {}
class C extends A implements B {}
public static <T extends A & B> void test(T a) {}

public static void main(String[] args) {
	// 编译错误，A 只能满足一个上界
	test(new A());
	// 正常
	test(new C());
}

通配符

在泛型中使用 ? 表示通配符，它的语义是表示未知的类型。通配符可以用作方法的形参、字段的定义、局部变量的定义，以及有的时候作为函数的返回值。通配符不能作为实参调用泛型方法，不能创建对象，或者派生子类型。

上界通配符

当你想定义一个普通方法，这个普通方法可以处理某一类的 List 中的元素时，比如像：List<Number>，List<Integer>，List<Double> 时，这个时候如果你把方法的入参定义为 List<Number> 是不行的，因为在 Java 中 List<Integer> 不是 List<Number> 的子类。

public static void process(List<Number> numbers) {}

// 编译错误
List<Number> numbers = new ArrayList<>();
proess(numbers);

假设 List 是 List 的子类，则可以实现如下的代码：

List<Integer> integers = new ArrayList<>();

// 假设下面是成立的
List<Number> numbers = integers;

// 下面这句也应该是合法的，但是这违背了 intergers 只能存放 Integer 的语义
numbers.add(new Double());

从上面的例子可以看出，如果允许 List<Integer> 是 List<Number> 的子类型，则会破坏泛型的语义，因此这在 Java 中是不允许的。

但是又实际存在上面描述的这种需求，因此 Java 提供了上界通配符的语法，则方法定义可以定义为如下：

public static void process(List<? extends Number> numbers) {
	for (Number num : numbers) {
		// do something
	}
}

// 下面的调用都是能够正常编译通过的
List<Number> numbers = new ArrayList<>();
process(numbers);

List<Integer> integers = new ArrayList<>();
process(integers);

List<Double> doubles = new ArrayList<>();
process(doubles);

这里的 ? extends Number 的语义就是可以匹配 Number 或者 Number 子类的 List，需要注意的是在 Java 中的继承（extends）和实现（implements）在这里都用关键字 extends 来表示。

从这里也可以看出，List<? extends Number> 的返回值是可以赋值给 Number 类型的。这里可以想象一下 List 的 get() 方法的泛型参数 E 就变成了 ? extends Number 这个实际类型，而它表达的语义是 Number 以及 Number 的子类，因此赋值给一个 Number 类型的变量是合法的。

但是下面的代码是不合法的：

public static void process(List<? extends Number> numbers) {
	numbers.add(new Integer());
}

这里同样可以想象一下 List 的 add() 方法的入参的泛型参数 E 就变成了 ? extends Number 这个实际类型，它表达的语义是 Number 以及 Number 的子类，但是具体是哪个子类是无法确定的。上面的例子也解释了它可能是 Number，Integer，Double 等，假设它是 Double 类型，这里放一个 Integer 类型，又违背了泛型只能放 Double 的语义，因此这里的赋值是不合法的。

无界通配符

下面的代码就是定义了一个 List<?> 形参的方法，这里的 List<?> 语义是一个未知类型的 List。

public static void printList(List<?> list) {}

无界通配符定义的 List 里面的元素只能赋值给 Object 类型。这里可以想象一下 List 的 get() 方法的泛型参数 E 就变成了 ? 这个实际类型，它的语义是一个未知的类型，既然是一个未知的类型那么我只能赋值给 Object 类型的变量了。

public static void printList(List<?> list) {
	for (Object obj : list) {
		// do something
	}
}

无界通配符定义的 List 里面只能添加 null，不能添加其它的任何类型的元素，即使是 Object 也不行，因为添加了之后就会违背泛型的语义了。

无界通配符的主要使用场景是：

  • 需要使用 Object 类中的方法
  • 使用了泛型类中不用关心泛型的方法，比如 List 中的 size() ，clear() 方法

下界通配符

在使用上面的上界通配时，发现了一个问题，如果一个 List 类型形参声明为了上界通配符，是没有办法往这个 List 里面添加元素的，为了解决这个问题，可以使用下界通配符，可以定义如下的方法：

public static void addNumbers(List<? super Number> list) {
	list.add(new Integer());
	list.add(new Double());
}

这里可以想象一下这个时候 List 的 add() 方法的入参的泛型参数 E 就变成了 ? super Integer 类型，它的语义是匹配 Number 以及 Number 类型的超类。根据 Java 多态的原理，这里实际可以传递的类型为 Integer 以及 Integer 的子类型，因为形参声明的是超类，实际传递子类的引用当然是合法的。

泛型继承关系

泛型的继承关系如下图所示：

image.png

通配符捕获

假设定义了一个无界限通配符的方法如下，这个方法会编译错误，因为按照之前分析的 List<?> 中不能添加任何类型的对象，而这里 list.get(0) 返回的是 Object 类型的对象，肯定是无法放入进去的。代码如下：

public void foo(List<?> list) {
	list.set(0, list.get(0)); // 编译报错
}

为了解决这个问题这个时候就可以通过新建一个私有的泛型方法来帮助捕获通配符的类型，这个私有的泛型方法名称通常是原有方法加上Helper后缀，这种技巧称为通配符捕获。代码如下：

pulic void foo(List<?> list) {
	// 调用这个方法的语义是告诉编译器我不知道具体类型是什么，
	// 但是取出来和放进去的元素类型是相同的
	fooHelper(list);
}

private <T> void fooHelper(List<T> list) {
    // 合法
	T temp = list.get(0);
	// 合法
	list.set(0, temp);
}

对于泛型方法，因为 add() 方法的入参，get() 方法返回值的泛型参数都是 T，当传入一个 List 进来，虽然这个 List 里面的对象实际类型不知道，但是通过泛型参数可以判断 get() 方法返回类型和 add() 方法的入参类型都是一样的，都是 T 捕获到的一个实际类型 X。

对于带通配符参数的方法，因为方法的声明没有一个泛型参数，不能捕获到实际的参数类型 X。那么对于每次方法的调用编译器都会认为是一个不同的类型。比如编译器编译的时候 list.set(0, xxx)，这里的入参的类型就会是 CAP#1， list.get(0) 返回的类型就是 CAP#2，因为没有一个泛型参数来告诉编译器说 CAP#1 和 CAP#2 是一样的类型，因此编译器就会认为这两个是不同的类型，从而拒绝编译。下图是编译器实际的提示信息：
image.png

image.png
从上面的图也可以看出，第二次调用方法时，类型又变成 CAP#3 和 CAP#4 了，这也证明了每次编译器都会认为是一个新的类型。

实际上这里也可以将这个私有的 Helper 方法定义为公共的，然后去掉通配符的方法。这两种定义实际上是达到了相同的效果，但是 Java 语言规范 5.1.10 章节中更推荐采用通配符的方式定义，但它上面阐述的原因没太看懂，但是在另外一篇博客里面看到一个观点感觉有点道理。
image.png

它说如果定义成一个泛型方法，那么老的遗留的没有用泛型的代码调用这个方法就会产生一个警告，但是如果是使用通配符则不会有警告产生。

public static void foo1(List<?>) {}

public static <T> void foo2(List<T>) {}

// 假设老的代码没有用泛型
List rawList = Arrays.asList("1", "2");
// 不会产生告警
foo1(rawList);
// 会产生告警，提示未经检查的转换
foo2(rawList);

然而实际上 JDK 中真正的实现并没有采用这种方式，而是直接用注解忽略了异常，直接用的原生类型来实现的。Collections 中的 reverse() 方法内部实现逻辑如下：

@SuppressWarnings({"rawtypes", "unchecked"})  
public static void reverse(List<?> list) {  
    int size = list.size();  
    if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) {  
        for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--)  
            swap(list, i, j);  
    } else {  
        // instead of using a raw type here, it's possible to capture 
        // the wildcard but it will require a call to a supplementary         // private method 
        ListIterator fwd = list.listIterator();  
        ListIterator rev = list.listIterator(size);  
        for (int i=0, mid=list.size()>>1; i<mid; i++) {  
            Object tmp = fwd.next();  
            fwd.set(rev.previous());  
            rev.set(tmp);  
        }  
    }  
}

桥接方法

假设定义了如下代码：

public class Node<T> {
    public T data;
    public Node(T data) { this.data = data; }
    public void setData(T data) {
        System.out.println("Node.setData");
        this.data = data;
    }
}

public class MyNode extends Node<Integer> {
    public MyNode(Integer data) { super(data); }
    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }
}

泛型擦除后的实际代码如下，注意看 MyNode 里面的 setData() 方法并没有重写 Node 里面的 setData() 方法了，因为方法签名不一样。这就违背了 Java 多态的语义。
Java 编译器在编译的时候会自动给 MyNode 生成一个桥接方法，这个方法的签名和 Node 类里面的一样，然后在这个方法里面去调用真正的 setData() 方法。
通过查看 MyNode.class 文件可以看到真的有两个 setData() 方法存在。
image.png

方法的形参类型是 Object 类型，和 Node 类中泛型擦除后的类型相同，说明这个方法才是真正重载了 Node 类中的方法。
image.png

方法实现中调用了 MyNode 类中形参为 Integer 类型的 setData() 方法。
image.png

同时在 MyNode 类中不允许自己定义形参为 Object 类型的 setData() 方法了，如果定义了则无法编译：
image.png

经过编译器编译后的代码等效为如下的代码：

public class Node {
    public Object data;
    public Node(Object data) { this.data = data; }
    public void setData(Object data) {
        System.out.println("Node.setData");
        this.data = data;
    }
}

public class MyNode extends Node<Integer> {
    public MyNode(Integer data) { super(data); }
    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }
    
    // 由编译器生成的桥接方法
    // 如果手动定义了这个方法编译器就会报错了
    public void setData(Object data) {
        setData((Integer) data);
    }
}

泛型的局限性

泛型不能用于基本类型

泛型是通过擦除实现的，擦除之后 ArrayList 内部是 Object[] 类型的数组，是不能存放基本类型的，因为基本类型不是 Object 类型的子类。

List<int> list = new ArrayList<>();

不能创建泛型类型的实例

泛型是通过擦除来实现的，所以擦除之后都会变成 new Object() (没有指定上界的情况)，而实际上我们是要创建 T 类型的实例的。

public static <T> void test(List<T> list) {
	E ele = new E();
	list.add(ele);
}

// 可以通过如下方式
public static <T> void test(List<T> list, Class<T> clazz) {
	E ele = clazz.newInstance();
	list.add(ele);
}
// 调用
List<String> list = new ArrayList<>();
test(list, String.class);

不能声明静态的泛型变量

泛型相当于是类的工厂，可以创建不同类型的实例。而静态变量是所有实例共享的，如果允许声明静态的泛型变量，那么不同类型的实例之间就会存在矛盾。

public class MobileDevice<T> {
	private static T os;
}

// 这两个实例的静态变量就会存在矛盾
MobileDevice<Smartphone> phone = new MobileDevice<>();
MobileDevice<TabletPC> pc = new MobileDevice<>();

不能使用 instanceof 判断泛型类型

泛型是通过擦除实现的，因此 List<T>.class 在内存中是不存在的，只有 List.class，这个类型也被称为原生类型。

// 错误
if (list instanceof List<String>) {
}

// 正确
if (list instanceof List) {
}

不能创建泛型数组

泛型是通过擦除实现的，如果允许声明泛型数组，则无法实现数组在存放时会校验数组的元素类型这个语义。

// 假设允许创建，这个数组的每个元素只允许存放 List<String> 类型的元素
Object[] stringLists = new List<String>[2]; 
// 正确执行
stringLists[0] = new ArrayList<String>(); 
// 这行应该抛出 ArrayStoreException 异常，
// 但是由于擦除，实际上和上面是一样的，这里违背了数组的语义
stringLists[1] = new ArrayList<Integer>();

不能创建、捕获、抛出带泛型的异常

// 编译报错
class MathException<T> extends Exception {}    

// 编译报错
class QueueFullException<T> extends Throwable {}

// 编译报错
public static <T extends Exception, J> void execute(List<J> jobs) {
    try {
        for (J job : jobs)
    } catch (T e) {  // 编译报错
    }
}

class Parser<T extends Exception> {
	// 这样是允许的
	// 我觉得允许的原因是声明了抛出父类，而实际抛出子类也是合法的
    public void parse(File file) throws T {  
    }
}

不能使用擦除后原生类型相同的泛型参数方法来重载

public class Example {
    // 这两个方法擦除后的参数是一样的，所以不能算重载
    public void print(Set<String> strSet) { }
    public void print(Set<Integer> intSet) { }
}

堆污染

当定义变长的泛型参数时，如果尝试把一个原生类型赋值给变成泛型参数就有可能发生堆污染。堆污染的本质原因就是可以通过语法糖变长参数列表来创建泛型的的数组导致的。例如下面的代码：

public class ArrayBuilder {
  public static <T> void addToList (List<T> listArg, T... elements) {
    for (T x : elements) {
      listArg.add(x);
    }
  }

  public static void faultyMethod(List<String>... l) {
    // 这里编译应该会有告警，如果忽略这个告警，则有可能带来堆污染
    Object[] objectArray = l;   
    objectArray[0] = Arrays.asList(42);
    String s = l[0].get(0);     
  }
}

编译告警中就会提示有堆污染，如下图所示：
image.png

当编译器遇到一个变长参数方法时，它会把它转换为一个数组。对于 T... elements 这种参数声明就会转为 T[] elements，因为泛型的擦除，最终会被转换为 Object[] elements，这里编译器就会认为有可能发生堆污染。

可以通过以下三种方式抑制这种警告：

  • @SuppressWarnings({"unchecked", "varargs"})
    这种方式只能抑制方法声明时候的告警，方法调用处还是会产生告警；
    image.png
  • @SafeVarargs
    不会产生任何警告
    image.png
  • 增加 -Xlint:varags 编译选项
    不会产生任何警告
    image.png

JVM 控制参数

显示所有告警信息

给编译器增加 -Xlint:unchecked ，在 Idea 中可以参考如下图配置：
image.png

显示更详细的诊断信息

给编译增加 -Xdiags: verbose 选项
image.png

显示所有告警信息为英文

增加如下环境变量：
image.png
Idea 中可以将配置放在 vmproperties 文件中，如下图所示：
image.png

参考

Java Generic Tutorial
Java核心技术·卷 I（原书第10版）
深入理解Java虚拟机（第3版）
When to use generic methods and when to use wild-card?
Why use a wild card capture helper method?
Capture Conv: rev/reverse - what’s the point?
Difference between <? super T> and <? extends T> in Java
What is PECS (Producer Extends Consumer Super)?
Differences between copy(List<? super T> dest, List<? extends T> src) and copy(List dest, List<? extends T> src)

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Python语法基础（四）

Python语法基础（四）

&#x1f308;个人主页&#xff1a;羽晨同学 &#x1f4ab;个人格言:“成为自己未来的主人~” 高阶函数之map 高阶函数就是说&#xff0c;A函数作为B函数的参数&#xff0c;B函数就是高阶函数 map&#xff1a;映射 map(func,iterable) 这个是map的基本语法&#xff0c;…
阅读更多...
【JavaEE初阶】应是天仙狂醉,乱把白云揉碎 - (重点)线程

【JavaEE初阶】应是天仙狂醉,乱把白云揉碎 - (重点)线程

本篇博客给大家带来的是线程的知识点, 由于内容较多分几天来写. &#x1f40e;文章专栏: JavaEE初阶 &#x1f680;若有问题 评论区见 ⭐欢迎大家点赞 评论 收藏 分享 ❤❤❤ 如果你不知道分享给谁,那就分享给薯条. 你们的支持是我不断创作的动力 . 1. 认识线程 1.1 概念 )1 …
阅读更多...
构建鸿蒙5.0应用（一）

构建鸿蒙5.0应用（一）

准备工作 1、开发工具 开发工具使用华为官方推荐的IDE&#xff1a;DevEco Studio &#xff0c;为鸿蒙应用开发提供了最全面的官方支持&#xff0c;包括最新的 SDK、API 和功能。 2、编译工具 开发鸿蒙应用需要安装Nodejs环境&#xff0c;为打包编译鸿蒙应用提供支持&#x…
阅读更多...
【Linux】匿名管道通信场景——进程池

【Linux】匿名管道通信场景——进程池

&#x1f525; 个人主页&#xff1a;大耳朵土土垚 &#x1f525; 所属专栏&#xff1a;Linux系统编程 这里将会不定期更新有关Linux的内容&#xff0c;欢迎大家点赞&#xff0c;收藏&#xff0c;评论&#x1f973;&#x1f973;&#x1f389;&#x1f389;&#x1f389; 文章目…
阅读更多...
FUSU: 多源多时相土地利用变化分割数据集

FUSU: 多源多时相土地利用变化分割数据集

FUSU是首个针对细粒度城市语义理解的多时态、多源地类变化分割数据集&#xff0c;其提供高分辨率双时态图像和每月时序观测&#xff0c;支持对城市动态变化的高频率监测。FUSU-Net是统一的时序架构&#xff0c;可同时进行变化检测和分割任务。结合光学和SAR数据&#xff0c;通过…
阅读更多...
LLM学习笔记（13）分词器 tokenizer

LLM学习笔记（13）分词器 tokenizer

由于神经网络模型不能直接处理文本&#xff0c;因此我们需要先将文本转换为数字&#xff0c;这个过程被称为编码 (Encoding)&#xff0c;其包含两个步骤&#xff1a; 使用分词器 (tokenizer) 将文本按词、子词、字符切分为 tokens&#xff1b;将所有的 token 映射到对应的 tok…
阅读更多...
Unity中让光点跟图片填充区的末尾一起移动

Unity中让光点跟图片填充区的末尾一起移动

一、实现效果展示 想要实现的效果如下，就是要让白色光点图片跟随绿色圆形图片填充区末尾一起移动。 二、代码如下： using UnityEngine; using System.Collections; using UnityEngine.UI; using DG.Tweening;public class IconCircle : MonoBehaviour {public float ti…
阅读更多...
给定一个整数可能为正,0,负数,统计这个数据的位数.

给定一个整数可能为正,0,负数,统计这个数据的位数.

题目描述 给定一个整数可能为正,0,负数,统计这个数据的位数. 例如1234567输出7位; -12345678输出8位;0输出1位 代码实现 int main() { long long m; long long n; scanf("%lld",&n); mn; int count0;//位数 do { count; n/10;//舍弃个位 }while(n!0); printf(&…
阅读更多...
LLamafactory API部署与使用异步方式 API 调用优化大模型推理效率

LLamafactory API部署与使用异步方式 API 调用优化大模型推理效率

文章目录 背景介绍第三方大模型API 介绍LLamafactory 部署API大模型 API 调用工具类项目开源 背景介绍 第三方大模型API 目前&#xff0c;市面上有许多第三方大模型 API 服务提供商&#xff0c;通过 API 接口向用户提供多样化的服务。这些平台不仅能提供更多类别和类型的模型…
阅读更多...
【关闭or开启电脑自带的数字键盘】

【关闭or开启电脑自带的数字键盘】

目录 一、按数字键盘左上角的按键【NumLK Scroll】 二、修改注册表中数字键盘对应的数值【InitialKeyboardIndicators】 1、步骤&#xff1a; 2、知识点&#xff1a; 一、按数字键盘左上角的按键【NumLK Scroll】 这是最简单快捷的方法。 关闭后若想开启&#xff0c;再按一…
阅读更多...
【FAQ】使用Node.js 镜像 构建本地项目

【FAQ】使用Node.js 镜像 构建本地项目

在nodejs官方并没有提供使用node.js构建本地项目的方法&#xff0c;但是通过阅读官方文档&#xff0c;可以发现&#xff0c;官方在包管理器界面提供了如下语句 所以node.js容器是可以执行语句的 下面通过docker 的 -w 、-v 参数设置容器工作目录和目录映射&#xff08;实现本…
阅读更多...
深度学习 | pytorch + torchvision + python 版本对应及环境安装

深度学习 | pytorch + torchvision + python 版本对应及环境安装

Hi&#xff0c;大家好&#xff0c;我是半亩花海。要让一个基于 torch 框架开发的深度学习模型正确运行起来&#xff0c;配置环境是个重要的问题&#xff0c;本文介绍了 pytorch、torchvision、torchaudio 及 python 的对应版本以及环境安装的相关流程。 目录 一、版本对应 二…
阅读更多...
4399大数据面试题及参考答案（数据分析和数据开发）

4399大数据面试题及参考答案（数据分析和数据开发）

对数据分析的理解 数据分析是一个从数据中提取有价值信息以支持决策的过程。它涵盖了数据收集、清洗、转换、建模和可视化等多个环节。 首先&#xff0c;数据收集是基础。这包括从各种数据源获取数据&#xff0c;例如数据库、文件系统、网络接口等。这些数据源可以是结构化的数…
阅读更多...
fastdds:编译、安装并运行helloworld

fastdds:编译、安装并运行helloworld

fastdds安装可以参考官方文档&#xff1a; 3. Linux installation from sources — Fast DDS 3.1.0 documentation 从INSTALLATION MANUAL这一节可以看出来&#xff0c;fastdds支持的操作系统包括linux、windows、qnx、MAC OS。本文记录通过源码和cmake的方式来安装fastdds的…
阅读更多...
Istio笔记01--快速体验Istio

Istio笔记01--快速体验Istio

Istio笔记01--快速体验Istio 介绍部署与测试部署k8s安装istio测试istio 注意事项说明 介绍 Istio是当前最热门的服务网格产品&#xff0c;已经被广泛应用于各个云厂商和IT互联网公司。企业可以基于Istio轻松构建服务网格&#xff0c;在接入过程中应用代码无需更改&#xff0c;…
阅读更多...
ipad项目 蓝湖宽度

ipad项目 蓝湖宽度

ipad项目 横屏状态时 蓝湖宽度设置930px media screen and (orientation: portrait) {/* 竖屏时的样式 */ } media screen and (orientation: landscape) {/* 默认是 横屏时的样式 */ }
阅读更多...
14、保存与加载PyTorch训练的模型和超参数

14、保存与加载PyTorch训练的模型和超参数

文章目录 1. state_dict2. 模型保存3. check_point4. 详细保存5. Docker6. 机器学习常用库 1. state_dict nn.Module 类是所有神经网络构建的基类&#xff0c;即自己构建一个深度神经网络也是需要继承自nn.Module类才行&#xff0c;并且nn.Module中的state_dict包含神经网络中…
阅读更多...
在鸿蒙应用中 Debug 对开发者的帮助

在鸿蒙应用中 Debug 对开发者的帮助

文章目录 摘要引言Debug 的意义与挑战案例&#xff1a;页面渲染性能优化中的 Bug 排查Debug 过程详解问题定位问题解决优化布局与渲染逻辑 代码详细讲解示例代码详细讲解1. 导入必要模块2. 数据生成3. 使用虚拟列表组件items 属性itemHeight 属性renderItem 属性 4. 返回完整组…
阅读更多...
基于多VSG独立微网的多目标二次控制MATLAB仿真模型

基于多VSG独立微网的多目标二次控制MATLAB仿真模型

“电气仔推送”获得资料&#xff08;专享优惠&#xff09; 模型简介 本文将一致性算法引入微电网的二次频率和电压控制&#xff0c;自适应调节功率参考值和补偿电压&#xff0c;同时实现频率电压恢复、有功 无功功率的比例均分以及功率振荡抑制&#xff0c;提高系统的暂态和稳…
阅读更多...
洛谷 P2415 集合求和 C语言

洛谷 P2415 集合求和 C语言

题目&#xff1a; https://www.luogu.com.cn/problem/P2415 思路从大佬学来的思路。 如图&#xff1a; 我们可以发现&#xff0c;集合最后出现过的数字是2的&#xff08;n-1&#xff09;次方&#xff0c;所以就很好计算了。 代码如下&#xff1a; #include <iostream&g…
阅读更多...
最新文章

Copyright @ 2022~2023