stream笔记

news2024/11/15 7:40:43

1、 创建流stream

  • 1.1、 Stream 的操作三个步骤

1.2、 stream中间操作

  • 1.2.1 、 limit、skip、distinct

  • 1.2.2、 map and flatMap

  • 1.2.3、 sort 自然排序和定制排序

1.3、 add and andAll difference:

1.4、 终止操作

  • 1.4.1、 allmatch、anyMatch、noneMatch、max、min
  • 1.4.2、 reduce
  • 1.4.3 、 collect

1、创建流stream:

流(Stream) 到底是什么 呢 ?
是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。
“ 集合讲的是数据 , 流讲的是 计 算 ! ”
注意 :
①Stream 自己不会存储元素。
②Stream 不会改变源对象。相反,他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

1.1 Stream 的操作三个步骤
  • 创建 建 Stream
    一个数据源(如:集合、数组),获取一个流
  • 中间操作
    一个中间操作链,对数据源的数据进行处理
  • 终止操作( ( 终端操作) )
    一个终止操作,执行中间操作链,并产生结果

在这里插入图片描述

default Stream stream()List list = new ArrayList<>(); Stream stream = list.stream(); //获取一个顺序流返回一个顺序流
default Stream parallelStream()Stream parallelStream = list.parallelStream(); //获取一个并行流返回一个并行流
Integer[] nums = new Integer[10]; Stream stream1 = Arrays.stream(nums);通过 Arrays 中的 stream() 获取一个数组流
//迭代 Stream stream3 = Stream.iterate(0, (x) -> x + 2).limit(10); stream3.forEach(System.out::println);创建无限流
Stream stream4 = Stream.generate(Math::random).limit(2);生成
        //下面两个遍历一样
        stream4.forEach(System.out::println);
//        stream4.forEach(s->{
//            System.out.println(s);
//        });

1.2:stream中间操作

filter接收 Lambda , 从流中排除某些元素。
limit截断流,使其元素不超过给定数量。
skip(n)跳过元素,返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个,则返回一个空流。与 limit(n) 互补
distinct筛选,通过流所生成元素的 hashCode() 和 equals() 去除重复元素
map接收 Lambda , 将元素转换成其他形式或提取信息。接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。
flatMap接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流,流中流
sorted()自然排序 comparable
sorted(Comparator com)定制排序

1.2.1 limit、skip、distinct、
public class Employee {
    private int id;
    private String name;
    private int age;
    private Double salary;

}
List<Employee> emps = Arrays.asList(
        new Employee(102, "李四", 59, 6666.66),
        new Employee(101, "张三", 18, 9999.99),
        new Employee(103, "王五", 28, 3333.33),
        new Employee(104, "赵六", 8, 7777.77),
        new Employee(104, "赵六", 8, 7777.77),
        new Employee(104, "赵六", 8, 7777.77),
        new Employee(105, "田七", 38, 5555.55)
);
    //内部迭代:迭代操作 Stream API 内部完成(filter  过滤时需要迭代一下)
    @Test
    public void test2() {
        //所有的中间操作不会做任何的处理
        Stream<Employee> stream = emps.stream()
                //断言,传入参数,返回布尔值
                .filter((e) -> {
                    System.out.println("测试中间操作");
                    return e.getAge() <= 35;
                });

        //只有当做终止操作时,所有的中间操作会一次性的全部执行,称为“惰性求值”
        stream.forEach(System.out::println);
    }

    //外部迭代
    @Test
    public void test3() {
        Iterator<Employee> it = emps.iterator();

        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }


    //找到三个之后就不往下找了。提高效率
    @Test
    public void test4() {
        emps.stream()
                .filter((e) -> {
                    System.out.println("短路!"); // &&  ||
                    return e.getSalary() >= 5000;
                }).limit(3)
                .forEach(System.out::println);
    }


    //大于5000的前两个跳过,也就是不取
    @Test
    public void test5() {
        emps.parallelStream()
                .filter((e) -> e.getSalary() >= 5000)
                .skip(2)
                .forEach(System.out::println);
    }


    //去重。如果是对象,hashcode和equals  进行比较,所以要去重。  lambda 已经重写的了去重操作
    @Test
    public void test6() {
        emps.stream()
                .distinct()
                .forEach(System.out::println);
    }

