10可变参数&Stream流

Stream Collectors.groupingBy的四种用法 解决分组统计(计数、求和、平均数等)、范围统计、分组合并、分组结果自定义映射等问题 基于Java8介绍Java stream Collectors.groupingBy 功能 使用 方法,对java Collectors.groupingBy()的可用方法进行一一举例介绍,如stream分组 stream分组计数 stream分组求和 stream分组聚合等,基于stream collect() 和 收集器 Collectors 阅读详情

1.可变参数

1.1可变参数【应用】(视频 01)(12 “)

  • 可变参数介绍

    • 可变参数又称参数个数可变,用作方法的形参出现,那么方法参数个数就是可变的了
    • 方法的参数类型已经确定,个数不确定,我们可以使用可变参数
  • 可变参数定义格式

    修饰符 返回值类型 方法名(数据类型… 变量名) {  }
    
  • 可变参数的注意事项

    • 这里的变量其实是一个数组
    • 如果一个方法有多个参数,包含可变参数,可变参数要放在最后
      • 一个方法只能有一个可变参数
  • 可变参数的基本使用

    public class ArgsDemo01 {
        public static void main(String[] args) {
            System.out.println(sum(10, 20));
            System.out.println(sum(10, 20, 30));
            System.out.println(sum(10, 20, 30, 40));
    
            System.out.println(sum(10,20,30,40,50));
            System.out.println(sum(10,20,30,40,50,60));
            System.out.println(sum(10,20,30,40,50,60,70));
            System.out.println(sum(10,20,30,40,50,60,70,80,90,100));
        }
    
        //public static int sum(int b,int... a) {
        // return 0;
        //}
    
        public static int sum(int... a) {
            int sum = 0;
            for(int i : a) {
                sum += i;
            }
            return sum;
        }
    }
    

自由练习-5分钟

1.2创建不可变集合【理解】(视频 02)(10 “)

  • 方法介绍

    • 在List、Set、Map接口中,都存在of方法,可以创建一个不可变的集合
      • 这个集合不能添加,不能删除,不能修改
      • 但是可以结合集合的带参构造,实现集合的批量添加
    • 在Map接口中,还有一个ofEntries方法可以提高代码的阅读性
      • 首先会把键值对封装成一个Entry对象,再把这个Entry对象添加到集合当中
  • 示例代码

    public class MyVariableParameter4 {
        public static void main(String[] args) {
            // static <E>  List<E>  of(E…elements)  创建一个具有指定元素的List集合对象
            //static <E>  Set<E>  of(E…elements)    创建一个具有指定元素的Set集合对象
            //static <K , V>   Map<K,V>  of(E…elements) 创建一个具有指定元素的Map集合对象
    
            //method1();
            //method2();
            //method3();
            //method4();
    
        }
    
        private static void method4() {
            Map<String, String> map = Map.ofEntries(
                    Map.entry("zhangsan", "江苏"),
                    Map.entry("lisi", "北京"));
            System.out.println(map);
        }
    
        private static void method3() {
            Map<String, String> map = Map.of("zhangsan", "江苏", "lisi", "北京", "wangwu", "天津");
            System.out.println(map);
        }
    
        private static void method2() {
            //传递的参数当中,不能存在重复的元素。
            Set<String> set = Set.of("a", "b", "c", "d","a");
            System.out.println(set);
        }
    
        private static void method1() {
            List<String> list = List.of("a", "b", "c", "d");
            System.out.println(list);
            //list.add("Q");
            //list.remove("a");
            //list.set(0,"A");
            //System.out.println(list);
    
    //        ArrayList<String> list2 = new ArrayList<>();
    //        list2.add("aaa");
    //        list2.add("aaa");
    //        list2.add("aaa");
    //        list2.add("aaa");
    
            //集合的批量添加。
            //首先是通过调用List.of方法来创建一个不可变的集合,of方法的形参就是一个可变参数。
            //再创建一个ArrayList集合,并把这个不可变的集合中所有的数据,都添加到ArrayList中。
            ArrayList<String> list3 = new ArrayList<>(List.of("a", "b", "c", "d"));
            System.out.println(list3);
        }
    }
    
  • 数组转换成集合 常用的三种方式

    public static void main(String[] args) {
        String[] strings = {"a", "b", "c", "d"};
    
        //方式一  :  得到的集合可以进行修改
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1, strings);
        System.out.println(list1);
    
        //方式二  : 得到的集合不能进行修改
        List<String> list2 = Arrays.asList(strings);
    	
        
        //方式三  :  得到的集合不能进行修改
        List<String> list3 = List.of(strings);
    
    
        //方式二 和 方式三  想要集合可以进行修改 :
        // 通过原有的集合创建一个新的集合对象就可以了
        List<String> newList2 = new ArrayList<>(list2);
        List<String> newList3 = new ArrayList<>(list3);
    }
    

