26. 可变参数和Collection集合工具类

news2025/1/22 12:47:14

可变参数与`Collections`

    • 1. 可变参数
      • 1. 概述
      • 2. 格式
      • 3. 代码示例
      • 4. 注意事项
    • 2. `Collections`集合工具类
      • 2.1 概述
      • 2.2 方法
      • 2.3 代码示例
      • 2.4 注意事项

1. 可变参数

1. 概述

可变参数（Variable Arguments）是指在参数列表中允许传入不定个数的参数。在许多编程语言中，可变参数通常用于传递相同类型的参数，并且允许传入任意个数的参数。

  • 可变参数的语法通常是通过使用"..." (省略号)来表示，它可以将传递的参数打包成数组。

例如：

public void method(String... args) {
    for (String arg : args) {
        System.out.println(arg);
    }
}

method("Hello", "World");  // 打印结果：Hello World
method("a", "b", "c");  // 打印结果：a b c

2. 格式

  1. 格式：

    修饰符 返回值类型 方法名(参数类型... 形参名){  }

  2. 底层：

    其实是一个数组，只不过是java已经创建好的

  3. 作用：

    在形参中接受多个数据

  4. 注意：
    ​ 1. 一个方法只能有一个可变参数
    ​ 2. 如果方法中有多个参数，可变参数要放到最后。

3. 代码示例

  • 代码示例
    需求：利用可变参数求几个数的和
    package text.text02;

/*可变参数（JDK5以后）：
1.格式
    修饰符 返回值类型 方法名(参数类型... 形参名){  }
    参数类型... 形参名
    例如：int... args
2.底层：其实是一个数组，只不过是java已经创建好的
3.作用：在形参中接受多个数据
4.注意事项：
    1.形参列表中可变参数只能有一个
    2.可变参数必须放在形参列表的最后面

需求：利用可变参数求几个数的和
 */
public class text55 {
    public static void main(String[] args) {
        int sum = getSum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println("这几个数的和为：" + sum);       //这几个数的和为：55
    }

    //利用可变参数定义方法
    public static int getSum(int... args) {
        int sum = 0;
        for (int arg : args) {
            sum = sum + arg;
        }
        return sum;
    }
}
  • 输出结果
    在这里插入图片描述

4. 注意事项

  1. 可变参数通常应该作为参数列表的最后一个参数，因为在调用函数时，可变参数后面的参数将无法被传递或者识别。

  2. 在函数内部，可变参数实际上被当作一个数组（或者其他类似的数据结构）处理。因此，可以使用数组相关的操作来处理可变参数，如索引访问、遍历等。

  3. 当没有传递任何参数时，可变参数的值将为一个空数组（或者类似结构）。在函数内部，应该适当处理这种情况，以避免出现空指针异常或其他错误。

  4. 可变参数只能用于传递相同类型的参数。如果需要传递不同类型的参数，可以考虑使用重载函数或其他方式来处理。

  5. 使用可变参数时，需要注意参数的顺序。如果同时使用可变参数和其他类型的参数，需要确保传递参数时的顺序是正确的。

2. Collections集合工具类

2.1 概述

Collections 是 Java 编程语言中提供的一个集合工具类，位于 java.util 包中。它提供了一系列静态方法，用于对集合进行常见的操作和算法实现。

Collections 类的主要功能：

  1. 创建不可变集合：Collections 提供了一系列的 emptyXxx() 方法，用于创建不可变的空集合（如 emptyList()、emptySet() 等）。

  2. 创建单元素集合：提供了一系列的 singletonXxx() 方法，用于创建只包含一个元素的不可变集合。

  3. 集合操作：提供了一系列的静态方法用于对集合进行操作，如排序、反转、查找、填充等。这些方法包括：sort()、shuffle()、reverse()、binarySearch()、fill() 等。

  4. 同步集合：提供了一系列的线程安全的集合类的静态方法（如 synchronizedList()、synchronizedSet() 等），用于将现有的集合转换为线程安全的集合，以便在多线程环境下使用。

2.2 方法