1.2.2 map and flatMap:
  •    @Test
          public void test7() {
              Stream<String> str = emps.stream()
                      .map((e) -> e.getName());
      
              System.out.println("-------------------------------------------");
      
              List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
      
              Stream<String> stream = strList.stream()
                      .map(String::toUpperCase);
      
              stream.forEach(System.out::println);
      
              //TODO:下面两种一样的。内部迭代
      //        emps.stream().map(Employee::getName).forEach(System.out::println);
              emps.stream().map(s -> s.getName()).forEach(System.out::println);
      
      
              Stream<Stream<Character>> stream2 = strList.stream()
                      .map(TestStreamApI::filterCharacter);
      
              stream2.forEach((sm) -> {
                  sm.forEach(System.out::println);
              });
      
              System.out.println("---------------------------------------------");
      
              Stream<Character> stream3 = strList.stream()
                      .flatMap(TestStreamApI::filterCharacter);
      
              stream3.forEach(System.out::println);
      
      
              System.out.println("----------------------------------------------");
              //解决结果两次for循环
              strList.stream().flatMap(item -> Arrays.stream(item.split(" "))).forEach(System.out::println);
      
          }
      
          public static Stream<Character> filterCharacter(String str) {
              List<Character> list = new ArrayList<>();
      
              for (Character ch : str.toCharArray()) {
                  list.add(ch);
              }
      
              return list.stream();
          }
    

1.2.3 sort 自然排序和定制排序:
public class Employee {
    private int id;
    private String name;
    private int age;
    private Double salary;

}
  @Test
    public void test9() {
        emps.stream()
                .map(Employee::getName)
                .sorted()
                .forEach(System.out::println);

        System.out.println("------------------------------------");

        emps.stream()
                .sorted((x, y) -> {
                    if (x.getAge() == y.getAge()) {
                        //两种排序方式
                        return x.getName().compareTo(y.getName());
                    } else {
                        return Integer.compare(x.getAge(), y.getAge());
                    }
                }).forEach(System.out::println);

        System.out.println("---------------------------------------------");
        List<String> list1 = Arrays.asList("zzzzzz", "aaaa", "bbbb", "cccc", "ddddd", "eeeee");
        list1.stream().sorted().forEach(System.out::println);

    }

1.3add and andAll difference:

add 和addall 区别:

  • 1、add 是把集合添加进去,addAll 是把集合中的元素添加进去
 @Test
    public void test8() {
        List<String> list1 = Arrays.asList("aaaa", "bbbb", "cccc", "ddddd", "eeeee");
        List list2 = new ArrayList<>();
        list2.add(1111);
        list2.add(2222);

        list2.add(list1);

        System.out.println(list2);
//[1111, 2222, [aaaa, bbbb, cccc, ddddd, eeeee]]
        System.out.println("================================");

        list2.addAll(list1);
        System.out.println(list2);
        //addall  是把集合中的元素取出来添加list1中。  里面的[aaaa, bbbb, cccc, ddddd, eeeee]   是上面添加的
        //[1111, 2222, [aaaa, bbbb, cccc, ddddd, eeeee], aaaa, bbbb, cccc, ddddd, eeeee]

    }

1.4 终止操作