自由练习-5分钟

2.Stream流

2.1体验Stream流【理解】(视频 03)(6 “)

  • 案例需求

    按照下面的要求完成集合的创建和遍历

    • 创建一个集合,存储多个字符串元素
    • 把集合中所有以"张"开头的元素存储到一个新的集合
    • 把"张"开头的集合中的长度为3的元素存储到一个新的集合
    • 遍历上一步得到的集合
  • 原始方式示例代码

    public class MyStream1 {
        public static void main(String[] args) {
            //集合的批量添加
            ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
            //list.add()
    
            //遍历list1把以张开头的元素添加到list2中。
            ArrayList<String> list2 = new ArrayList<>();
            for (String s : list1) {
                if(s.startsWith("张")){
                    list2.add(s);
                }
            }
            //遍历list2集合,把其中长度为3的元素,再添加到list3中。
            ArrayList<String> list3 = new ArrayList<>();
            for (String s : list2) {
                if(s.length() == 3){
                    list3.add(s);
                }
            }
            for (String s : list3) {
                System.out.println(s);
            }      
        }
    }
    
  • 使用Stream流示例代码

    public class StreamDemo {
        public static void main(String[] args) {
            //集合的批量添加
            ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
    
            //Stream流
            list1.stream().filter(s->s.startsWith("张"))
                    .filter(s->s.length() == 3)
                    .forEach(s-> System.out.println(s));
        }
    }
    
  • Stream流概述

  • 专门用来处理集合和数组的一个工具

  • Stream流的好处

    • 代码简洁
  • Stream流版本

    • 必须是jdk1.8以上版本

2.2Stream流的常见生成方式【应用】 (视频 04、05)

  • Stream流的思想

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GY7RhFAq-1629968368443)(.\img\01_Stream流思想.png)]在这里插入图片描述

  • Stream流的三类方法

    • 获取Stream流
      • 创建一条流水线,并把数据放到流水线上准备进行操作
    • 中间方法
      • 流水线上的操作
      • 一次操作完毕之后,还可以继续进行其他操作
    • 终结方法
      • 一个Stream流只能有一个终结方法
      • 是流水线上的最后一个操作
  • 生成Stream流的方式

    • Collection体系集合

      使用默认方法stream()生成流, default Stream stream()

    • Map体系集合

      把Map转成单列集合,间接的生成流

    • 数组

      通过Arrays中的静态方法stream生成流

    • 同种数据类型的多个数据

      通过Stream接口的静态方法of(T… values)生成流

  • 代码演示

    public class StreamDemo {
        public static void main(String[] args) {
            //Collection体系的集合可以使用默认方法stream()生成流
            List<String> list = new ArrayList<String>();
            Stream<String> listStream = list.stream();
    
            Set<String> set = new HashSet<String>();
            Stream<String> setStream = set.stream();
    
            //Map体系的集合间接的生成流
            Map<String,Integer> map = new HashMap<String, Integer>();
            Stream<String> keyStream = map.keySet().stream();
            Stream<Integer> valueStream = map.values().stream();
            Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
    
            //数组可以通过Arrays中的静态方法stream生成流
            String[] strArray = {"hello","world","java"};
            Stream<String> strArrayStream = Arrays.stream(strArray);
          
          	//同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流
            Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
            Stream<Integer> intStream = Stream.of(10, 20, 30);
        }
    }
    

自由练习-5分钟