方法描述
public static <T> boolean addAll(Collection<T> c, T ... elements)批量添加元素
public static void shuffle(List<?> list)打乱集合顺序
public static <T> void sort(List<T> list)将集合中元素按照默认规则排序（默认规则：需要重写Comparable接口compareTo方法，默认按照从小到大的顺序排列）
public static <T> void sort(List<T> list, Comparator<? super T> c)将集合中元素按照指定规则排序（指定规则在创建对象时指定比较器规则）（自定义对象，需要自己指定规则）
public static <T> int binarySearch(List<? super T> list, T key)以二分查找法查找元素
public static void fill(List<? super T> list, T obj)使用指定元素填充集合
public static <T> T max(Collection<? extends T> coll)返回指定 collection 中的最大元素
public static <T> T min(Collection<? extends T> coll)返回指定 collection 中的最小元素
public static void swap(List<?> list, int i, int j)交换指定列表中指定位置的元素

详细描述：

  1. public static <T> boolean addAll(Collection<T> c, T ... elements)

    • 描述：批量添加元素到指定集合中。
    • 参数：
      • c：目标集合
      • elements：要添加的元素数组
    • 返回值：如果集合发生更改，则返回 true；否则返回 false。

  2. public static void shuffle(List<?> list)

    • 描述：打乱指定列表中元素的顺序。
    • 参数：
      • list：要进行打乱顺序操作的列表。

  3. public static <T> void sort(List<T> list)

    • 描述：将集合中的元素按照默认规则排序。
    • 参数：
      • list：要排序的列表
    • 默认规则：集合中的元素必须实现 Comparable 接口，并重写 compareTo 方法来定义排序规则。默认按照从小到大的顺序排列。

  4. public static <T> void sort(List<T> list, Comparator<? super T> c)

    • 描述：将集合中的元素按照指定规则排序。
    • 参数：
      • list：要排序的列表
      • c：比较器规则，需要在创建对象时指定比较器规则。对于自定义对象，需要自己指定排序规则。

  5. public static <T> int binarySearch(List<? super T> list, T key)

    • 描述：使用二分查找法在指定列表中搜索指定的元素。
    • 参数：
      • list：要进行搜索的有序列表
      • key：要搜索的元素
    • 返回值：如果找到元素，则返回其在列表中的位置；否则返回负数。

  6. public static void fill(List<? super T> list, T obj)

    • 描述：使用指定元素填充列表中的所有元素。
    • 参数：
      • list：要进行填充操作的列表
      • obj：要填充的元素

  7. public static <T> T max(Collection<? extends T> coll)

    • 描述：返回指定 collection 中的最大元素。
    • 参数：
      • coll：要进行查找最大元素的集合
    • 返回值：集合中的最大元素。

  8. public static <T> T min(Collection<? extends T> coll)

    • 描述：返回指定 collection 中的最小元素。
    • 参数：
      • coll：要进行查找最小元素的集合
    • 返回值：集合中的最小元素。

  9. public static void swap(List<?> list, int i, int j)

    • 描述：交换指定列表中指定位置的元素。
    • 参数：
      • list：要进行元素交换的列表
      • i，j：要交换的元素索引位置。

2.3 代码示例

  • 代码示例
package text.text02;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.function.Consumer;

/*Collections：集合工具类
1.java.util.Collections：是集合的工具类
2.作用：Collections不是集合，而是集合的工具类
3.方法：
public static <T> boolean addAll(Collection <T> c,T ... elements)`:批量添加元素
public static void shuffle(List<?> list) `:打乱集合顺序
public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序
    默认规则：需要重写Comparable接口compareTo方法，默认按照从小到大的顺序排列

public static <T> void sort(List<T> list，Comparator<? super T> )`:将集合中元素按照指定规则排序
   指定规则：在创建对象时，指定比较器规则（自定义对象，需要自己指定规则）

public static <T> int binarySearch(List<? super T> list, T key)` ：以二分查找法查找元素
   前提元素必须有序，该方法返回的是该元素所在的索引


public static void fill(List<? super T> list, T obj)`： 使用指定元素填充集合
public static <T> T max(Collection<? extends T> coll)` ： 返回指定 Collection 中的最大元素
public static <T> T min(Collection<? extends T> coll)` ： 返回指定 Collection 中的最小元素
public static void swap(List<?> list, int i, int j)` ：交换指定列表中指定位置的元素

 */