anyMatch检查是否至少匹配一个元素
noneMatch检查是否没有匹配的元素
findFirst返回第一个元素
findAny返回当前流中的任意元素
count返回流中元素的总个数
max返回流中最大值Optional max = emps.stream().map(Employee::getSalary).max((v1,v2)->Double.compare(v1,v2)); .max(Double::compare); .max((v1,v2)->v1.compareTo(v2));
min返回流中最小值
reduce归约。可以将流中元素反复结合起来,得到一个值。
collect将流转换为其他形式。接收一个 Collector接口的实现,用于给Stream中元素做汇总的方法.collect(Collectors.toList());.collect(Collectors.toSet()); 放到hashset中:: .collect(Collectors.toCollection(HashSet::new)); .collect(Collectors.maxBy(Double::compare)); 总薪水: .collect(Collectors.summingDouble(Employee::getSalary)); 平均值: .collect(Collectors.averagingDouble(Employee::getSalary)); 总数: .collect(Collectors.counting()); 计算薪水总函数(最大值,最小值、平均值、数量):.collect(Collectors.summarizingDouble(Employee::getSalary)); 分组:.collect(Collectors.groupingBy(Employee1::getStatus)); 多级分组:Collectors.groupingBy(Employee1::getStatus, Collectors.groupingBy()。 分区:.collect(Collectors.partitioningBy((e) -> e.getSalary() >= 5000)); joining: .collect(Collectors.joining(“,”, “----”, “----”));
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee1 {
    private int id;
    private String name;
    private int age;
    private double salary;
    private Status status;

    public enum Status {
        FREE, BUSY, VOCATION;
    }
}
List<Employee1> empss = Arrays.asList(
        new Employee1(102, "李四", 59, 6666.66, Employee1.Status.BUSY),
        new Employee1(101, "张三", 18, 9999.99, Employee1.Status.FREE),
        new Employee1(103, "王五", 28, 3333.33, Employee1.Status.VOCATION),
        new Employee1(104, "赵六", 8, 7777.77, Employee1.Status.BUSY),
        new Employee1(104, "赵六", 8, 7777.77, Employee1.Status.FREE),
        new Employee1(104, "赵六", 8, 7777.77, Employee1.Status.FREE),
        new Employee1(105, "田七", 38, 5555.55, Employee1.Status.BUSY)
);

1.4.1allmatch、anyMatch、noneMatch、max、min
 @Test
    public void test10() {
        //返回false ,并不是匹配所有元素
        boolean bl = empss.stream()
                .allMatch((e) -> e.getStatus().equals(Employee1.Status.BUSY));
        System.out.println(bl);

//true,有这个样的元素
        boolean bl1 = empss.stream()
                .anyMatch((e) -> e.getStatus().equals(Employee1.Status.BUSY));

        System.out.println(bl1);

        //没有匹配元素 false
        boolean bl2 = empss.stream()
                .noneMatch((e) -> e.getStatus().equals(Employee1.Status.BUSY));
        System.out.println(bl2);

//得到最大值
        Optional<Double> max = emps.stream().map(Employee::getSalary)
//                .max(Double::compare);
        .max((v1,v2)->Double.compare(v1,v2));
      // .max((v1,v2)->v1.compareTo(v2));  
      System.out.println(max.get());

//得到最小值,的成员
        Optional<Employee> min = emps.stream().min((v1, v2) -> Double.compare(v1.getSalary(), v2.getSalary()));
        System.out.println(min.get());

//得到薪水的最小值,把薪水通过map映射出来
        Optional<Double> min1 = emps.stream().map(item -> item.getSalary()).min(Double::compare);
        System.out.println(min1.get());
    }

1.4.2reduce
  @Test
    public void test20() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        /**
         * x=0,y=1,x=x+y=1
         * x=1 y=2 x=x+y=3
         * ...........
         */
        Integer sum = list.stream()
                .reduce(0, (x, y) -> x + y);
        System.out.println(sum);


        System.out.println("----------------------------------------");

        Optional<Double> op = emps.stream()
                .map(Employee::getSalary)
                .reduce(Double::sum);
        System.out.println(op.get());


        System.out.println("====");
        double identity = 0.0;
        double d = emps.stream().map(Employee::getSalary)
                .reduce(identity, (x, y) -> x + y);
        System.out.println(d);

        //为什么这个是optional  因为可能为空,而上面那个为什么不是?因为有初始值,所以即使你传入的为null,但结果也不会为空。
        Optional<Double> reduce = emps1.stream().map(Employee::getSalary).filter(item -> {
                    System.out.println("item" + item);
                    boolean equals = item == null;
                    return !equals;
                })
                .reduce(Double::sum);
        //如果上面为null的话,下面可以使用这个变成null。如果有值还会删除你的结果的。
        System.out.println(reduce.orElse(null));

/**
 * itemnull
 * itemnull
 * null
 */
    }

1.4.3 collect
 @Test
    public void test21() {
//        把名字收集到list中去
        List<String> list = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toList());

        list.forEach(System.out::println);

        System.out.println("----------------------------------");
