03-详细介绍Stream及其常用API

Stream API

Stream API(java.util.stream)把真正的函数式编程风格引入到Java中,可以极大地提高程序员生产力，让程序员写出高效、简洁的代码

实际开发中项目中多数数据源都是来自MySQL、Oracle等关系型数据库,还有部分来自MongDB、Redis等非关系型数据库

  • 从关系型数据库中查询数据时: 可以先使用SQL语句在数据库中就对数据进行过滤,排序等操作,最后后台Java程序接收
  • 从非关系型数据库中查询数据: 由于不能在数据库中使用SQL语句操作数据,此时只能靠后台Java程序(Stream API)操作数据库中查询到的数据

Stream是Java8中处理集合的关键抽象概念,它可以指定你希望对集合/数组进行的操作(可是是非常复杂的查找、过滤和映射数据等操作)

  • 使用Stream API对内存数据(集合/数组)进行操作就类似于使用SQL语句对数据库表中数据的操作,即Stream API提供了一种高效且易于使用的处理数据的方式

Stream和Collection集合的区别: Stream关注的是数据的运算(过滤操作)与CPU打交道, 集合关注的是数据的存储(静态的存储结构)与内存打交道

Stream的特性如操作链

  • Stream自己不会存储元素
  • Stream不会改变源对象,相反他们会返回一个持有结果的新Stream
  • Stream操作是延迟执行的,只有执行了终止操作后才会执行中间操作链并产生结果
  • Stream一旦执行了终止操作，就不能再次使用该Stream执行其它中间操作或终止操作了,得重新创建一个新的流才行

在这里插入图片描述

数据准备

编写实体类Employee

@Date
public class Employee {private int id;private String name;private int age;private double salary;public Employee() {System.out.println("Employee().....");}public Employee(int id) {this.id = id;System.out.println("Employee(int id).....");}public Employee(int id, String name) {this.id = id;this.name = name;}public Employee(int id, String name, int age, double salary) {this.id = id;this.name = name;this.age = age;this.salary = salary;}@Overridepublic String toString() {return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';}@Overridepublic boolean equals(Object o) {if (this == o)return true;if (o == null || getClass() != o.getClass())return false;Employee employee = (Employee) o;if (id != employee.id)return false;if (age != employee.age)return false;if (Double.compare(employee.salary, salary) != 0)return false;return name != null ? name.equals(employee.name) : employee.name == null;}@Overridepublic int hashCode() {int result;long temp;result = id;result = 31 * result + (name != null ? name.hashCode() : 0);result = 31 * result + age;temp = Double.doubleToLongBits(salary);result = 31 * result + (int) (temp ^ (temp >>> 32));return result;}
}

创建一个ArrayList集合提供测试数据

public class EmployeeData {public static List<Employee> getEmployees() {List<Employee> list = new ArrayList<>();list.add(new Employee(1001, "马化腾", 34, 6000.38));list.add(new Employee(1002, "马云", 12, 9876.12));list.add(new Employee(1003, "刘强东", 33, 3000.82));list.add(new Employee(1004, "雷军", 26, 7657.37));list.add(new Employee(1005, "李彦宏", 65, 5555.32));list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));list.add(new Employee(1007, "任正非", 26, 4333.32));list.add(new Employee(1008, "扎克伯格", 35, 2500.32));return list;}
}

通过一个数据源创建Stream

方式一通过集合(常用):Java8中的Collection接口扩展了两个获取Stream流的方法

方法名功能
default Stream stream()返回一个顺序流(按照顺序操作元素)
default Stream parallelStream()返回一个并行流(并发的操作元素)
@Test
public void test01(){// 创建List集合List<Integer> list = Arrays.asList(1,2,3,4,5);// 返回一个顺序流Stream<Integer> stream1 = list.stream();// 返回一个并行流Stream<Integer> stream2 = list.parallelStream();List<Employee> employees = EmployeeData.getEmployees();// 返回一个顺序流Stream<Employee> stream = employees.stream();// 返回一个并行流Stream<Employee> employeeStream = employees.parallelStream();
}