public class text56 {
    public static void main(String[] args) {
        //1.public static <T> boolean addAll(Collection <T> c,T ... elements)`:批量添加元素
        System.out.println("===================== 1.批量添加元素 =====================");
        //创建集合
        Collection<String> list1 = new ArrayList<>();
        //添加元素
        Collections.addAll(list1, "abc", "def", "ghi", "jkl", "mno", "por");
        //遍历集合
        list1.forEach(new Consumer<String>() {
            @Override
            public void accept(String str) {
                System.out.print(str + "  ");      //abc  def  ghi  jkl  mno  por
            }
        });

        System.out.println();

        //2.public static void shuffle(List<?> list) `:打乱集合顺序
        System.out.println("===================== 2.打乱集合顺序 =====================");
        //创建集合
        ArrayList<String> list2 = new ArrayList<>();
        //添加元素
        Collections.addAll(list2, "abc", "def", "ghi", "jkl", "mno", "por");
        //打乱元素
        Collections.shuffle(list2);
        //遍历集合
        for (String str : list2) {
            System.out.print(str + "  ");     //打乱顺序了，每次输出结果都不一样
        }

        System.out.println();

        //3.public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序
        System.out.println("===================== 3.将集合中元素按照默认规则排序 =====================");
        //默认规则：需要重写Comparable接口compareTo方法，默认按照从小到大的顺序排列
        //创建集合
        ArrayList<String> list3 = new ArrayList<>();
        //添加元素
        Collections.addAll(list3, "0004", "0002", "0006", "0001", "0003", "0005");
        //默认规则排序(即从小到大排列)
        Collections.sort(list3);
        //遍历集合
        for (String str : list3) {
            System.out.print(str + "  ");       //0001  0002  0003  0004  0005  0006

        }

        System.out.println();

        //4.public static <T> void sort(List<T> list，Comparator<? super T> )`:将集合中元素按照指定规则排序
        System.out.println("===================== 4.将集合中元素按照指定规则排序 =====================");
        //指定规则：在创建对象时，指定比较器规则（自定义对象，需要自己指定规则）
        //创建集合
        ArrayList<String> list4 = new ArrayList<>();
        //添加元素
        Collections.addAll(list4, "0004", "0002", "0006", "0001", "0003", "0005");
        //指定规则排序
        Collections.sort(list4, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        //遍历集合
        for (String str : list4) {
            System.out.print(str + "  ");       //0006  0005  0004  0003  0002  0001

        }

        System.out.println();

        //5.public static <T> int binarySearch(List<? super T> list, T key)` ：以二分查找法查找元素
        System.out.println("===================== 5.以二分查找法查找元素 =====================");
        //前提元素必须有序
        //创建集合
        ArrayList<Integer> list5 = new ArrayList<>();
        //添加元素
        Collections.addAll(list5, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10);
        //二分查找法查找元素
        //该方法返回的是该元素所在的索引
        int binarySearch = Collections.binarySearch(list5, 6);
        System.out.println("该元素所在的索引为：" + binarySearch);       //该元素所在的索引为：5
        //遍历集合
        for (Integer str : list5) {
            System.out.print(str + "  ");       //1  2  3  4  5  6  7  8  8  9  10

        }

        System.out.println();

        //6.public static void fill(List<? super T> list, T obj)`： 使用指定元素填充集合
        System.out.println("===================== 6.使用指定元素填充集合 =====================");
        //创建集合
        ArrayList<Integer> list6 = new ArrayList<>();
        //添加元素
        Collections.addAll(list6, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10);
        //指定元素填充集合
        Collections.fill(list6, 1314);
        //遍历集合
        for (Integer str : list6) {
            System.out.print(str + "  ");       //1314  1314  1314  1314  1314  1314  1314  1314  1314  1314  1314

        }

        System.out.println();

        //7.public static <T> T max(Collection<? extends T> coll)`：返回指定Collection 中的最大元素
        System.out.println("===================== 7.返回指定Collection 中的最大元素 =====================");
        //创建集合
        ArrayList<Integer> list7 = new ArrayList<>();
        //添加元素
        Collections.addAll(list7, 1, 2, 3, 4, 5, 1314, 520, 6, 7, 8, 8, 9, 10);
        //返回指定Collection 中的最大元素
        Integer max = Collections.max(list7);
        System.out.println("最大元素为：" + max);        //最大元素为：1314
        //遍历集合
        for (Integer str : list7) {
            System.out.print(str + "  ");       //1  2  3  4  5  1314  520  6  7  8  8  9  10
        }

        System.out.println();

        //8.public static <T> T min(Collection<? extends T> coll)`：返回指定 Collection 中的最小元素
        System.out.println("===================== 8.返回指定 Collection 中的最小元素 =====================");
        //创建集合
        ArrayList<Integer> list8 = new ArrayList<>();
        //添加元素
        Collections.addAll(list8, 1, 2, 3, 4, 5, 0, -1, 6, 7, 8, 8, 9, 10);
        //返回指定Collection 中的最小元素
        Integer min = Collections.min(list8);
        System.out.println("最小元素为：" + min);        //最小元素为：-1
        //遍历集合
        for (Integer str : list8) {
            System.out.print(str + "  ");       //1  2  3  4  5  0  -1  6  7  8  8  9  10
        }

        System.out.println();

        //9.public static void swap(List<?> list, int i, int j)` ：交换指定列表中指定位置的元素
        System.out.println("===================== 9.交换指定列表中指定位置的元素 =====================");
        //创建集合
        ArrayList<Integer> list9 = new ArrayList<>();
        //添加元素
        Collections.addAll(list9, 1, 2, 3, 4, 5, 0, -1, 6, 7, 8, 8, 9, 10);
        //交换指定列表中指定位置的元素
        Collections.swap(list9, 0, 12);
        //遍历集合
        for (Integer str : list9) {
            System.out.print(str + "  ");       //10  2  3  4  5  0  -1  6  7  8  8  9  1  
        }
    }
}
  • 输出结果