2.3Stream流中间操作方法【应用】 (视频 06、07)

  • 概念

    中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作

  • 常见方法

    方法名说明
    Stream filter(Predicate predicate)用于对流中的数据进行过滤
    Stream limit(long maxSize)返回此流中的元素组成的流,截取指定参数个数的数据
    Stream skip(long n)跳过指定参数个数的数据,返回由该流的剩余元素组成的流
    static Stream concat(Stream a, Stream b)合并a和b两个流为一个流
    Stream distinct()返回由该流的不同元素(根据Object.equals(Object) )组成的流
    Stream map(Function function)类型转换
  • filter代码演示

    public class MyStream3 {
        public static void main(String[] args) {
    //        Stream<T> filter(Predicate predicate):过滤
    //        Predicate接口中的方法	boolean test(T t):对给定的参数进行判断,返回一个布尔值
    
            ArrayList<String> list = new ArrayList<>();
            list.add("张三丰");
            list.add("张无忌");
            list.add("张翠山");
            list.add("王二麻子");
            list.add("张良");
            list.add("谢广坤");
    
            //filter方法获取流中的 每一个数据.
            //而test方法中的s,就依次表示流中的每一个数据.
            //我们只要在test方法中对s进行判断就可以了.
            //如果判断的结果为true,则当前的数据留下
            //如果判断的结果为false,则当前数据就不要.
    //        list.stream().filter(
    //                new Predicate<String>() {
    //                    @Override
    //                    public boolean test(String s) {
    //                        boolean result = s.startsWith("张");
    //                        return result;
    //                    }
    //                }
    //        ).forEach(s-> System.out.println(s));
    
            //因为Predicate接口中只有一个抽象方法test
            //所以我们可以使用lambda表达式来简化
    //        list.stream().filter(
    //                (String s)->{
    //                    boolean result = s.startsWith("张");
    //                        return result;
    //                }
    //        ).forEach(s-> System.out.println(s));
    
            list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));
    
        }
    }
    
  • limit&skip代码演示

    public class StreamDemo02 {
        public static void main(String[] args) {
            //创建一个集合,存储多个字符串元素
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("林青霞");
            list.add("张曼玉");
            list.add("王祖贤");
            list.add("柳岩");
            list.add("张敏");
            list.add("张无忌");
    
            //需求1:取前3个数据在控制台输出
            list.stream().limit(3).forEach(s-> System.out.println(s));
            System.out.println("--------");
    
            //需求2:跳过3个元素,把剩下的元素在控制台输出
            list.stream().skip(3).forEach(s-> System.out.println(s));
            System.out.println("--------");
    
            //需求3:跳过2个元素,把剩下的元素中前2个在控制台输出
            list.stream().skip(2).limit(2).forEach(s-> System.out.println(s));
        }
    }
    
  • concat&distinct代码演示

    public class StreamDemo03 {
        public static void main(String[] args) {
            //创建一个集合,存储多个字符串元素
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("林青霞");
            list.add("张曼玉");
            list.add("王祖贤");
            list.add("柳岩");
            list.add("张敏");
            list.add("张无忌");
    
            //需求1:取前4个数据组成一个流
            Stream<String> s1 = list.stream().limit(4);
    
            //需求2:跳过2个数据组成一个流
            Stream<String> s2 = list.stream().skip(2);
    
            //需求3:合并需求1和需求2得到的流,并把结果在控制台输出
    		Stream.concat(s1,s2).forEach(s-> System.out.println(s));
    
            //需求4:合并需求1和需求2得到的流,并把结果在控制台输出,要求字符串元素不能重复
            Stream.concat(s1,s2).distinct().forEach(s-> System.out.println(s));
        }
    }
    

自由练习-6分钟