方式二通过数组: Java8中的Arrays类的静态方法stream()可以获取对应类型的Stream流

方法名功能
static Stream stream(T[] array)返回一个自定义类型的Stream流
public static IntStream stream(int[] array)返回一个int类型的Stream流
public static LongStream stream(long[] array)返回一个long类型的Stream流
public static DoubleStream stream(double[] array)返回一个double类型的Stream流
@Test
public void test(){// 获取基本数据类型的Stream流int[] arr = {1,2,3,4,5};IntStream stream = Arrays.stream(arr);// 获取引用数据类型的Stram流String[] arr = {"hello","world"};Stream<String> stream = Arrays.stream(arr); // 获取自定义类型的Stream流Employee kyle = new Employee(9527, "Kyle");Employee lucy = new Employee(9421, "Lucy");Employee[] employees = {kyle, lucy};Stream<Employee> stream1 = Arrays.stream(employees);
}

方式三通过指定具体数据: 调用Stream类静态方法of()创建一个流

方法名功能
public static Stream of(T… values)通过手动指定任意个数据创建一个流
@Test
public void test04(){Stream<Integer> stream = Stream.of(1,2,3,4,5);stream.forEach(System.out::println);
}

方式四调用Stream类的静态方法iterate()和generate()创建无限流(了解)

方法名功能
public static Stream iterate(final T seed, final UnaryOperator f)迭代
public static Stream generate(Supplier s)生成
@Test
public void test() {// 从0开始迭代遍历10个数,没有limit限制会无限迭代Stream.iterate(0, t -> t + 1).limit(10).forEach(System.out::println);// 生成10个随机数,没有limit限制会无限生成Stream.generate(Math::random).limit(10).forEach(System.out::println);
}

中间操作筛选与切片

中间操作就是处理数据的具体操作,每次处理都会返回一个持有结果的新Stream,即中间操作的方法返回值仍然是Stream类型的对象

  • 中间操作可以是个操作链可对数据源的数据进行n次处理(多个中间操作),但是所有的中间操作只有在执行终止操作时才会一次性全部处理(惰性求值)
  • Stream流一旦执行了终止操作就不能再次使用该Stream执行其它中间操作,需要根据数据源重新创建一个新的Stream流
方 法描 述
filter(Predicatep)接收Lambda表达式按照规则后从流中排除某些元素
distinct()筛选通过流所生成元素的hashCode() 和 equals()方法去除重复元素
limit(long maxSize)截断流使其元素不超过给定数量,返回一个只保留前n个元素的流
skip(long n)跳过元素返回一个扔掉了前 n个元素的流, 若流中元素不足n个则返回一个空流
@Test
public void test() {List<Employee> employees = EmployeeData.getEmployees();//1. 查询工资大于7000的员工信息employees.stream().filter(employee -> employee.getSalary() > 7000).forEach(System.out::println);System.out.println("----------------------------");//2. 只输出3条员工信息employees.stream().limit(3).forEach(System.out::println);System.out.println("----------------------------");//3. 跳过前3个元素employees.stream().skip(3).forEach(System.out::println);System.out.println("----------------------------");//4. 通过流所生成元素的hashCode和equals方法去除重复元素employees.add(new Employee(9527, "Kyle", 20, 9999));employees.add(new Employee(9527, "Kyle", 20, 9999));employees.stream().distinct().forEach(System.out::println);
}
/*
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
----------------------------
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
----------------------------
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1007, name='任正非', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
----------------------------
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1007, name='任正非', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
Employee{id=9527, name='Kyle', age=20, salary=9999.0}
*/

中间操作映射新的Stream

编写函数逻辑: 遍历Stream中的每个元素转换成其他形式或提取流中元素的信息