//        把名字收集到set中去
        Set<String> set = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toSet());

        set.forEach(System.out::println);

        System.out.println("----------------------------------");

        //把名字放到hashset中去
        HashSet<String> hs = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toCollection(HashSet::new));
        hs.forEach(System.out::println);
    }


    @Test
    public void test22() {

        Optional<Double> max = emps.stream()
                .map(Employee::getSalary)
                .collect(Collectors.maxBy(Double::compare));
        //如果上面为空的话就为null,不为空就为  计算的值
        /**
         * 结果
         * 9999.99
         * 9999.99
         */
        System.out.println(max.orElse(null));
        System.out.println(max.get());


        Optional<Employee> op = emps.stream()
                .collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));

        System.out.println(op.get());


        //总薪水
        Double sum = emps.stream()
                .collect(Collectors.summingDouble(Employee::getSalary));
        System.out.println(sum);


        //平均值
        Double avg = emps.stream()
                .collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(avg);

        //总数
        Long count = emps.stream()
                .collect(Collectors.counting());

        System.out.println(count);

        System.out.println("--------------------------------------------");

        DoubleSummaryStatistics dss = emps.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));

        System.out.println(dss.getMax());
    }


 //计算薪水总和,里面能得到一系列的东西。总函数的形式
    @Test
    public void test28() {

        DoubleSummaryStatistics statistics = emps.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(statistics.getMax());
        System.out.println(statistics.getAverage());
        System.out.println(statistics.getCount()
        );
        System.out.println(statistics.getMin());
        System.out.println(statistics.getSum());


        IntSummaryStatistics summaryStatistics = emps.stream().collect(Collectors.summarizingInt(Employee::getAge));

//        Collectors.summarizingDouble(Employee::getSalary);
//        System.out.println(sum.get());
    }


 //分组
    @Test
    public void test23() {
        Map<Employee1.Status, List<Employee1>> map = empss.stream()
                .collect(Collectors.groupingBy(Employee1::getStatus));
        System.out.println(map);

//        遍历hashmap
        map.forEach((key, value) -> {
            System.out.println("key" + key + "======value" + value);
        });
    }


    //多级分组
    @Test
    public void test27() {
        Map<Employee1.Status, Map<String, List<Employee1>>> map = empss.stream()
                .collect(Collectors.groupingBy(Employee1::getStatus, Collectors.groupingBy((e) -> {
                    if (((Employee1) e).getAge() >= 60) {
                        return "老年";
                    } else if (((Employee1) e).getAge() >= 35) {
                        return "中年";
                    } else {
                        return "成年";
                    }

                })));

        System.out.println(map);
    }


    //分区
    @Test
    public void test24() {
        Map<Boolean, List<Employee>> map = emps.stream()
                .collect(Collectors.partitioningBy((e) -> e.getSalary() >= 5000));
        System.out.println(map);
    }

    //收集名字,分割,添加前后缀
    @Test
    public void test25() {
        String str = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.joining(",", "----", "----"));

        System.out.println(str);
    }

    //计算薪水总和。
    @Test
    public void test26() {
        Optional<Double> sum = emps.stream()
                .map(Employee::getSalary)
                .collect(Collectors.reducing(Double::sum));
        //结果保存小数点后保存两位
        System.out.println(sum.get().floatValue());
    }


    //计算薪水总和,里面能得到一系列的东西。总函数的形式
    @Test
    public void test28() {

        DoubleSummaryStatistics statistics = emps.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(statistics.getMax());
        System.out.println(statistics.getAverage());
        System.out.println(statistics.getCount()
        );
        System.out.println(statistics.getMin());
        System.out.println(statistics.getSum());


        IntSummaryStatistics summaryStatistics = emps.stream().collect(Collectors.summarizingInt(Employee::getAge));

//        Collectors.summarizingDouble(Employee::getSalary);
//        System.out.println(sum.get());
    }


1.4.5 将名字拼接起来
@Test
public void test29(){
    String collect = emps.stream().map(Employee::getName)
            .distinct()
            .sorted()
            .collect(Collectors.joining(" "));
    System.out.println(collect);
}
//第二种方法:

  //使用计算的形式,如果没有起始值,不知道加起来的值是字符串还是什么。如果没有起始值需要强制转换一下
        String reduce1 = emps.stream().map(Employee::getName).distinct().sorted()
                .reduce("", String::concat);
        System.out.println(reduce1);



结果 张三李四王五田七赵六

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

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

相关文章

JavaScript通过js的方式来判断一个数奇偶性的代码

