Java8新特性：强大的Stream API

news2024/9/29 19:29:56

5.1 说明

  • Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API。
  • Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
  • Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 **使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。**也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

5.2 为什么要使用Stream API

实际开发中，项目中多数数据源都来自于MySQL、Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要Java层面去处理。

5.3 什么是Stream

Stream 是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

Stream 和 Collection 集合的区别：**Collection 是一种静态的内存数据结构，讲的是数据，而 Stream 是有关计算的，讲的是计算。**前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。

注意：

①Stream 自己不会存储元素。

②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。即一旦执行终止操作，就执行中间操作链，并产生结果。

④ Stream一旦执行了终止操作，就不能再调用其它中间操作或终止操作了。

5.4 Stream的操作三个步骤

1- 创建 Stream
一个数据源（如：集合、数组），获取一个流

2- 中间操作
每次处理都会返回一个持有结果的新Stream，即中间操作的方法返回值仍然是Stream类型的对象。因此中间操作可以是个操作链，可对数据源的数据进行n次处理，但是在终结操作前，并不会真正执行。

3- 终止操作(终端操作)
终止操作的方法返回值类型就不再是Stream了，因此一旦执行终止操作，就结束整个Stream操作了。一旦执行终止操作，就执行中间操作链，最终产生结果并结束Stream。

image-20220514180803311
5.4.1 创建Stream实例

方式一：通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

  • default Stream stream() : 返回一个顺序流

  • default Stream parallelStream() : 返回一个并行流

@Test
public void test01(){
    List<Integer> list = Arrays.asList(1,2,3,4,5);

    //JDK1.8中，Collection系列集合增加了方法
    Stream<Integer> stream = list.stream();
}

方式二：通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

  • static Stream stream(T[] array): 返回一个流
  • public static IntStream stream(int[] array)
  • public static LongStream stream(long[] array)
  • public static DoubleStream stream(double[] array)
@Test
public void test02(){
    String[] arr = {"hello","world"};
    Stream<String> stream = Arrays.stream(arr); 
}

@Test
public void test03(){
    int[] arr = {1,2,3,4,5};
    IntStream stream = Arrays.stream(arr);
}

方式三：通过Stream的of()

可以调用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() 和 Stream.generate(), 创建无限流。

  • 迭代
    public static Stream iterate(final T seed, final UnaryOperator f)

  • 生成
    public static Stream generate(Supplier s)

// 方式四：创建无限流
@Test
public void test05() {
	// 迭代
	// public static<T> Stream<T> iterate(final T seed, final
	// UnaryOperator<T> f)
	Stream<Integer> stream = Stream.iterate(0, x -> x + 2);
	stream.limit(10).forEach(System.out::println);

	// 生成
	// public static<T> Stream<T> generate(Supplier<T> s)
	Stream<Double> stream1 = Stream.generate(Math::random);
	stream1.limit(10).forEach(System.out::println);
}
5.4.2 一系列中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

1-筛选与切片

方 法描 述
filter(Predicatep)接收 Lambda ， 从流中排除某些元素
distinct()筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
limit(long maxSize)截断流，使其元素不超过给定数量
skip(long n)跳过元素，返回一个扔掉了前 n 个元素的流。
若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补

2-映 射