2.4Stream流终结操作方法【应用】(视频 08)(8 “)

  • 概念

    终结操作的意思是,执行完此方法之后,Stream流将不能再执行其他操作

  • 常见方法

    方法名说明
    void forEach(Consumer action)对此流的每个元素执行操作
    long count()返回此流中的元素数
  • 代码演示

    public class MyStream5 {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<>();
            list.add("张三丰");
            list.add("张无忌");
            list.add("张翠山");
            list.add("王二麻子");
            list.add("张良");
            list.add("谢广坤");
    
            //method1(list);
            
    //        long count():返回此流中的元素数
            long count = list.stream().count();
            System.out.println(count);
        }
    
        private static void method1(ArrayList<String> list) {
            //  void forEach(Consumer action):对此流的每个元素执行操作
            //  Consumer接口中的方法void accept(T t):对给定的参数执行此操作
            //在forEach方法的底层,会循环获取到流中的每一个数据.
            //并循环调用accept方法,并把每一个数据传递给accept方法
            //s就依次表示了流中的每一个数据.
            //所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.
            list.stream().forEach(
                    new Consumer<String>() {
                        @Override
                        public void accept(String s) {
                            System.out.println(s);
                        }
                    }
            );
          
            System.out.println("====================");
            //lambda表达式的简化格式
            //是因为Consumer接口中,只有一个accept方法
            list.stream().forEach(
                    (String s)->{
                        System.out.println(s);
                    }
            );
            System.out.println("====================");
            //lambda表达式还是可以进一步简化的.
            list.stream().forEach(s->System.out.println(s));
        }
    }
    

2.5Stream流的收集操作【应用】(视频 10 、11)

  • 概念

    对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中

  • 常用方法

    方法名说明
    R collect(Collector collector)把结果收集到集合中
  • 工具类Collectors提供了具体的收集方式

    方法名说明
    public static Collector toList()把元素收集到List集合中
    public static Collector toSet()把元素收集到Set集合中
    public static Collector toMap(Function keyMapper,Function valueMapper)把元素收集到Map集合中
  • 代码演示

    // toList和toSet方法演示 
    public class MyStream7 {
        public static void main(String[] args) {
            ArrayList<Integer> list1 = new ArrayList<>();
            for (int i = 1; i <= 10; i++) {
                list1.add(i);
            }
    
            list1.add(10);
            list1.add(10);
            list1.add(10);
            list1.add(10);
            list1.add(10);
    
            //filter负责过滤数据的.
            //collect负责收集数据.
                    //获取流中剩余的数据,但是他不负责创建容器,也不负责把数据添加到容器中.
            //Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.
            List<Integer> list = list1.stream().filter(number -> number % 2 == 0)
                    .collect(Collectors.toList());
    
            System.out.println(list);
    
        Set<Integer> set = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toSet());
        System.out.println(set);
    }
    }
    /**
    Stream流的收集方法 toMap方法演示
    创建一个ArrayList集合,并添加以下字符串。字符串中前面是姓名,后面是年龄
    "zhangsan,23"
    "lisi,24"
    "wangwu,25"
    保留年龄大于等于24岁的人,并将结果收集到Map集合中,姓名为键,年龄为值
    */
    public class MyStream8 {
    	public static void main(String[] args) {
          	ArrayList<String> list = new ArrayList<>();
            list.add("zhangsan,23");
            list.add("lisi,24");
            list.add("wangwu,25");
    
            Map<String, Integer> map = list.stream().filter(
                    s -> {
                        String[] split = s.split(",");
                        int age = Integer.parseInt(split[1]);
                        return age >= 24;
                    }
    
             //   collect方法只能获取到流中剩余的每一个数据.
             //在底层不能创建容器,也不能把数据添加到容器当中
    
             //Collectors.toMap 创建一个map集合并将数据添加到集合当中
    
              // s 依次表示流中的每一个数据
    
              //第一个lambda表达式就是如何获取到Map中的键
              //第二个lambda表达式就是如何获取Map中的值
            ).collect(Collectors.toMap(
                    s -> s.split(",")[0],
                    s -> Integer.parseInt(s.split(",")[1]) ));
    
            System.out.println(map);
    	}
    }
    

自由练习-6分钟