以下为通过js的方式来判断一个数奇偶性的程序代码和运行截图 目录 前言 一、通过js的方式来判断一个数奇偶性&#xff08;html部分&#xff09; 1.1 运行流程及思想 1.2 代码段 二、通过js的方式来判断一个数奇偶性&#xff08;js部分&#xff09; 2.1 运行流程及思想 2…

美国新的 AI 研究基金将专注于 6 个领域

美国白宫周四宣布&#xff0c;在 1.4 亿美元的联邦资金支持下&#xff0c;拜登政府将开设七个新的人工智能实验室。 国家科学基金会将在其他政府机构的支持下掌舵运营。这些研究所将专注于六个研究课题&#xff1a; 1. 值得信赖的人工智能&#xff0c;隶属于马里兰大学领导的…

JustFE团队前端代码规范,降本增效,敏感肌可用

背景 &#x1f30f; 近年来&#xff0c;接手各个前端的代码&#xff0c;看着前人屎山&#xff0c;深恶痛绝 为了避免自己或者团队&#xff0c;继续添粪&#xff0c;因此经验总结一番~ 规范化优点&#xff1a; 容易理解&#xff0c;维护性强容易编写&#xff0c;扩展性强精准定…

优化营商环境:打造政策精准服务平台,提高惠政策落实落地时效性

近年来&#xff0c;各级政府部门及产业园区不断加强对于惠企政策的宣传和落实&#xff0c;努力打造优质的营商环境&#xff0c;加大助企纾困力度&#xff0c;以推动经济高质量发展。为了更好地实现这一目标&#xff0c;搭建惠企政策精准服务平台成为了一个非常重要的举措。 搭建…

Apache Zeppelin系列教程第四篇——Interpreter原理分析

Interpreter 其实就是整个项目的核心&#xff0c;代码运行都是在里面进行执行的&#xff0c;首先来看下Interpreter的抽象类 以jdbc-Interpreter为例&#xff0c;可以参考下测试代码(这个代码里面可以直接测试jdbc的sql执行过程和数据返回过程) 参数和介绍可以参考官方文档&am…

CH9329双头线使用说明

1.介绍说明 CH9329双头线是集成了CH9329CH340芯片的成品线&#xff0c;主要作用是使用主控电脑发送串口指令数据来控制被控电脑的键盘以及鼠标的功能。主控电脑和被控电脑可以是同一台电脑&#xff0c;就是能够自己控制自己。支持自定义修改USB的硬件信息&#xff0c;如PID、V…

FTP-HTTP-HTTPS的学习总结

FTP协议的学习 一&#xff0c;学习的要点 ftp的掌握总体架构、了解状态机 请求响应的格式、常用操作码及响应的含义 PORT与PASV的区别、断点续传 上传、下载文件的基本流程 1&#xff0c;FTP的架构主要有两种形式 UserPI&#xff08;用户解释器&#xff09;和ServerPI&…

『面试篇』之网络知识串联(一):DNS域名解析、TCP的建立与关闭

趁着马上就要面试的这个机会&#xff0c;将网络相关的知识进行一个串联复习。前端网络会在面试中遇到的问题其实并不是很多&#xff0c;核心的内容主要是TCP建立的的三次握手、TCP断开的四次挥手、DNS解析的过程、以及前端跨域等。话不多说&#xff0c;我们直接进入正题。 一、…

【STL十八】算法——不修改序列的操作(for_each、count、find、equal、search)

【STL十八】算法——不修改序列的操作&#xff08;for_each、count、find、equal、search&#xff09; 一、简介二、头文件三、分类四、不修改序列的操作1、for_each2、count、count_if3、find、find_if4、euqal5、search 前言&#xff1a;在前面我们讲解容器和函数对象时&…

X.25,帧中继(FR),ATM三种分组交换系统

X.25、帧中继&#xff08;FR&#xff09;、ATM 是流行的三种分组交换系统&#xff0c;它们具有不同的特点。 两个术语&#xff1a; DTE(Data Terminal Equipment) &#xff0c;数据终端设备&#xff0c;如我们的个人电脑、手机。 DCE(Data Circuit Equipment) &#xff0c;数据…

【STM32】基础知识 第十二课 GPIO