方法描述
map(Function f)接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。
mapToInt(ToIntFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。
mapToLong(ToLongFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。
flatMap(Function f)接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

3-排序

方法描述
sorted()产生一个新流，其中按自然顺序排序
sorted(Comparator com)产生一个新流，其中按比较器顺序排序

代码举例：

package com.atguigu.stream;

import org.junit.Test;

import java.util.Arrays;
import java.util.stream.Stream;

public class StreamMiddleOperate {
	@Test
    public void test01(){
        //1、创建Stream
        Stream<Integer> stream = Stream.of(1,2,3,4,5,6);

        //2、加工处理
        //过滤：filter(Predicate p)
        //把里面的偶数拿出来
        /*
         * filter(Predicate p)
         * Predicate是函数式接口，抽象方法：boolean test(T t)
         */
        stream = stream.filter(t -> t%2==0);

        //3、终结操作：例如：遍历
        stream.forEach(System.out::println);
    }
    @Test
    public void test02(){
        Stream.of(1,2,3,4,5,6)
                .filter(t -> t%2==0)
                .forEach(System.out::println);
    }
    @Test
    public void test03(){
        Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
                .distinct()
                .forEach(System.out::println);
    }
    @Test
    public void test04(){
        Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
                .limit(3)
                .forEach(System.out::println);
    }
    @Test
    public void test05(){
        Stream.of(1,2,2,3,3,4,4,5,2,3,4,5,6,7)
                .distinct()  //(1,2,3,4,5,6,7)
                .filter(t -> t%2!=0) //(1,3,5,7)
                .limit(3)
                .forEach(System.out::println);
    }
    @Test
    public void test06(){
        Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
                .skip(5)
                .forEach(System.out::println);
    }
    @Test
    public void test07(){
        Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
                .skip(5)
                .distinct()
                .filter(t -> t%3==0)
                .forEach(System.out::println);
    }
    @Test
    public void test08(){
        long count = Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
                .distinct()
                .peek(System.out::println)  //Consumer接口的抽象方法  void accept(T t)
                .count();
        System.out.println("count="+count);
    }
    @Test
    public void test09(){
        //希望能够找出前三个最大值，前三名最大的，不重复
        Stream.of(11,2,39,4,54,6,2,22,3,3,4,54,54)
                .distinct()
                .sorted((t1,t2) -> -Integer.compare(t1, t2))//Comparator接口  int compare(T t1, T t2)
                .limit(3)
                .forEach(System.out::println);
    }
    @Test
    public void test10(){
        Stream.of(1,2,3,4,5)
                .map(t -> t+=1)//Function<T,R>接口抽象方法 R apply(T t)
                .forEach(System.out::println);
    }
    @Test
    public void test11(){
        String[] arr = {"hello","world","java"};

        Arrays.stream(arr)
                .map(t->t.toUpperCase())
                .forEach(System.out::println);
    }
    @Test
    public void test12(){
        String[] arr = {"hello","world","java"};
        Arrays.stream(arr)
                .flatMap(t -> Stream.of(t.split("|")))//Function<T,R>接口抽象方法 R apply(T t)  现在的R是一个Stream
                .forEach(System.out::println);
    } 
}
5.4.3 终止操作

  • 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

  • 流进行了终止操作后，不能再次使用。

1-匹配与查找

方法描述
allMatch(Predicate p)检查是否匹配所有元素
**anyMatch(Predicate p) **检查是否至少匹配一个元素
noneMatch(Predicate p)检查是否没有匹配所有元素
findFirst()返回第一个元素
findAny()返回当前流中的任意元素
count()返回流中元素总数
max(Comparator c)返回流中最大值
min(Comparator c)返回流中最小值
forEach(Consumer c)内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。
相反，Stream API 使用内部迭代——它帮你把迭代做了)

2-归约

方法描述
reduce(T identity, BinaryOperator b)可以将流中元素反复结合起来，得到一个值。返回 T
reduce(BinaryOperator b)可以将流中元素反复结合起来，得到一个值。返回 Optional

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

3-收集

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

Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、Map)。

另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：