2.6Stream流综合练习【应用】(视频 12)(8 “)

  • 案例需求

    现在有两个ArrayList集合,分别存储6名男演员名称和6名女演员名称,要求完成如下的操作

    • 男演员只要名字为3个字的前三人
    • 女演员只要姓林的,并且不要第一个
    • 把过滤后的男演员姓名和女演员姓名合并到一起
    • 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据

    演员类Actor已经提供,里面有一个成员变量,一个带参构造方法,以及成员变量对应的get/set方法

  • 代码实现

    演员类

    public class Actor {
        private String name;
    
        public Actor(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    

    测试类

    public class StreamTest {
        public static void main(String[] args) {
            //创建集合
            ArrayList<String> manList = new ArrayList<String>();
            manList.add("周润发");
            manList.add("成龙");
            manList.add("刘德华");
            manList.add("吴京");
            manList.add("周星驰");
            manList.add("李连杰");
      
            ArrayList<String> womanList = new ArrayList<String>();
            womanList.add("林心如");
            womanList.add("张曼玉");
            womanList.add("林青霞");
            womanList.add("柳岩");
            womanList.add("林志玲");
            womanList.add("王祖贤");
      
            //男演员只要名字为3个字的前三人
            Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);
      
            //女演员只要姓林的,并且不要第一个
            Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);
      
            //把过滤后的男演员姓名和女演员姓名合并到一起
            Stream<String> stream = Stream.concat(manStream, womanStream);
      
          	// 将流中的数据封装成Actor对象之后打印
          	stream.forEach(name -> {
                Actor actor = new Actor(name);
                System.out.println(actor);
            }); 
        }
    }
    

2.7 Stream流-扩展补充

  • map(Function function) 方法

    方法名说明
    Stream map(Function function)类型转换
    public static void main(String[] args) {
        ArrayList<String> manList = new ArrayList<>();
        manList.add("张国立");
        manList.add("张晋");
        manList.add("刘烨");
        manList.add("郑伊健");
        manList.add("徐峥");
        manList.add("王宝强");
    
    	
        List<Actor> collect = manList.stream().map(s -> new Actor(s)).collect(Collectors.toList());
    }
    
  • 同一个stream对象只能调用一次方法

    public static void main(String[] args) {
        ArrayList<String> manList = new ArrayList<>();
        manList.add("张国立");
        manList.add("张晋");
        manList.add("刘烨");
        manList.add("郑伊健");
        manList.add("徐峥");
        manList.add("王宝强");
    
    	
        //错误代码
        Stream<String> stream = manList.stream();
        Stream<String> stringStream = stream.filter(s -> s.length() == 3);
        Stream<Actor> actorStream = stream.map(s -> new Actor(s));
    }
    

自由练习-6分钟

CUDA编程实战:从GPU并行计算原理到环境部署与性能优化 GPU并行计算是现代高性能计算的核心技术之一,它通过成千上万的计算核心同时处理海量数据,突破了传统CPU串行处理的性能瓶颈。其原理基于单指令多数据流架构,特别适合处理矩阵运算等高度并行的任务,在人工智能、科学计算和大数据分析领域展现出巨大技术价值。CUDA作为英伟达推出的统一计算架构,通过网格、线程块和线程的三级抽象模型,为开发者提供了高效的GPU编程接口。在实际应用中,合理利用全局内存、共享内存和寄存器的层次结构,并优化内存访问模式,是提升程序性能的关键。本文以环境部署和性能调优为主线,结合Nsight性 阅读详情

相关推荐

llama.cpp tools深度解析:量化、压测与并发性能调优实战

GGUF格式是llama.cpp推理生态的核心容器,其模型量化与性能验证高度依赖原生C++工具链。quantize工具通过分组量化(如Q4_K_M)在精度、显存与延迟间实现工程平衡;llama-bench以硬件级参数(--gpu-layers、--flash-attn)精准定位GPU kernel与内存带宽瓶颈;llama-batched-bench则模拟真实服务负载,暴露多并发下的KV缓存竞争与显存带宽天花板。这些工具共同构成从模型瘦身到生产压测的闭环能力,尤其适用于Windows 11 CUDA部署、S

weixin_33720078的博客 348

java8stream排序并获取前三个

sorted()方法进行排序,并利用limit()方法进行截取前几个。需求:根据某个类里面的某个字段对集合进行排序并截取前三个。思路:利用java8新特性stream流里面的。根据下面实体类的字段进行排序。

weixin_60948956的博客 5916