方法描述
map(Function f)接收一个函数作为参数, 该函数会被应用到每个元素上最终得到一个新的元素放入Stream中
mapToDouble(ToDoubleFunction f)接收一个函数作为参数，该函数会被应用到每个元素上产生一个新的DoubleStream
mapToInt(ToIntFunction f)接收一个函数作为参数，该函数会被应用到每个元素上产生一个新的IntStream
mapToLong(ToLongFunction f)接收一个函数作为参数，该函数会被应用到每个元素上产生一个新的LongStream
flatMap(Function f)接收一个函数作为参数， 该函数会被应用到每个元素上最终得到一个新的Stream,最后把所有Stream连接成一个Stream

map和flatMap的区别: map方法最终会得到一个Stream(含有多个Stream实例),flatMap最终会得到一个Stream(含有多个元素)

@Test
public void test() {ArrayList list1 = new ArrayList();list1.add(1);list1.add(2);list1.add(3);ArrayList list2 = new ArrayList();list2.add(1);list2.add(2);list2.add(3);// 集合中有4个元素,[1,2,3,[4,5,6]],类似maplist1.add(list2);// 集合中有6个元素,[1,2,3,4,5,6],类似flatMaplist1.addAll(list2);System.out.println(list1);
}

public class LambdaTest{@Testpublic void test() {List<String> strings = Arrays.asList("aa", "bb", "cc", "dd");List<Employee> employees = EmployeeData.getEmployees();// 将集合所有元素转为大写并输出strings.stream().map(s -> s.toUpperCase()).forEach(System.out::println);System.out.println("--------------------------");// 获取员工姓名长度大于3的员工的姓名employees.stream().map(Employee::getName).// 过滤出name长度>3的员工filter(name -> name.length() > 3).// 遍历输出forEach(System.out::println);System.out.println("--------------------------");// 使用map将字符串中的多个字符构成的集合转换为对应的Stream实例,然后再获取每一个Stream中的元素strings.stream().map(LambdaTest::formStringToStream).forEach(characterStream -> characterStream.forEach(System.out::println));// 使用flatMap可以直接获取Stream中Stream实例中的元素System.out.println("--------------------------");strings.stream().flatMap(LambdaTest::formStringToStream).forEach(System.out::println);}public static Stream<Character> formStringToStream(String str) {ArrayList<Character> list = new ArrayList<>();for (char c : str.toCharArray()) {list.add(c);}return list.stream();}}
/*
AA
BB
CC
DD
--------------------------
比尔盖茨
扎克伯格
--------------------------
a
a
b
b
c
c
d
d
--------------------------
*/

中间操作排序

方法描述
sorted()产生一个新流其中按自然顺序排序
sorted(Comparator com)产生一个新流其中按比较器顺序排序
@Test
public void test20() {List<Integer> nums = Arrays.asList(13, 54, 97, 52, 43, 64, 27);List<Employee> employees = EmployeeData.getEmployees();//自然排序,如果要对employees自然排序就需要Employee类实现Comparable接口nums.stream().sorted().forEach(System.out::println);//定制排序，先按照年龄升序排，再按照工资降序排employees.stream().sorted((o1, o2) -> {int compare = Integer.compare(o1.getAge(), o2.getAge());if (compare != 0) {return compare;} else {return -Double.compare(o1.getSalary(), o2.getSalary());} }).forEach(System.out::println);
}/*
13
27
43
52
54
64
97
------------------
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1007, name='任正非', age=26, salary=4333.32}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
*/

终止操作匹配与查找

终端操作会从流的流水线生成结果,方法返回值类型就不再是Stream了可以是任何不是流的值(如List,Integer,void等),并且不能再执行其他中间操作或终止操作

方法描述
allMatch(Predicate p)检查是否匹配所有元素
anyMatch(Predicate p)检查是否至少匹配一个元素
noneMatch(Predicate p)检查是否没有匹配所有元素
findFirst()返回第一个元素
findAny()返回当前流中的任意元素,顺序流会取第一个元素
count()返回流中元素总数
max(Comparator c)返回流中最大值
min(Comparator c)返回流中最小值
forEach(Consumer c)Stream API帮你把迭代做了内部迭代
使用 Collection接口需要用户去做迭代(称为外部迭代)
@Test
public void test21(){List<Employee> employees = EmployeeData.getEmployees();// 练习：是否所有的员工的工资是否都大于5000System.out.println("是否所有的员工的工资是否都大于5000："+employees.stream().allMatch(employee -> employee.getSalary() > 5000));// 练习：是否存在员工年龄小于15System.out.println("是否存在员工年龄小于15："+employees.stream().anyMatch(employee -> employee.getAge() < 15));// 练习：是否不存在员工姓“马”System.out.println("是否不存在员工姓马："+employees.stream().noneMatch(employee -> employee.getName().startsWith("马")));// 返回流中的第一个元素System.out.println("返回第一个元素："+employees.stream().findFirst());// 返回当前流中的任意元素System.out.println("返回当前流中的任意元素"+employees.stream().findAny());// 返回流中元素的总个数(返回总个数前可以先过滤)System.out.println("返回元素总数："+employees.stream().count());// 返回流中最高工资System.out.println("返回最高工资："+employees.stream().map(Employee::getSalary).max(Double::compare));// 返回最低工资的员工System.out.println("返回最高工资："+employees.stream().min(e1,e2 -> Double.compare(e1.getSalary(),e2.getSalary()));// 返回流中最小值System.out.println("返回最小年龄："+employees.stream().map(Employee::getAge).min(Integer::compare));// 内部迭代employees.stream().forEach(System.out::println);System.out.println("-------------");// 使用集合的遍历操作employees.forEach(System.out::println);
}/*
是否所有的员工的工资是否都大于5000：false
是否存在员工年龄小于15：true
是否不存在员工姓马：false
返回第一个元素：Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]
返回当前流中的任意元素Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]
返回元素总数：8
返回最高工资：Optional[9876.12]
返回最小年龄：Optional[12]
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1007, name='任正非', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
-------------
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1007, name='任正非', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
*/

终止操作归约

map和reduce的连接通常称为map-reduce模式,因Google用它来进行网络搜索而出名

方法描述
reduce(T identity, BinaryOperator b)可以将流中元素反复结合起来返回一个值T
reduce(BinaryOperator b)可以将流中元素反复结合起来返回一个值Optional
@Test
public void test22() {List<Integer> nums = Arrays.asList(13, 32, 23, 31, 94, 20, 77, 21, 17);List<Employee> employees = EmployeeData.getEmployees();// 练习1：计算1-10的自然数的和(0是初始值)System.out.println(nums.stream().reduce(0, Integer::sum));// 练习2：手动计算公司所有员工工资总和System.out.println(employees.stream().map(Employee::getSalary).reduce((o1, o2) -> o1 + o2));// 调用Integer的sum方法计算年龄总和System.out.println(employees.stream().map(Employee::getAge).reduce(Integer::sum));// 计算公司所有员工工资综合Stream<Double> salaryStream = employ.stream.map(Employee::getSalary);Optional<Double> sumMoney = salaryStream.reduce(Double::sum);System.out.println(sumMoney);
}
/*
328
Optional[48424.08]
Optional[273]
Optional[48424.08]
*/

终止操作收集

方 法描 述
collect(Collector c)接收一个Collector接口的实现类, 将Stream转换为其他形式,用于给Stream中元素做汇总

Collector接口中方法的实现决定了如何对流执行收集的操作(如收集到List、Set、Map),可以方便地创建常见收集器实例

方法返回类型作用
toListList把流中元素收集到List
List emps= list.stream().collect(Collectors.toList());
toSetList把流中元素收集到List
Set emps= list.stream().collect(Collectors.toSet());
toCollectionCollection把流中元素收集到创建的集合
Collection emps =list.stream().collect(Collectors.toCollection(ArrayList::new));
countingLong计算流中元素的个数
long count = list.stream().collect(Collectors.counting());
summinglntInteger对流中元素的整数属性求和
int total=list.stream().collect(Collectors.summingInt(Employee::getSalary));
averagingIntDouble计算流中元素Integer属性的平均值
double avg = list.stream().collect(Collectors.averagingInt(Employee::getSalary));
summarizinglntIntSummaryStatistics收集流中Integer属性的统计值
如平均值
int SummaryStatisticsiss=list.stream().collect(Collectors.summarizingInt(Employee::getSalary));
joiningString连接流中每个字符串
String str= list.stream().map(Employee::getName).collect(Collectors.joining());
maxByOptional根据比较器选择最大值
optionalmax=list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary));
minByOptional根据比较器选择最小值
Optionalmin = list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary));
reducing归约产生的类型从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值
int total=list.stream().collect(Collectors.reducing(0, Employe::getSalar, Integer::sum));
collectingAndThen转换函数返回的类型包裹另一个收集器,对其结果转换函数
int how= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));
groupingByMap<K, List>根据某属性值对流分组
属性为K,结果为V
Map<Emp.Status, List> map= list.stream().collect(Collectors.groupingBy(Employee::getStatus));
partitioningByMap<Boolean,List>根据true或false进行分区
Map<Boolean,List>vd=list.stream().collect(Collectors.partitioningBy(Employee::getManage));
@Test
public void test23() {// 练习1：查找工资大于6000的员工，结果返回为一个ListList<Employee> employees = EmployeeData.getEmployees();List<Employee> list = employees.stream().filter(employee -> employee.getSalary() > 6000).collect(Collectors.toList());list.forEach(System.out::println);System.out.println("--------------------");// 练习2：查找年龄大于20的员工，结果返回为一个Setemployees.add(new Employee(9527,"Kyle",21,9999));employees.add(new Employee(9527,"Kyle",21,9999));Set<Employee> set = employees.stream().filter(employee -> employee.getAge() > 20).collect(Collectors.toSet());set.forEach(System.out::println);
}/*
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
--------------------
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1007, name='任正非', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=9527, name='Kyle', age=21, salary=9999.0}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
*/

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

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