方法返回类型作用
toListCollector<T, ?, List>把流中元素收集到List
List<Employee> emps= list.stream().collect(Collectors.toList());
方法返回类型作用
toSetCollector<T, ?, Set>把流中元素收集到Set
Set<Employee> emps= list.stream().collect(Collectors.toSet());
方法返回类型作用
toCollectionCollector<T, ?, C>把流中元素收集到创建的集合
Collection<Employee> emps =list.stream().collect(Collectors.toCollection(ArrayList::new));
方法返回类型作用
countingCollector<T, ?, Long>计算流中元素的个数
long count = list.stream().collect(Collectors.counting());
方法返回类型作用
summingIntCollector<T, ?, Integer>对流中元素的整数属性求和
int total=list.stream().collect(Collectors.summingInt(Employee::getSalary));
方法返回类型作用
averagingIntCollector<T, ?, Double>计算流中元素Integer属性的平均值
double avg = list.stream().collect(Collectors.averagingInt(Employee::getSalary));
方法返回类型作用
summarizingIntCollector<T, ?, IntSummaryStatistics>收集流中Integer属性的统计值。如：平均值
int SummaryStatisticsiss= list.stream().collect(Collectors.summarizingInt(Employee::getSalary));
方法返回类型作用
joiningCollector<CharSequence, ?, String>连接流中每个字符串
String str= list.stream().map(Employee::getName).collect(Collectors.joining());
方法返回类型作用
maxByCollector<T, ?, Optional>根据比较器选择最大值
Optional<Emp>max= list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary)));
方法返回类型作用
minByCollector<T, ?, Optional>根据比较器选择最小值
Optional<Emp> min = list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary)));
方法返回类型作用
reducingCollector<T, ?, Optional>从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值
int total=list.stream().collect(Collectors.reducing(0, Employee::getSalar, Integer::sum));
方法返回类型作用
collectingAndThenCollector<T,A,RR>包裹另一个收集器，对其结果转换函数
int how= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));
方法返回类型作用
groupingByCollector<T, ?, Map<K, List>>根据某属性值对流分组，属性为K，结果为V
Map<Emp.Status, List<Emp>> map= list.stream().collect(Collectors.groupingBy(Employee::getStatus));
方法返回类型作用
partitioningByCollector<T, ?, Map<Boolean, List>>根据true或false进行分区
Map<Boolean,List<Emp>> vd = list.stream().collect(Collectors.partitioningBy(Employee::getManage));

举例：

package com.atguigu.stream;

import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.junit.Test;

public class StreamEndding {
    @Test
    public void test01(){
        Stream.of(1,2,3,4,5)
                .forEach(System.out::println);
    }
    @Test
    public void test02(){
        long count = Stream.of(1,2,3,4,5)
                .count();
        System.out.println("count = " + count);
    }
    @Test
    public void test03(){
        boolean result = Stream.of(1,3,5,7,9)
                .allMatch(t -> t%2!=0);
        System.out.println(result);
    }
	@Test
    public void test04(){
        boolean result = Stream.of(1,3,5,7,9)
                .anyMatch(t -> t%2==0);
        System.out.println(result);
    }
	@Test
    public void test05(){
        Optional<Integer> opt = Stream.of(1,3,5,7,9).findFirst();
        System.out.println(opt);
    }
	@Test
    public void test06(){
        Optional<Integer> opt = Stream.of(1,2,3,4,5,7,9)
                .filter(t -> t%3==0)
                .findFirst();
        System.out.println(opt);
    }
	@Test
    public void test07(){
        Optional<Integer> opt = Stream.of(1,2,4,5,7,8)
                .filter(t -> t%3==0)
                .findFirst();
        System.out.println(opt);
    }
    @Test
    public void test08(){
        Optional<Integer> max = Stream.of(1,2,4,5,7,8)
                .max((t1,t2) -> Integer.compare(t1, t2));
        System.out.println(max);
    }
    @Test
    public void test09(){
        Integer reduce = Stream.of(1,2,4,5,7,8)
                .reduce(0, (t1,t2) -> t1+t2);//BinaryOperator接口   T apply(T t1, T t2)
        System.out.println(reduce);
    }
    @Test
    public void test10(){
        Optional<Integer> max = Stream.of(1,2,4,5,7,8)
                .reduce((t1,t2) -> t1>t2?t1:t2);//BinaryOperator接口   T apply(T t1, T t2)
        System.out.println(max);
    }
    @Test
    public void test11(){
        List<Integer> list = Stream.of(1,2,4,5,7,8)
                .filter(t -> t%2==0)
                .collect(Collectors.toList());

        System.out.println(list);
    }   
}

5.5 Java9新增API

新增1：Stream实例化方法

ofNullable()的使用：

Java 8 中 Stream 不能完全为null，否则会报空指针异常。而 Java 9 中的 ofNullable 方法允许我们创建一个单元素 Stream，可以包含一个非空元素，也可以创建一个空 Stream。