    • 1.批量添加元素
      在这里插入图片描述

    • 2.打乱集合顺序
      在这里插入图片描述

    • 3.将集合中元素按照默认规则排序
      在这里插入图片描述

    • 4.将集合中元素按照指定规则排序
      在这里插入图片描述

    • 5.以二分查找法查找元素
      在这里插入图片描述

    • 6.使用指定元素填充集合
      在这里插入图片描述

    • 7.返回指定Collection 中的最大元素
      在这里插入图片描述

    • 8.返回指定 Collection 中的最小元素
      在这里插入图片描述

    • 9.交换指定列表中指定位置的元素
      在这里插入图片描述

2.4 注意事项

  1. 集合的同步性：Collections 类提供了一些线程安全的集合方法，如 synchronizedList()、synchronizedSet() 等。但是需要注意，这些方法只是将现有的集合转换为线程安全的集合，并不能保证对集合中的元素的操作是原子性的。如果需要在多线程环境下对集合进行并发操作，建议使用并发集合类 （如 ConcurrentHashMap、CopyOnWriteArrayList 等）来代替。

  2. 不可变集合： Collections 类提供了创建不可变集合的方法（如 unmodifiableList()、unmodifiableSet()），返回的不可变集合不允许对其进行修改操作。需要注意的是，如果原始的集合发生了变化，不可变集合可能会反映这些变化。因此，当需要确保集合不会被修改时，应该使用不可变集合。

  3. 自然排序和自定义排序：Collections.sort() 方法用于对集合进行排序，默认使用集合元素的自然顺序，即元素的类必须实现 Comparable 接口并重写 compareTo() 方法。如果需要使用自定义排序规则，可以使用重载的 sort() 方法，其中传入一个自定义的比较器 Comparator。

  4. 对象的比较和相等：在使用排序或查找方法时，需要确保集合中的元素正确地实现了 equals() 和 compareTo() 方法，以保证比较和查找的准确性。

  5. 注意泛型的使用：Collections 类中的方法通常使用了泛型来增加灵活性和类型安全性。在使用这些方法时，需要注意传入的集合类型和元素类型需要匹配。