相关文章

1.测试基础

1.测试基础

目录 一、测试基础 1.软件测试中基础信息定义 2.测试主流技能 3.常见的测试分类 3.1按阶段划分 3.2按代码可见度划分 3.3其他 4.测试模型 5.测试流程 6.测试用例 二、用例设计方法 2.1等价类 2.2 边界值 2.3判定表法 2.4场景法 2.5错误推测法 三、缺陷管理 1…
阅读更多...
文章解读与仿真程序复现思路——电力系统自动化EI\CSCD\北大核心《交直流配电网中柔性软开关接入的规划-运行协同优化方法》

文章解读与仿真程序复现思路——电力系统自动化EI\CSCD\北大核心《交直流配电网中柔性软开关接入的规划-运行协同优化方法》

这个标题涉及到交直流配电网中柔性软开关接入的规划-运行协同优化方法。下面是对这个标题各部分的详细解读&#xff1a; 交直流配电网&#xff1a; 这指的是一个电力系统&#xff0c;同时包含交流和直流电力传输的元素。这样的系统可能结合了传统的交流电力传输和近年来兴起的直…
阅读更多...
python中一个文件（A.py）怎么调用另一个文件（B.py）中定义的类AA详解和示例

python中一个文件（A.py）怎么调用另一个文件（B.py）中定义的类AA详解和示例