【合规领域】【信息科学与工程学】计算机科学与自动化——第五百篇 国产化/XC解决方案 第二篇 海光CPU/DPU芯片适配01

信创软件与海光CPU/DCU(深算单元,常被统称为海光GPU加速卡)的适配,核心思路是:海光CPU兼容x86指令集、海光DCU兼容"类CUDA"环境,因此绝大多数x86应用和CUDA生态组件可以通过"轻量迁移"而非"重写"的方式落地。本条目的目标是把"海光x86 CPU + 海光DCU加速卡 + 统信UOS/银河麒麟 + 国密算法"串成一条可验收的链路。海光CPU(C86系列):兼容x86指令集(完整x86-64及SSE、AVX等主流扩展),基于AMD Zen1微架构深度定制的国产路线,国内唯一获得x86指

weixin_49199313的博客 119

JavaSE进阶笔记-集合04(可变参数,Stream流)

1.可变参数 1.1可变参数【应用】 可变参数介绍 可变参数又称参数个数可变,用作方法的形参出现,那么方法参数个数就是可变的了 方法的参数类型已经确定,个数不确定,我们可以使用可变参数 可变参数定义格式 修饰符 返回值类型 方法名(数据类型… 变量名) { } 可变参数的注意事项 这里的变量其实是一个数组 如果一个方法有多个参数,包含可变参数,可变参数要放在最后 可变参数的基本使用 public class ArgsDemo01 { public static void

SUIT THUG!的博客 388

佳能相机EDSDK开发入门:从枚举相机到多机位协同的完整指南

在工业视觉与影像自动化领域,设备控制软件开发的核心挑战之一,是如何将相机从手动操作的硬件转换为可编程的自动化节点。佳能官方提供的EDSDK(Camera Development Kit)正是应对这一需求的原生开发库,它允许开发者通过C/C++或C#等语言直接控制快门、光圈、ISO及实时取景功能。理解SDK的初始化流程、事件回调机制以及属性读写闭环,是搭建可靠系统的关键。典型的应用场景包括商品拍摄流水线、多机位影棚协同、批量影像数据采集等工程实践。本文围绕Windows端开发环境,梳理从设备枚举、会话建立到图

weixin_34252090的博客 457

佳能相机SDK开发实战:从EDSDK初始化到实时取景与断线重连

在机器视觉与自动化采集场景中,如何让相机像工业设备一样被程序精确控制,是很多开发者面临的共性需求。佳能官方提供的EDSDK(Edwards Camera SDK)正是解决这一问题的关键工具,它通过C风格API与事件回调模型,屏蔽了USB底层协议,使开发者能够快速完成相机连接、参数设置、图像下载及实时取景等操作。本文从环境配置与最小可运行代码入手,梳理SDK初始化、事件驱动拍照、图像数据传输及避坑要点,并介绍如何通过Watchdog机制实现断线自动重连,以保障长期无人值守场景下的稳定性。无论你是做影棚自动化、

weixin_34315485的博客 378

Cpp使用tensorrt10.8推理Yolov8

【代码】Cpp使用tensorrt10.8推理Yolov8。

qq_49595983的博客 226

first-n-stream:从流中获取前n个对象

第一流 通过的objectMode流将前n个条目转移到另一个流或回调中 npm install --save first-n-stream 原料药 var FirstN = require ( 'first-n-stream' ) ; var withCallback = new FirstN ( 5 , function ( err , resp ) { // resp will be an array of the first 5 items } ) ; something . pipe ( withCallback ) . pipe ( streamThatWillGetTheRest ) ; var withStream = new FirstN ( 5 , streamThatWillGetTheFirst5 ) ; something . pipe ( withStream

yolov11安装,训练模型,tensorrtx加速,Qt预测图像

yolov11安装,训练模型,tensorrtx加速,Qt预测图像

qq_30150579的博客 1350

pandas groupby 分组取每组的前几行记录方法

下面小编就为大家分享一篇pandas groupby 分组取每组的前几行记录方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧

ASPICE1-配置管理

SUP.8配置管理 BP1:开发配置管理策略 BP2:识别配置项 BP3:建立配置项管理系统 BP4:建立分支管理 BP5:控制变更和发布 BP6: 建立基线 BP7:报告配置项状态 BP8:验证配置项信息 BP9:管理配置项和基线的存储 1.配置管理概念 配置管理(Configuration Management,CM)是通过使用技术或行政手段对软件产品进行控制,以实现对软件开发过程和生命周期进行控制、规范的一系列措施。 完整性、一致性、可控性。 2.配置管理的主要活动: 1.

HDZQ2005的专栏 3687

ANTLR4 C++语法解析器实战指南:从入门到深度精通

ANTLR4作为业界领先的语法解析器生成工具,其C++目标实现为开发者提供了高性能的语言识别能力。本文将全面解析ANTLR4 C++的核心架构、实战应用和性能优化策略,帮助开发者快速掌握这一强大的语法解析工具。 ## 项目概述与核心价值 ANTLR4 C++运行时库是一个功能完整的语法解析器生成器实现,支持C++17标准,能够在Windows、macOS、Linux和Android等多平台上运

gitblog_00233的博客 712

URDF模型转换实战:解决SolidWorks到Gazebo的五大常见问题

本文详细解析了从SolidWorks导出URDF模型到Gazebo仿真过程中常见的五大问题及解决方案,包括插件安装、坐标系建立、Link与Joint配置等关键步骤。通过实战经验分享,帮助机器人仿真工程师高效完成模型转换,确保Gazebo仿真准确性。

weixin_29052717的博客 446

window下让QTextStream写文本时能够自动换行

window7下QT;目的是让QTextStream写文本时能够自动换行代码如下 :这是在window7下QT的;目的是让QTextStream 中能够自动换行,但尝试了半天,平常编程中的&lt;&lt;\n  &lt;&lt;\t  &lt;&lt;"\n" &lt;&lt;"\t" &lt;&lt;endl 都是不行的。摸索了半天,最后在qt 的help中找到了原因:在Windows上

komtao520的博客 1933

快充协议全兼容!HUSB390对比测试:iPhone/小米/华为哪个充电最快?

本文深入评测了HUSB390快充协议芯片的全兼容性能,展示了其在iPhone、小米和华为设备上的极速充电表现。通过智能功率分配算法和多协议并行处理引擎,HUSB390实现了高效的动态调压和温度控制,显著提升多设备充电效率。特别适合需要同时为不同品牌设备快充的用户。

dd012的博客 1万+

告别TI官网迷路!手把手教你用C2000Ware为TMS320F28027搭建Proteus仿真工程模板

本文详细指导如何使用C2000Ware为TMS320F28027搭建Proteus仿真工程模板,帮助DSP开发者快速上手。从资源获取、工程目录设计到关键文件配置,再到CCS与Proteus的联调技巧,全面解析仿真工程搭建的每个步骤,特别适合初学者和工程师参考。

weixin_42715608的博客 474

CANN ops-transformer 算子实战:aclnnRotaryPositionEmbeddingV2 旋转位置编码接口详解与 rotate 矩阵加速

本篇指南围绕 CANN ops-transformer 仓库中 `posembedding/rotary_position_embedding` 模块的 aclnnRotaryPositionEmbeddingV2 接口展开,讲解其在 NPU 上执行单路旋转位置编码(RoPE)计算的完整用法:包括两段式接口调用流程、half/interleave 旋转模式与计算公式、新增入参 rotate 旋转矩

gitblog_00971的博客 613

先进封装类别分析与典型案例

当制程微缩逼近物理极限、单颗大芯片(reticle limit)面积受限于光罩尺寸,且逻辑、存储、射频、传感等功能无法用同一套工艺最经济地制造时,性能增益的来源从 "晶体管密度" 转向 "互连密度"。先进封装的本质,是在芯片外部用更短、更密、更宽的路径把多个裸 die(die)互连起来,换取更高带宽、更低延迟、更小体积和异构集成能力。行业通常按划分为 2D、2.5D、3D、扇出、SiP 五大谱系,Chiplet/UCIe 则是贯穿其上的设计方法论,玻璃基板、共封装光学(CPO)是正在成型的新分支。

0 37

CANN ops-math 算子解析:DropOutV3 随机丢弃算子的原理、参数与双模式调用实战

DropOutV3 是 CANN ops-math 数学算子库中用于训练阶段正则化的随机丢弃算子:它以概率 p 将输入张量中的元素随机置零,并将存活元素按 1/(1-p) 比例缩放,同时输出可供反向传播复用的 mask。本文以 [DropOutV3 算子文档](https://link.gitcode.com/i/38cfde64f1e54d5d365e5d329bf40b22) 与 [aclnn

gitblog_00905的博客 765

python全栈入门到实战【基础篇 01】Python初识:定位、优势与发展历程

本文介绍了热门编程语言Python。它是解释型高级语言,具通用、入门友好、胶水型特点,以简洁易读为设计哲学。优势包括语法简洁高效、生态庞大、跨平台、社区活跃、应用广泛、门槛低。发展历经诞生(1989-1994,吉多创建,1994年1.0发布)、成长(版本迭代,3.0发布)、崛起(Web与大数据推动)、爆发(AI浪潮助推)及持续迭代阶段。

那些看似不起波澜的日复一日,会在某天让你看到坚持的意义 1万+

innovus:Clock Gating Check设置与报告

看图后发现,在设置clock gating check之前报告也会有clock gating check的值,这个就是因为timing library中会像reg一样定 library setup time值,如下图。我们常用set_clock_gating_check -setup去过约束Place阶段reg2cgate的时序,以防CTS后由于tree不平导致的时序违例。我正在「拾陆楼」和朋友们讨论有趣的话题,你⼀起来吧?

m0_61544122的博客 1020

CANN ops-nn 算子详解:aclnnNLLLoss 负对数似然损失(NLL Loss)两段式接口开发指南

`aclnnNLLLoss` 是 CANN 神经网络算子库([cann/ops-nn](https://link.gitcode.com/i/2458c79767adf17ba947c6ef895470e9))中用于计算负对数似然损失(Negative Log Likelihood Loss, NLL Loss)的 AscendCL 接口,典型应用场景是与 `LogSoftmax` 组合完成多分类

gitblog_00545的博客 378

Onnxruntime之YOLOP部署过程记录

魔改YoloP部署过程记录

如果想成为中心,那么就到中心去吧。 1930

CANN ops-math DropOutV3 算子 aclnnDropoutV3 两段式接口使用指南与实现原理

本文以 CANN ops-math 仓库中 [DropOutV3 算子 aclnn 接口文档](https://link.gitcode.com/i/33ef0090b5da1bcbcc568b899ca159f4) 为核心,结合该算子从 op_api、op_host、op_kernel 到图融合的完整源码实现,系统讲解 DropOutV3 算子的功能语义、aclnnDropoutV3 两段式接口

gitblog_00038的博客 324

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

CANN ops-nn 中 CrossEntropyLoss 算子的 aclnnCrossEntropyLoss 接口使用指南:公式、两段式调用与源码实现解析

CrossEntropyLoss(交叉熵损失)是深度学习中分类任务最常用的损失函数,CANN 的神经网络算子库 ops-nn 在 `loss/cross_entropy_loss` 目录下提供了面向昇腾 NPU 的该算子实现,并对外暴露 `aclnnCrossEntropyLoss` 单算子 API。本文以 [loss/cross_entropy_loss/docs/aclnnCrossEntro

gitblog_01090的博客 389

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

【Java 8 新特性】Java Stream通过limit()获取前N条元素

Stream的limit方法返回一个新的流,该流的元素被截断为给定的最大长度。limit方法包含前n个元素,其中n小于或等于给定的最大大小。 在javadoc中的limit方法声明。 Stream<T> limit(long maxSize) 参数:参数maxSize是limit返回的流中的最大元素数。 返回:limit方法返回新的流。 异常:如果参数maxSize超出元素数,则该方法抛出IllegalArgumentException。 limit方法是一种短路状态的中间操作(short-

猫巳的博客 3万+

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

上一篇: 9HashSet&Map 红黑树 HashMap TreeMap
下一篇: 11File&IO流01 字节流 字节缓冲流
InLoadwetrust
博客等级 码龄6年 11粉丝 84原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

InLoadwetrust

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值