  6. 注意性能和效率：某些 Collections 方法的实现可能会产生额外的开销，比如排序方法可能需要额外的内存空间。在处理大量数据时，需要考虑这些性能和效率因素。

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

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

相关文章

多模态论文串讲·上【论文精读·46】只用 Transformer encoder 的一些方法viLT、clip、ALBEF、VLMO

多模态论文串讲·上【论文精读·46】只用 Transformer encoder 的一些方法viLT、clip、ALBEF、VLMO

目录 简单回顾一下 viLT 简单回顾CLIP 总结后提出改进 1 ALBEF 1.1 主体方法 1.1.1 模型结构 1.1.2 目标函数 1 ITCloss&#xff1a;align before fuse的align 2 ITM loss 3 MLM loss 1.1.3 动量蒸馏 1.2 预训练数据集 1.3 下游任务描述 1.4 实验结果 1 消融实验…
阅读更多...
洛谷: [CSP-J 2023] 小苹果

洛谷: [CSP-J 2023] 小苹果

题目描述 小 Y 的桌子上放着 n n n 个苹果从左到右排成一列&#xff0c;编号为从 1 1 1 到 n n n。 小苞是小 Y 的好朋友&#xff0c;每天她都会从中拿走一些苹果。 每天在拿的时候&#xff0c;小苞都是从左侧第 1 1 1 个苹果开始、每隔 2 2 2 个苹果拿走 1 1 1 个苹果…
阅读更多...
【JAVA WEB】JavaScript--函数 作用域 对象

【JAVA WEB】JavaScript--函数 作用域 对象

目录 函数 语法格式 示例 定义没有参数列表&#xff0c;也没有返回值的一个函数 定义一个有参数列表 &#xff0c;有返回值的函数 关于参数个数 函数表达式 作用域 作用域链 对象 基本概念 创建对象 1.使用 字面量 创建对象 2.使用new Object()创建对象 3.使…
阅读更多...
在huggingface中如何使用 google/flan-t5-large

在huggingface中如何使用 google/flan-t5-large

参考&#xff1a; https://huggingface.co/google/flan-t5-large 1&#xff1a; from huggingface_hub.hf_api import HfFolder HfFolder.save_token(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) from transformers import pipeline from transformers import T5Tokenizer, T5F…
阅读更多...
【selenium】

【selenium】

selenium是一个Web的自动化测试工具&#xff0c;最初是为网站自动化测试而开发的。Selenium可以直接调用浏览器&#xff0c;它支持所有主流的浏览器。其本质是通过驱动浏览器&#xff0c;完成模拟浏览器操作&#xff0c;比如挑战&#xff0c;输入&#xff0c;点击等。 下载与打…
阅读更多...
以谷歌浏览器为例 讲述 JavaScript 断点调试操作用法

以谷歌浏览器为例 讲述 JavaScript 断点调试操作用法

今天来说个比较实用的东西 用浏览器开发者工具 对 javaScript代码进行调试 我们先创建一个index.html 编写代码如下 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content&…
阅读更多...
谷粒商城【成神路】-【6】——商品维护

谷粒商城【成神路】-【6】——商品维护

目录 &#x1f9c2;1.发布商品 &#x1f953;2.获取分类关联品牌 &#x1f32d;3.获取分类下所有分组和关联属性 &#x1f37f;4.商品保存功能 &#x1f9c8;5.sup检索 &#x1f95e;6.sku检索 1.发布商品 获取用户系统等级~&#xff0c;前面生成了后端代码&#xff…
阅读更多...
产品交付双轮驱动思维模型下的思考的研发工具

产品交付双轮驱动思维模型下的思考的研发工具

一、产品交付双轮驱动思维模型 之前读过这样双轮驱动思维模型&#xff0c;其思维模型如下图所示&#xff0c;双轮驱动思维模型是一个产品价值交付模型&#xff0c;总的理念是以“真北业务价值”为导向&#xff0c;以“产品快速交付”为动力&#xff0c;将“业务价值”与“产品…
阅读更多...
01.数据结构篇-链表

01.数据结构篇-链表

1.找出两个链表的交点 160. Intersection of Two Linked Lists (Easy) Leetcode / 力扣 例如以下示例中 A 和 B 两个链表相交于 c1&#xff1a; A: a1 → a2↘c1 → c2 → c3↗ B: b1 → b2 → b3 但是不会出现以下相交的情况&#xff0c;因为每个节点只有一个…
阅读更多...
HCIA-HarmonyOS设备开发认证V2.0-3.2.轻量系统内核基础-软件定时器

HCIA-HarmonyOS设备开发认证V2.0-3.2.轻量系统内核基础-软件定时器

目录 一、软件定时器基本概念二、软件定时器运行机制三、软件定时器状态四、软件定时器模式五、软件定时器开发流程六、软件定时器使用说明七、软件定时器接口八、代码分析&#xff08;待续...&#xff09;坚持就有收获 一、软件定时器基本概念 软件定时器&#xff0c;是基于系…
阅读更多...
【python量化交易】qteasy使用教程02 - 获取和管理金融数据

【python量化交易】qteasy使用教程02 - 获取和管理金融数据

qteasy教程2 - 获取并管理金融数据 qteasy教程2 - 获取并管理金融数据开始前的准备工作获取基础数据以及价格数据下载交易日历和基础数据查看股票和指数的基础数据下载沪市股票数据从本地获取股价数据生成K线图 数据类型的查找回顾总结 qteasy教程2 - 获取并管理金融数据 qtea…
阅读更多...
知识图谱 多模态学习 2024 最新综述

知识图谱 多模态学习 2024 最新综述

知识图谱遇见多模态学习&#xff1a;综述 论文题目&#xff1a;Knowledge Graphs Meet Multi-Modal Learning: A Comprehensive Survey 论文链接&#xff1a;http://arxiv.org/abs/2402.05391 项目地址&#xff1a;https://github.com/zjukg/KG-MM-Survey 备注&#xff1a;55…
阅读更多...
C||1.水仙花数是指一个n位数，每一位数字的n次幂的和正好等于这个数本身。2.有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数。

C||1.水仙花数是指一个n位数，每一位数字的n次幂的和正好等于这个数本身。2.有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数。

1.水仙花数是指一个n位数&#xff0c;每一位数字的n次幂的和正好等于这个数本身。 比如&#xff1a;153 13 53 33。 要求打印出所有三位数的水仙花数。 #include <stdio.h> #include <math.h> int main() {int i,x,y,z;for(i100;i<1000;i){xi/100%10;yi/10%…
阅读更多...
python-自动化篇-办公-批量新建文件夹并保存日志信息

python-自动化篇-办公-批量新建文件夹并保存日志信息

文章目录 说明代码效果 说明 因为业务需要&#xff0c;每天都需要按当天的日期创建很多新文件夹。把这种重复又繁重的操作交给Python来做&#xff0c;一直是我的目标。先说下要求&#xff1a; 默认在桌面新建文件夹。文件夹命名方式&#xff0c;“月.日-1”&#xff0c;比如7…
阅读更多...
同一个春晚 ，同一个淘宝

同一个春晚 ，同一个淘宝

配图来自Canva可画 在全国一片喜庆的氛围中&#xff0c;龙年春晚如约播出&#xff0c;又一次为淘宝商家打开“财富之门”。 春晚作为春节不可或缺的一部分&#xff0c;它在传承传统文化的同时&#xff0c;也在引领当代网络潮流。龙年春晚开始前&#xff0c;不少网友“押题”&…
阅读更多...
Stable Diffusion教程——stable diffusion基础原理详解与安装秋叶整合包进行出图测试

Stable Diffusion教程——stable diffusion基础原理详解与安装秋叶整合包进行出图测试

前言 在2022年&#xff0c;人工智能创作内容&#xff08;AIGC&#xff09;成为了AI领域的热门话题之一。在ChatGPT问世之前&#xff0c;AI绘画以其独特的创意和便捷的创作工具迅速走红&#xff0c;引起了广泛关注。随着一系列以Stable Diffusion、Midjourney、NovelAI等为代表…
阅读更多...
车载诊断协议DoIP系列 —— OSI模型DoIP参考

车载诊断协议DoIP系列 —— OSI模型DoIP参考

车载诊断协议DoIP系列 —— OSI模型DoIP参考 我是穿拖鞋的汉子，魔都中坚持长期主义的汽车电子工程师（Wechat：gongkenan2013）。 老规矩，分享一段喜欢的文字，避免自己成为高知识低文化的工程师： 本就是小人物，输了就是输了，不要在意别人怎么看自己。江湖一碗茶，喝完再…
阅读更多...
【玩转408数据结构】线性表——线性表的顺序表示（顺序表）

【玩转408数据结构】线性表——线性表的顺序表示（顺序表）

知识回顾 通过前文&#xff0c;我们了解到线性表是具有相同数据类型的有限个数据元素序列&#xff1b;并且&#xff0c;线性表只是一种逻辑结构&#xff0c;其不同存储形式所展现出的也略有不同&#xff0c;那么今天我们来了解一下线性表的顺序存储——顺序表。 顺序表的定义 …
阅读更多...
2024春晚纸牌魔术原理----环形链表的约瑟夫问题

2024春晚纸牌魔术原理----环形链表的约瑟夫问题

一.题目及剖析 https://www.nowcoder.com/practice/41c399fdb6004b31a6cbb047c641ed8a?tabnote 这道题涉及到数学原理,有一般公式,但我们先不用公式,看看如何用链表模拟出这一过程 二.思路引入 思路很简单,就试创建一个单向循环链表,然后模拟报数,删去对应的节点 三.代码引…
阅读更多...
Stable Diffusion 模型下载：DreamShaper XL（梦想塑造者 XL）

Stable Diffusion 模型下载：DreamShaper XL（梦想塑造者 XL）

本文收录于《AI绘画从入门到精通》专栏&#xff0c;专栏总目录&#xff1a;点这里。 文章目录 模型介绍生成案例案例一案例二案例三案例四案例五案例六案例七案例八案例九案例十 下载地址 模型介绍 DreamShaper 是一个分格多样的大模型&#xff0c;可以生成写实、原画、2.5D 等…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023