本文主要讲解python文件中怎么调用另外一个py文件中定义的类&#xff0c;将通过代码和示例解读&#xff0c;帮助大家理解和使用。 目录 代码B.pyA.py 调用过程 代码 B.py 如在文件B.py,定义了类别Bottleneck&#xff0c;其包含卷积层、正则化和激活函数层&#xff0c;主要对…
阅读更多...
WordPress用sql命令批量删除所有文章

WordPress用sql命令批量删除所有文章

有时我们需要将一个网站搬迁到另一个服务器。我们只想保留网站的模板样式&#xff0c;而不需要文章内容。一般情况下我们可以在后台删除已发表的文章&#xff0c;但如果有很多文章&#xff0c;我们则需要一次删除所有文章。 WordPress如何批量删除所有文章 进入网站空间后台&a…
阅读更多...
常见树种（贵州省）：013桉树、米槠、栲类

常见树种（贵州省）：013桉树、米槠、栲类

摘要&#xff1a;本专栏树种介绍图片来源于PPBC中国植物图像库&#xff08;下附网址&#xff09;&#xff0c;本文整理仅做交流学习使用&#xff0c;同时便于查找&#xff0c;如有侵权请联系删除。 图片网址&#xff1a;PPBC中国植物图像库——最大的植物分类图片库 一、桉树 …
阅读更多...
Java中的字符串String