//报NullPointerException
//Stream<Object> stream1 = Stream.of(null);
//System.out.println(stream1.count());

//不报异常，允许通过
Stream<String> stringStream = Stream.of("AA", "BB", null);
System.out.println(stringStream.count());//3

//不报异常，允许通过
List<String> list = new ArrayList<>();
list.add("AA");
list.add(null);
System.out.println(list.stream().count());//2
//ofNullable()：允许值为null
Stream<Object> stream1 = Stream.ofNullable(null);
System.out.println(stream1.count());//0

Stream<String> stream = Stream.ofNullable("hello world");
System.out.println(stream.count());//1

iterator()重载的使用：

//原来的控制终止方式：
Stream.iterate(1,i -> i + 1).limit(10).forEach(System.out::println);

//现在的终止方式：
Stream.iterate(1,i -> i < 100,i -> i + 1).forEach(System.out::println);

5.6 练习

现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以
下若干操作步骤：

  1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
  2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
  3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
  4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
  5. 将两个队伍合并为一个队伍；存储到一个新集合中。
  6. 根据姓名创建 Person 对象；存储到一个新集合中。
  7. 打印整个队伍的Person对象信息。

Person 类的代码为：

public class Person {
    private String name;
    public Person() {}
    public Person(String name) {
        this.name = name;
    }    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{name='" + name + "'}";
    }
}

两个队伍（集合）的代码如下：

public static void main(String[] args) {
       //第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");
        //第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");
    
		// ....编写代码完成题目要求 
    }

参考答案：