【STM32】基础知识 第十二课 GPIO 概述GPIO 简介GPIO 模式GPIO 特点GPIO 配置GPIO 操作施密特触发器案例 概述 本文小白我将来介绍通用输入与输出, GPIO (General-Purpose Input/Output) 在单片机中的应用, 以及如何配合和食用 GPIO 来实现各种功能. GPIO 简介 GPIO 是单片机…

十三、共享内存

文章目录 一、什么是共享内存&#xff08;一&#xff09;共享内存的定义&#xff08;二&#xff09;共享内存的原理&#xff08;三&#xff09;共享内存的理解 二、为什么要有共享内存三、共享内存怎么进行&#xff08;一&#xff09; 共享内存的数据结构&#xff08;二&#x…

【Redis系列】Redis布隆过滤之8亿大数据集实战

序言 即便平凡的日子仿佛毫无波澜&#xff0c;但在某个特定的时刻&#xff0c;执着的努力便会显现出它的价值和意义。 文章标记颜色说明&#xff1a; 黄色&#xff1a;重要标题红色&#xff1a;用来标记结论绿色&#xff1a;用来标记一级重要蓝色&#xff1a;用来标记二级重要 …

SPC Control Chart Tools for WPF 3.1 Crack

使用 WPF 的 SPC 控制图工具&#xff0c;将变量控制图&#xff08;X-Bar R、X-Bar Sigma、单个范围、中值范围、EWMA、MA、MAMR、MAMS 和 CuSum 控制图&#xff09;、属性控制图&#xff08;p、np、c、u 和 DPMO 控制图&#xff09;、频率直方图和帕累托图添加到 WPF 和 WPF We…

物理机:显卡3080 环境Centos7.9 如何检查及安装显卡驱动

环境&#xff1a; 硬件服务器&#xff1a;I5处理器&#xff0c; 显卡&#xff1a;3080 12G 等。 目标&#xff1a; 测试是否安装显卡。 如何找到正确的驱动版本。 安装显卡正确的显卡驱动。 一、检查是否正确安装显卡&#xff1a; # 检查使用什么型号的显卡&#xff1a; yum…

淄博烧烤,怎么就“出圈”了-也是机器视觉行业职场中的态度:少一点套路,多一些真诚,少一点计较,多一些宽容

我认为淄博烧烤之所以火爆&#xff0c;是因为它代表了一种淄博人的态度&#xff0c;一种对生活的热爱和对客人的真诚。 我认为淄博烧烤之所以火爆&#xff0c;是因为它代表了一种淄博人的态度&#xff0c;一种对生活的热爱和对客人的真诚。 我想更重要的一点&#xff0c;淄博烧…

使用NineData定制企业级数据库规范

1. 为什么需要数据库规范&#xff1f; 在企业级应用中&#xff0c;数据库是非常重要的一部分&#xff0c;它们存储着公司的核心数据&#xff0c;包括客户信息、订单、产品信息等等。如果这些数据没有得到妥善的管理&#xff0c;那么就会导致数据不一致、数据丢失、数据泄露等问…

涨知识!细数银行卡三要素 API 的 N 种验证方法

引言 银行卡三要素验证 API 是一种基于姓名、身份证号码和银行卡号等三种信息的验证服务&#xff0c;主要用于绑定银行卡时校验银行卡是否为该身份信息所有、手机号是否为银行卡绑定手机号。 银行卡三要素 API 的验证方法 银行卡三要素 API 的验证原理是通过与银行或银联网络…

k8s二进制搭建|ETCD + Flannel | 单节点部署 | 多节点的部署|dashbord的部署

k8s二进制搭建|ETCD Flannel | 单节点部署 | 多节点的部署|dashbord的部署 二进制搭建 Kubernetes v1.201 初始化环境2 部署 docker引擎3 在mster 192.168.10.10上操作4 在 node01 192.168.10.20节点上操作5 在 node02 192.168.10.30节点上操作6 检查etcd群集状态7 部署 Maste…

SpringBoot——入门程序的简单介绍

简单介绍&#xff1a; 在之前我们创建了一个基础的SpringBoot的程序&#xff0c;可以看到&#xff0c;我们只是启动了一个Java程序&#xff0c;但是它启动了一个Tomcat的服务器。其实在这里面他还启动了很多的服务&#xff0c;只不过这些服务我们都没有用到&#xff0c;我们就…