Java中的字符串String

目录 一、常用方法 1、字符串构造 2、String对象的比较 &#xff08;1&#xff09;、equals方法 &#xff08;2&#xff09;、compareTo方法 &#xff08;3&#xff09;、compareToIgnoreCase方法&#xff08;忽略大小写进行比较&#xff09; 3、字符串查找 4、转化 &…
阅读更多...
4.3 实时阴影

4.3 实时阴影

一、基于图像的阴影技术&#xff08;Shadow Map&#xff09; 什么是阴影 当来自光源的至少一个点在空间中被遮挡时&#xff0c;就产生了阴影区域。 阴影的前提 直接光照不透明物体 阴影的实现方式 阴影体&#xff08;Shadow Volumes&#xff09;——空间中黑暗部分的几何…
阅读更多...
Springboot集成swagger之knife4j

Springboot集成swagger之knife4j

knife4j的最终效果&#xff1a; 支持直观的入参介绍、在线调试及离线各种API文档下载。 1 引入pom <dependency><groupId>com.github.xiaoymin</groupId><artifactId>knife4j-spring-boot-starter</artifactId><version>3.0.2</ver…
阅读更多...
python 3.7安装并配置 pytorch（torch 1.8.2 + cuda 11.1 + torchaudio 0.8.2 + torchvision 0.9.2）

python 3.7安装并配置 pytorch（torch 1.8.2 + cuda 11.1 + torchaudio 0.8.2 + torchvision 0.9.2）

文章目录 前言一、安装 python二、安装 cuda cudnn二、安装 pytorch2.1 版本匹配2.1.1 方法一2.1.2 方法二2.2 安装 .tar.bz2 三、验证是否安装成功总结 前言 本篇文章主要介绍在Windows下 python 3.7 配置 pytorch&#xff0c;帮助需要的朋友避坑 安装 pytorch 需要多个版本适…
阅读更多...
内建组件和模块

内建组件和模块

讨论 Vue.js 中几个非常重要的内建组件和模块&#xff0c;例如 KeepAlive 组件、Teleport 组件、Transition 组件等&#xff0c;它们都需要渲染器级别的底层支持。另外&#xff0c;这些内建组件所带来的能力&#xff0c;对开发者而言非常重要且实用&#xff0c;理解它们的工作原…
阅读更多...
Word中如何实现 图片 | 表格 自动编号与文中引用编号对应

Word中如何实现 图片 | 表格 自动编号与文中引用编号对应

当我们在进行大篇幅word文档的编写时&#xff0c;为了节约修改文章中图片或表格所花费的大量时间&#xff0c;可以将图片自动编号&#xff0c;且让文中引用的顺序跟着图片顺序的变化而变化&#xff0c;具体操作如下&#xff1a; 1. 将鼠标定位在图片或者表格欲加编号的下方或上…
阅读更多...
Banana Pi [BPi-R3-Mini] 回顾和主线 ImmortalWrt 固件支持

Banana Pi [BPi-R3-Mini] 回顾和主线 ImmortalWrt 固件支持

BananaPi BPi-R3 Mini 采用 MediaTek 830&#xff08;4 个 A53&#xff0c;最高 2.0 GHz&#xff09;&#xff0c;具有 2 个 2.5 GbE、AX4200 2.4G/5G 无线和 USB 2.0 端口。它还具有两个 M.2 连接器&#xff0c;可用于 NVMe SSD 和 5G 模块&#xff08;板上包含 Nano SIM 插槽…
阅读更多...
ELK企业级日志分析平台——kibana数据可视化