public static void main(String[] args) {
       //第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");
    
        //第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");
        
		// 第一个队伍只要名字为3个字的成员姓名；
        // 第一个队伍筛选之后只要前3个人；
        Stream<String> streamOne = one.stream().filter(s ‐> s.length() == 3).limit(3);
    
        // 第二个队伍只要姓张的成员姓名；
        // 第二个队伍筛选之后不要前2个人；
        Stream<String> streamTwo = two.stream().filter(s ‐> s.startsWith("张")).skip(2);
    
        // 将两个队伍合并为一个队伍；
        // 根据姓名创建Person对象；
        // 打印整个队伍的Person对象信息。
        Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);
        
}```

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

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

相关文章

为养宠家庭量身打造，352 X63 Pet宠物专效空气净化器“养宠安馨，人宠共护”

为养宠家庭量身打造，352 X63 Pet宠物专效空气净化器“养宠安馨，人宠共护”

当下,养宠人群日益增多,宠物在给家庭带来了欢乐的同时,也产生了一系列困扰,如何在健康环境中快乐养宠,成为很多家养宠家庭的新需求。成立于2014年的北京三五二环保科技有限公司是一家立足于家庭洁净空气和安全用水领域的科技创新型公司。以“安全、健康、舒适”等消费需求为核心…
阅读更多...
AUTOSAR_RS_LogAndTrace中文翻译（待更）

AUTOSAR_RS_LogAndTrace中文翻译（待更）

4功能概述 5.功能要求 5.2.1.1通用型 1.日志记录应支持初始化和注册 2. 日志功能应该使应用程序提供日志信息 3. 日志功能应能和追踪应用程序之间通信&#xff0c; 4. 日志应支持对日志信息进行分组&#xff0c;使用案例&#xff1a;关联过滤所有属于一起的日志信息 5. 日志记…
阅读更多...
mos管工作原理

mos管工作原理

MOS管的工作原理可以通过增强型和耗尽型两种类型来解释。增强型MOS管在栅极电压达到一定值时会逐渐形成沟道&#xff0c;而耗尽型MOS管内部本身就存在沟道&#xff0c;随栅极电压的升高而减小。在增强型MOS管中&#xff0c;栅极的正电荷会吸引P型半导体中的电子&#xff0c;排斥…
阅读更多...
薅github的羊毛-用pages建自己的博客或静态资源站 - 1/2

薅github的羊毛-用pages建自己的博客或静态资源站 - 1/2

注册帐号 准备邮箱注册帐号&#xff0c;在注册界面输入用户名、邮箱及密码完成注册。 添加图片注释&#xff0c;不超过 140 字&#xff08;可选&#xff09; 1. 在注册成过程中&#xff0c;会往邮箱发送验证码&#xff0c;请如实填写即可 2. 验证码没错的话&#xff0c;就代…
阅读更多...
杨辉三角形-第11届蓝桥杯选拔赛Python真题精选

杨辉三角形-第11届蓝桥杯选拔赛Python真题精选

[导读]&#xff1a;超平老师的Scratch蓝桥杯真题解读系列在推出之后&#xff0c;受到了广大老师和家长的好评&#xff0c;非常感谢各位的认可和厚爱。作为回馈&#xff0c;超平老师计划推出《Python蓝桥杯真题解析100讲》&#xff0c;这是解读系列的第17讲。 杨辉三角形&#…
阅读更多...
低代码 —— 饮食均衡，合理膳食

低代码 —— 饮食均衡，合理膳食

目录 一、低代码的概念 二、低代码的优缺点 &#xff08;一&#xff09;优点 &#xff08;二&#xff09;缺点 三、低代码的能力 1、场景构建能力 2、数据编排能力 3、连接生态能力 4、业务中台能力 四、你认为低代码会替代传统编程吗&#xff1f; 1、从技术特征来看…
阅读更多...
前端已死？探讨人工智能与低代码对前端的影响

前端已死？探讨人工智能与低代码对前端的影响

文章目录 每日一句正能量前言前端行业究竟是好是坏&#xff1f;数字化转型的当下前端工程师该何去何从&#xff1f; 想要入行前端先认清这三个事实 后记 每日一句正能量 人的结构就是相互支撑&#xff0c;众人的事业需要每个人的参与。 前言 随着人工智能和低代码的崛起&#…
阅读更多...
软件设计师——信息安全（一）

软件设计师——信息安全（一）

&#x1f4d1;前言 本文主要是【信息安全】——软件设计师——信息安全的文章&#xff0c;如果有什么需要改进的地方还请大佬指出⛺️ &#x1f3ac;作者简介&#xff1a;大家好&#xff0c;我是听风与他&#x1f947; ☁️博客首页&#xff1a;CSDN主页听风与他 &#x1f304…
阅读更多...
ISCTF2023 Reverse方向 WP

ISCTF2023 Reverse方向 WP

文章目录 ReversecrackmeEasyRebabyReeasy_z3FloweyRSAeasy_flower_teamfx_rez3_revengeWHERE Reverse crackme 、 加了UPX壳&#xff0c;可以看到EP Section处UPX标识被修改了 用WinHex修改 之后UPX脱壳 得到flag。 EasyRe 逆向一下&#xff0c;先逆序&#xff0c;再做一些…
阅读更多...
华为云sp2服务器系统根分区扩容后重启失败解决

华为云sp2服务器系统根分区扩容后重启失败解决

lvm根分区扩容 概念&#xff1a; PV&#xff08;物理卷&#xff1a;Physical Volumes&#xff09; VG&#xff08;物理卷组&#xff1a;Volume Group&#xff09; LV&#xff08;逻辑卷&#xff1a;Logical Volumes&#xff09; R系 V10服务器&#xff1a; 显示当前Logic…
阅读更多...
HTTP、HTTPS、SSL协议以及相关报文讲解

HTTP、HTTPS、SSL协议以及相关报文讲解

目录 HTTP/HTTPS介绍 HTTP/HTTPS基本信息 HTTP如何实现有状态 HTTP请求与应答报文 HTTP请求报文 HTTP响应报文 SSL协议 SSL单向认证 SSL双向认证 HTTP连接建立与传输步骤 HTTP访问全过程相关报文&#xff08;以访问www.download.cucdccom为例子&#xff09; DNS报文…
阅读更多...
努比亚×实在RPA丨全域数据获取时长降低67%以上，累计节省人天1900+

努比亚×实在RPA丨全域数据获取时长降低67%以上，累计节省人天1900+

国际知名数码品牌努比亚的服务和销售网络遍及海内外市场&#xff0c;其中&#xff0c;国内线上渠道包含淘系、京东、拼多多、快手等10余个主流电商平台。 为了更好满足年轻消费群体需求&#xff0c;努比亚每天需要获取各平台销售数据&#xff0c;对于需要管理10平台的运营部门…
阅读更多...
@Valid注解的使用

@Valid注解的使用

Valid注解的使用 Valid 用来对参数进行验证&#xff0c;在变量信息中添加用于充当校验条件的注解 需要传入BindingResult对象&#xff0c;用于获取校验失败情况下的反馈信息 用法示例
阅读更多...
DevOps搭建(十)-安装Harbor镜像仓库详细步骤

DevOps搭建(十)-安装Harbor镜像仓库详细步骤

1、下载Harbor 官方地址： https://goharbor.io/ 下载地址： https://github.com/goharbor/harbor/tags 选择文档版本进行下载，这里我们选择v2.7.2版本 2、上传到服务器并解压 上传压缩包到服务器后，解压到/usr/local目录下，执行以下解压命令 tar -zxvf harbor-offli…
阅读更多...
windows任务计划的创建、导出和导入

windows任务计划的创建、导出和导入

创建任务计划 任务名称 任务触发器 执行bat的话起始于必须填写 创建成功 导出任务计划 选择导出路径 导出成功 导入任务计划 可视化界面导入任务计划 选择任务计划的xml文件 点击确定 导入成功 命令行导入计划任务 cd /d D:\迅雷下载schtasks.exe /create /tn 1234 /xml 123…
阅读更多...
【XR806开发板试用】+2.鸿蒙内核

【XR806开发板试用】+2.鸿蒙内核

非常感谢基于安谋科技STAR-MC1的全志XR806 Wi-FiBLE开源鸿蒙开发板试用活动&#xff01;非常感谢极术社区&#xff01;非常感谢极术小姐姐&#xff01;非常感谢全志在线开发者社区&#xff01;非常感谢通过试用申请&#xff01;非常感谢安谋科技&#xff01; 接上一篇&#xff…
阅读更多...
CSS新手入门笔记整理：CSS定位布局

CSS新手入门笔记整理：CSS定位布局

定位布局概述 浮动布局比较灵活&#xff0c;但是不容易控制。而定位布局的出现&#xff0c;使得用户精准定位页面中的任意元素成为可能。当然了&#xff0c;由于定位布局缺乏灵活性&#xff0c;这给空间大小和位置不确定的版面布局带来困惑。因此在实际开发中&#xff0c;大家…
阅读更多...
数据服务化在京东的实践

数据服务化在京东的实践

01 缘起&#xff1a;数据服务化从 0 到 1 1. 缘起 京东数据智能部负责维护数据资产和对外提供数据服务&#xff0c;很多业务方要求我们尽快地提供开放的数据 API供其使用&#xff0c;但开发一个 API 的平均周期在两周左右&#xff0c;遇到 618 大促时还要提供 80 个接口。在…
阅读更多...
Mrdoc知识文档

Mrdoc知识文档

MrDoc知识文档平台是一款基于Python开发的在线文档系统&#xff0c;适合作为个人和中小型团队的私有云文档、云笔记和知识管理工具&#xff0c;致力于成为优秀的私有化在线文档部署方案。我现在主要把markdown笔记放在上面&#xff0c;因为平时老是需要查询一些知识点&#xff…
阅读更多...
一张图看懂NvMDynamicConfiguration和NvMResistantToChangedSw对NvM数据变更的影响

一张图看懂NvMDynamicConfiguration和NvMResistantToChangedSw对NvM数据变更的影响

一、背景 在实际项目中&#xff0c;我们会通过NvM将易失性数据存入EEPRAM。如果说NvM中配置好的Block List在项目迭代过程中没有Block的增加或减少&#xff0c;没有Block数据长度的增加或减少&#xff0c;那么NvM的使用就不会有什么问题。 但是如果Block List在某一天要增加一…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023