ELK企业级日志分析平台——kibana数据可视化

部署 新建虚拟机server5&#xff0c;部署kibana [rootelk5 ~]# rpm -ivh kibana-7.6.1-x86_64.rpm [rootelk5 ~]# cd /etc/kibana/[rootelk5 kibana]# vim kibana.ymlserver.host: "0.0.0.0"elasticsearch.hosts: ["http://192.168.56.11:9200"]i18n.local…
阅读更多...
微服务学习（十二）：安装Minio

微服务学习（十二）：安装Minio

微服务学习&#xff08;十二&#xff09;&#xff1a;安装Minio 一、简介 MinIO 是一款基于Go语言发开的高性能、分布式的对象存储系统。客户端支持Java,Net,Python,Javacript, Golang语言。MinIO系统&#xff0c;非常适合于存储大容量非结构化的数据&#xff0c;例如图片、视…
阅读更多...
Qt 软件开发框架（主要部分）

Qt 软件开发框架（主要部分）

目录 1、 一个软件基本要素 &#xff08;1&#xff09;UI模块 &#xff08;2&#xff09;网络模块 &#xff08;3&#xff09;业务逻辑模块 &#xff08;4&#xff09;中间层 &#xff08;5&#xff09;独立模块&#xff08;守护进程、更新模块、日志收集模块…&#xff…
阅读更多...
【spring（三）】AOP总结

【spring（三）】AOP总结

&#x1f308;键盘敲烂&#xff0c;年薪30万&#x1f308; 目录 一、AOP相关概念 ① AOP核心思想思想&#xff1a; ② AOP专业术语&#xff1a; 二、AOP快速如入门 三、AOP工作流程 四、切入点表达式 ① 语法格式 ②支持通配符 ③书写技巧 五、通知类型 ①⭐环绕通知…
阅读更多...
nodejs 如何将 Buffer 数据转为 String

nodejs 如何将 Buffer 数据转为 String

问题说明 使用webSocket的时候出现了一个问题&#xff0c;前端小程序和nodejs后端建立websocket连接后&#xff0c;使用send方法发送到后端为buffer格式&#xff0c;以下为我前后端代码 1、前端小程序代码 //创建webSocket连接 const socket uni.connectSocket({url: wss…
阅读更多...
[架构之路-249]：目标系统 - 设计方法 - 软件工程 - 需求工程- 需求开发：如何用图形表达需求，结构化方法的需求分析

[架构之路-249]：目标系统 - 设计方法 - 软件工程 - 需求工程- 需求开发：如何用图形表达需求，结构化方法的需求分析

目录 一、概述 二、数据模型&#xff1a;E-R图/实体关系图&#xff08;数据单元之间的结构关系&#xff09; 三、功能模型&#xff1a;数据流图DFD&#xff08;逻辑运算&#xff0c;包括输入和输出&#xff0c;实体之间的关系&#xff09;&#xff1a;输入》处理 》 输出 四…
阅读更多...
【VSCode】VSCode 使用

【VSCode】VSCode 使用

目录 文章目录 目录插件配置设置代码不显示 git 提示 "xxx months ago | 1 author"设置打开项目不自动选择 CMakeLists 插件 以下插件为 C 开发偏好设置。 C/CCMakeCMake ToolsGitLensRemote DevelopmentRemote Explorer 配置 设置代码不显示 git 提示 “xxx mon…
阅读更多...
绝地求生：PGC 2023 赛事直播期间最高可获：2000万G-Coins，你还不来吗？

绝地求生：PGC 2023 赛事直播期间最高可获：2000万G-Coins，你还不来吗？

今年PGC直播期间将有最高2000万G-Coin掉落&#xff0c;究竟花落谁家咱们拭目以待 公告原文&#xff1a;Watch PGC 2023 Live And Earn G-Coins! 如何赚取高额G-Coin&#xff1f; Throughout the PGC 2023, an astounding 20,000,000 G-Coins will be up for grabs as part of …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023