Java8 Stream之Collectors

2024-08-21 09:48
文章标签 java stream collectors

本文主要是介绍Java8 Stream之Collectors，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

  • toList、toSet
  • toMap
  • toConcurrentMap
  • toCollection
  • joining
  • collectingAndThen
  • groupingBy
  • groupingByConcurrent
  • partitioningBy
  • counting
    • Stream.count() 实现相同功能
  • maxBy
    • Stream.max() 实现相同功能
  • minBy
    • Stream.min() 实现相同功能
  • summingXXX
    • Stream.sum() 实现相同功能
  • summarizingXXX
  • mapping
    • Stream.map 实现相同功能
  • reducing
    • Stream.reduce 实现相同功能
  • averagingDouble
    • Stream.average() 实现相同功能

Collectors 是 Java 8 加入的操作类，位于 java.util.stream 包下。它会根据不同的策略将元素收集归纳起来，比如最简单常用的是将元素装入 Map、Set、List等可变容器中

toList、toSet

Collector<T, ?, List<T>> toList() 
返回一个将输入元素累积到新List中的CollectorCollector<T, ?, Set<T>> toSet() 
返回一个将输入元素累积到新Set中的Collector

Stream<String> language = Stream.of("java", "php","java");
List<String> list = language.collect(Collectors.toList());
System.out.println(list);//[java, php, java]Stream<String> language1 = Stream.of("java", "php","java");
Set<String> set = language1.collect(Collectors.toSet());
System.out.println(set);//[java, php]

toMap

Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
返回一个将输入元素累积到新map中的Collector，keyMapper生成key的函数，valueMapper生成value的函数,当可以相同时报错java.lang.IllegalStateException: Duplicate keyCollector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction)
返回一个将输入元素累积到新map中的Collector，keyMapper生成key的函数，valueMapper生成value的函数,mergeFunction处理相同key的元素Collector<T, ?, M> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)
返回一个将输入元素累积到新map中的Collector，keyMapper生成key的函数，valueMapper生成value的函数,mergeFunction处理相同key的元素,mapSupplier一个函数，它返回一个新的指定实现类的空Map ，结果将插入其中

Stream<String> language2 = Stream.of("java", "php");
Map<String, Integer> map = language2.collect(Collectors.toMap(o -> o, o -> o.length()));
System.out.println(map);//{java=4, php=3}Stream<String> language21 = Stream.of("java", "php","java");
Map<String, Integer> map21 = language21.collect(Collectors.toMap(o -> o, o -> o.length(), (o1, o2) ->  o1));
System.out.println(map21);//{java=4, php=3}Stream<String> language22 = Stream.of("java", "php","java");
LinkedHashMap<String, Integer> map22 = language22.collect(Collectors.toMap(o -> o, o -> o.length(), (o1, o2) ->  o1, LinkedHashMap::new));
System.out.println(map22);//{java=4, php=3}

toConcurrentMap

和toMap相似，但是使用并发ConcurrentMap承装

Collector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
返回一个将输入元素累积到新并发map中的Collector，keyMapper生成key的函数，valueMapper生成value的函数,当可以相同时报错java.lang.IllegalStateException: Duplicate keyCollector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction)
返回一个将输入元素累积到新map中的Collector，keyMapper生成key的函数，valueMapper生成value的函数,mergeFunction处理相同key的元素Collector<T, ?, M> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)
返回一个将输入元素累积到新map中的Collector，keyMapper生成key的函数，valueMapper生成value的函数,mergeFunction处理相同key的元素,mapSupplier一个函数，它返回一个新的指定实现类的空Map ，结果将插入其中

Stream<String> language4 = Stream.of("java", "php");
ConcurrentMap<String, Integer> concurrentMap = language4.collect(Collectors.toConcurrentMap(o -> o, o -> o.length()));
System.out.println(concurrentMap);//{java=4, php=3}Stream<String> language41 = Stream.of("java", "php","java");
ConcurrentMap<String, Integer> concurrentMap1 = language41.collect(Collectors.toConcurrentMap(o -> o, o -> o.length(), (o1, o2) ->  o1));
System.out.println(concurrentMap1);//{java=4, php=3}Stream<String> language42 = Stream.of("java", "php","java");
ConcurrentMap<String, Integer> concurrentMap2 = language42.collect(Collectors.toConcurrentMap(o -> o, o -> o.length(), (o1, o2) ->  o1, ConcurrentHashMap::new));
System.out.println(concurrentMap2);//{java=4, php=3}

toCollection

指定承装集合类型

Collector<T, ?, C> toCollection(Supplier<C> collectionFactory)
返回一个将输入元素累积到一个新的指定实现类的Collection中

Stream<String> language3 = Stream.of("java", "php","java");
ArrayList<String> arrayList = language3.collect(Collectors.toCollection(ArrayList::new));
System.out.println(arrayList);//[java, php, java]

joining

拼接元素

Collector<CharSequence, ?, String> joining() 
返回一个Collector ，它按照遇到的顺序将输入元素连接成一个StringCollector<CharSequence, ?, String> joining(CharSequence delimiter) 
返回一个以遇到顺序连接输入元素的Collector ，由指定的分隔符分隔Collector<CharSequence, ?, String> joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)返回一个Collector ，它按遇到顺序连接输入元素，由指定的分隔符分隔，具有指定的前缀和后缀

Stream<String> language = Stream.of("java", "php","java");
String joining = language.collect(Collectors.joining());
System.out.println(joining);//javaphpjavaStream<String> language1 = Stream.of("java", "php","java");
String joining1 = language1.collect(Collectors.joining(","));
System.out.println(joining1);//java,php,javaStream<String> language2 = Stream.of("java", "php","java");
String joining2 = language2.collect(Collectors.joining(",", "[", "]"));
System.out.println(joining2);//[java,php,java]

collectingAndThen

对Collector执行多次加工转换

Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher) 
对Collector执行多次加工转换

Stream<String> language = Stream.of("java", "php","java");
String collectingAndThen = language.collect(Collectors.collectingAndThen(Collectors.joining(","), String::toUpperCase));
System.out.println(collectingAndThen);//JAVA,PHP,JAVA

groupingBy

对元素分组

Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> classifier)
对类型T输入元素执行“分组”操作,符合条件的元素将组成一个 List 映射到以T为key 的 Map 中Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)
对类型T输入元素执行“分组”操作,符合条件的元素将组成一个 集合 映射到以T为key 的 Map 中，downstream指定返回集合类型Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)
对类型T输入元素执行“分组”操作,符合条件的元素将组成一个 集合 映射到以T为key 的 mapFactory新生成的map 中，downstream指定返回集合类型

Stream<String> language = Stream.of("java", "php","java");
Map<Integer, List<String>> map = language.collect(Collectors.groupingBy(String::length));
System.out.println(map);//{3=[php], 4=[java, java]}Stream<String> language2 = Stream.of("java", "php","java");
Map<Integer, Set<String>> map2 = language2.collect(Collectors.groupingBy(String::length, Collectors.toSet()));
System.out.println(map2);//{3=[php], 4=[java]}Stream<String> language3 = Stream.of("java", "php","java");
LinkedHashMap<Integer, Map<String, Integer>> map3 = language3.collect(Collectors.groupingBy(String::length, LinkedHashMap::new, Collectors.toMap(o -> o, o -> o.length(), (o1, o2) ->  o1)));
System.out.println(map3);//{4={java=4}, 3={php=3}}

groupingByConcurrent

分组后返回的是一个并发集合

Collector<T, ?, ConcurrentMap<K, List<T>>> groupingByConcurrent(Function<? super T, ? extends K> classifier)
对类型T输入元素执行“分组”操作,符合条件的元素将组成一个 List 映射到以T为key 的 并发Map 中Collector<T, ?, ConcurrentMap<K, D>> groupingByConcurrent(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)
对类型T输入元素执行“分组”操作,符合条件的元素将组成一个 集合 映射到以T为key 的 并发Map 中，downstream指定返回集合类型Collector<T, ?, M> groupingByConcurrent(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)
对类型T输入元素执行“分组”操作,符合条件的元素将组成一个 集合 映射到以T为key 的 mapFactory新生成的并发map 中，downstream指定返回集合类型

Stream<String> language = Stream.of("java", "php","java");
Map<Integer, List<String>> map = language.collect(Collectors.groupingByConcurrent(String::length));
System.out.println(map);//{3=[php], 4=[java, java]}Stream<String> language2 = Stream.of("java", "php","java");
Map<Integer, Set<String>> map2 = language2.collect(Collectors.groupingByConcurrent(String::length, Collectors.toSet()));
System.out.println(map2);//{3=[php], 4=[java]}Stream<String> language3 = Stream.of("java", "php","java");
ConcurrentHashMap<Integer, Map<String, Integer>> map3 = language3.collect(Collectors.groupingByConcurrent(String::length, ConcurrentHashMap::new, Collectors.toMap(o -> o, o -> o.length(), (o1, o2) ->  o1)));
System.out.println(map3);//{3={php=3}, 4={java=4}}

partitioningBy

Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate)
根据Predicate对输入元素进行判断分区，并将它们组织成Map<Boolean, List<T>>Collector<T, ?, Map<Boolean, D>> partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream)
根据Predicate对输入元素进行判断分区，并将它们组织成Map<Boolean, ?<T>>,downstream指定返回集合类型

Stream<String> language = Stream.of("java", "php","java");
Map<Boolean, List<String>> map = language.collect(Collectors.partitioningBy(o -> o.length() > 3));
System.out.println(map);//{false=[php], true=[java, java]}Stream<String> language2 = Stream.of("java", "php","java");
Map<Boolean, Set<String>> map2 = language2.collect(Collectors.partitioningBy(o -> o.length() > 3, Collectors.toSet()));
System.out.println(map2);//{false=[php], true=[java]}

counting

Collector<T, ?, Long> counting()
计算输入元素的数量。 如果不存在元素，则结果为 0。

Stream<String> language = Stream.of("java", "php","java");
Long count = language.collect(Collectors.counting());
System.out.println(count);//3

Stream.count() 实现相同功能

Stream<String> language = Stream.of("java", "php","java");
Long count = language.count();
System.out.println(count);//3

maxBy

Collector<T, ?, Optional<T>> maxBy(Comparator<? super T> comparator)
根据comparato比较后返回最大元素的Optional<T>

Stream<String> language = Stream.of("java", "php","java");
Optional<String> maxObj = language.collect(Collectors.maxBy(Comparator.comparingInt(String::length)));
System.out.println(maxObj.get());//java

Stream.max() 实现相同功能

Stream<String> language = Stream.of("java", "php","java");
Optional<String> max = language.max(Comparator.comparingInt(String::length));
System.out.println(max.get());//java

minBy

Collector<T, ?, Optional<T>> minBy(Comparator<? super T> comparator)
根据comparato比较后返回最小元素的Optional<T>

Stream<String> language = Stream.of("java", "php","java");
Optional<String> maxObj = language.collect(Collectors.minBy(Comparator.comparingInt(String::length)));
System.out.println(maxObj.get());//php

Stream.min() 实现相同功能

Stream<String> language = Stream.of("java", "php","java");
Optional<String> max = language.min(Comparator.comparingInt(String::length));
System.out.println(max.get());//php

summingXXX

Collector<T, ?, Double> summingDouble(ToDoubleFunction<? super T> mapper)
求输入元素的Double类型数值函数的总和
Collector<T, ?, Integer> summingInt(ToIntFunction<? super T> mapper)
求输入元素的Integer类型数值函数的总和
Collector<T, ?, Long> summingLong(ToLongFunction<? super T> mapper)
求输入元素的Long类型数值函数的总和

Stream<String> language = Stream.of("java", "php","java");
Double sumDouble = language.collect(Collectors.summingDouble(String::length));
System.out.println(sumDouble);//11.0Stream<String> language2 = Stream.of("java", "php","java");
Integer sumInt = language2.collect(Collectors.summingInt(String::length));
System.out.println(sumInt);//11Stream<String> language3 = Stream.of("java", "php","java");
Long sumLong = language3.collect(Collectors.summingLong(String::length));
System.out.println(sumLong);//11

Stream.sum() 实现相同功能

当Stream的类似是数字时，可以用Stream.sum()实现相同功能

DoubleStream language = DoubleStream.of(4, 3, 4);
double sumDouble = language.sum();
System.out.println(sumDouble);//11.0IntStream language2 = IntStream.of(4, 3, 4);
Integer sumInt = language2.sum();
System.out.println(sumInt);//11LongStream language3 = LongStream.of(4, 3, 4);
Long sumLong = language3.sum();
System.out.println(sumLong);//11

summarizingXXX

汇总统计

Collector<T, ?, DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)
以Double类型数值函数汇总统计，包含了 总数，总和，最小值，最大值，平均值 五个指标。Collector<T, ?, IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)
以Integer类型数值函数汇总统计，包含了 总数，总和，最小值，最大值，平均值 五个指标。Collector<T, ?, LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)
以Long类型数值函数汇总统计，包含了 总数，总和，最小值，最大值，平均值 五个指标。

Stream<String> language = Stream.of("java", "php","java");
DoubleSummaryStatistics doubleSummaryStatistics = language.collect(Collectors.summarizingDouble(String::length));
System.out.println(doubleSummaryStatistics);//DoubleSummaryStatistics{count=3, sum=11.000000, min=3.000000, average=3.666667, max=4.000000}Stream<String> language2 = Stream.of("java", "php","java");
IntSummaryStatistics intSummaryStatistics = language2.collect(Collectors.summarizingInt(String::length));
System.out.println(intSummaryStatistics);//IntSummaryStatistics{count=3, sum=11, min=3, average=3.666667, max=4}Stream<String> language3 = Stream.of("java", "php","java");
LongSummaryStatistics longSummaryStatistics = language3.collect(Collectors.summarizingLong(String::length));
System.out.println(longSummaryStatistics);//LongSummaryStatistics{count=3, sum=11, min=3, average=3.666667, max=4}

mapping

Collector<T, ?, R> mapping(Function<? super T, ? extends U> mapper, Collector<? super U, A, R> downstream)
先对元素使用 mapper 进行再加工操作，然后用另一个downstream 归纳

Stream<String> language = Stream.of("java", "php","java");
List<String> list = language.collect(Collectors.mapping(s -> s.substring(1), Collectors.toList()));
System.out.println(list);//[ava, hp, ava]

Stream.map 实现相同功能

Stream<String> language2 = Stream.of("java", "php","java");
List<String> list2 = language2.map(s -> s.substring(1)).collect(Collectors.toList());
System.out.println(list2);//[ava, hp, ava]

reducing

Collector<T, ?, Optional<T>> reducing(BinaryOperator<T> op)
根据op比较器来比较大小并分别返回最大值或者最小值,可能拿不到结果Collector<T, ?, T> reducing(T identity, BinaryOperator<T> op)
根据op比较器来比较大小并分别返回最大值或者最小值,identity为基准值，基准值也参与比较，没有结果时返回基准值，否则返回比较结果Collector<T, ?, U> reducing(U identity, Function<? super T, ? extends U> mapper, BinaryOperator<U> op)
先对元素进行mapper映射处理，再根据op比较器来比较大小并分别返回最大值或者最小值,identity为基准值，基准值也参与比较，没有结果时返回基准值，否则返回比较结果

Stream<String> language = Stream.of("java", "php","java");
Comparator<String> comparing = Comparator.comparing(String::length);
Optional<String> obj = language.collect(Collectors.reducing(BinaryOperator.minBy(comparing)));
System.out.println(obj);//Optional[php]Stream<String> language2 = Stream.of("java", "php","java");
Comparator<String> comparing2 = Comparator.comparing(String::length);
String objStr = language2.collect(Collectors.reducing("androd", BinaryOperator.maxBy(comparing2)));
System.out.println(objStr);//androdStream<String> language3 = Stream.of("java", "php","java");
Function<String, String> mapper = str -> {return str.substring(1);};
Comparator<String> comparing3 = Comparator.comparing(String::length);
String objStr2 = language3.collect(Collectors.reducing("androd", mapper, BinaryOperator.maxBy(comparing3)));
System.out.println(objStr2);//androd

Stream.reduce 实现相同功能

Stream<String> language = Stream.of("java", "php","java");
Comparator<String> comparing = Comparator.comparing(String::length);
Optional<String> obj = language.reduce(BinaryOperator.minBy(comparing));
System.out.println(obj);//Optional[php]Stream<String> language2 = Stream.of("java", "php","java");
Comparator<String> comparing2 = Comparator.comparing(String::length);
String objStr = language2.reduce("androd", BinaryOperator.maxBy(comparing2));
System.out.println(objStr);//androdStream<String> language3 = Stream.of("java", "php","java");
BiFunction<String, String, String> mapper = (str1, str2) -> { return str1.length()>str2.length()? str1:str2; };
Comparator<String> comparing3 = Comparator.comparing(String::length);
//第三个参数BinaryOperator.minBy(comparing3)无效，作用是合并各个流结果，故在parallelStream时才生效
String objStr2 = language3.reduce("androd", mapper, BinaryOperator.minBy(comparing3));
System.out.println(objStr2);//androd

averagingDouble

Collector<T, ?, Double> averagingDouble(ToDoubleFunction<? super T> mapper)
对元素进行Double类型数值函数映射处理后，求拼接值Collector<T, ?, Double> averagingInt(ToIntFunction<? super T> mapper)
对元素进行Int类型数值函数映射处理后，求拼接值Collector<T, ?, Double> averagingLong(ToLongFunction<? super T> mapper)
对元素进行Long类型数值函数映射处理后，求拼接值

Stream<String> language = Stream.of("java", "php","java");
Double averagingDouble = language.collect(Collectors.averagingDouble(String::length));
System.out.println(averagingDouble);//3.6666666666666665Stream<String> language2 = Stream.of("java", "php","java");
Double averagingInt2 = language2.collect(Collectors.averagingInt(String::length));
System.out.println(averagingInt2);//3.6666666666666665Stream<String> language3 = Stream.of("java", "php","java");
Double averagingLong3 = language3.collect(Collectors.averagingLong(String::length));
System.out.println(averagingLong3);//3.6666666666666665

Stream.average() 实现相同功能

当Stream的类似是数字时，可以用Stream.sum()实现相同功能

DoubleStream language = DoubleStream.of(4, 3, 4);
OptionalDouble sumDouble = language.average();
System.out.println(sumDouble.getAsDouble());//3.6666666666666665IntStream language2 = IntStream.of(4, 3, 4);
OptionalDouble sumInt = language2.average();
System.out.println(sumInt.getAsDouble());//3.6666666666666665LongStream language3 = LongStream.of(4, 3, 4);
OptionalDouble sumLong = language3.average();
System.out.println(sumLong.getAsDouble());//3.6666666666666665

这篇关于Java8 Stream之Collectors的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1092818。

相关文章

Java计算经纬度距离的示例代码

Java计算经纬度距离的示例代码

《Java计算经纬度距离的示例代码》在Java中计算两个经纬度之间的距离,可以使用多种方法（代码示例均返回米为单位）,文中整理了常用的5种方法,感兴趣的小伙伴可以了解一下... 目录1. Haversine公式（中等精度，推荐通用场景）2. 球面余弦定理（简单但精度较低）3. Vincenty公式（高精度，
阅读更多...
使用Java将实体类转换为JSON并输出到控制台的完整过程

使用Java将实体类转换为JSON并输出到控制台的完整过程

《使用Java将实体类转换为JSON并输出到控制台的完整过程》在软件开发的过程中,Java是一种广泛使用的编程语言,而在众多应用中,数据的传输和存储经常需要使用JSON格式,用Java将实体类转换为J... 在软件开发的过程中，Java是一种广泛使用的编程语言，而在众多应用中，数据的传输和存储经常需要使用j
阅读更多...
Java实现视频格式转换的完整指南

Java实现视频格式转换的完整指南

《Java实现视频格式转换的完整指南》在Java中实现视频格式的转换,通常需要借助第三方工具或库,因为视频的编解码操作复杂且性能需求较高,以下是实现视频格式转换的常用方法和步骤,需要的朋友可以参考下... 目录核心思路方法一：通过调用 FFmpeg 命令步骤示例代码说明优点方法二：使用 Jaffree（FF
阅读更多...
Java实现图片淡入淡出效果

Java实现图片淡入淡出效果

《Java实现图片淡入淡出效果》在现代图形用户界面和游戏开发中,**图片淡入淡出（FadeIn／Out）**是一种常见且实用的视觉过渡效果,它可以用于启动画面、场景切换、轮播图、提示框弹出等场景,通过... 目录1. 项目背景详细介绍2. 项目需求详细介绍2.1 功能需求2.2 非功能需求3. 相关技术详细
阅读更多...
Java如何用乘号来重复字符串的功能

Java如何用乘号来重复字符串的功能

《Java如何用乘号来重复字符串的功能》：本文主要介绍Java使用乘号来重复字符串的功能,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录Java乘号来重复字符串的功能1、利用循环2、使用StringBuilder3、采用 Java 11 引入的String.rep
阅读更多...
SpringBoot中HTTP连接池的配置与优化

SpringBoot中HTTP连接池的配置与优化

《SpringBoot中HTTP连接池的配置与优化》这篇文章主要为大家详细介绍了SpringBoot中HTTP连接池的配置与优化的相关知识,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一... 目录一、HTTP连接池的核心价值二、Spring Boot集成方案方案1：Apache HttpCl
阅读更多...
Spring Boot项目打包和运行的操作方法

Spring Boot项目打包和运行的操作方法

《SpringBoot项目打包和运行的操作方法》SpringBoot应用内嵌了Web服务器,所以基于SpringBoot开发的web应用也可以独立运行,无须部署到其他Web服务器中,下面以打包dem... 目录一、打包为JAR包并运行1.打包为可执行的 JAR 包2.运行 JAR 包二、打包为WAR包并运行
阅读更多...
Java进行日期解析与格式化的实现代码

Java进行日期解析与格式化的实现代码

《Java进行日期解析与格式化的实现代码》使用Java搭配ApacheCommonsLang3和Natty库,可以实现灵活高效的日期解析与格式化,本文将通过相关示例为大家讲讲具体的实践操作,需要的可以... 目录一、背景二、依赖介绍1. Apache Commons Lang32. Natty三、核心实现代
阅读更多...
Spring Boot 常用注解整理(最全收藏版)

Spring Boot 常用注解整理(最全收藏版)

《SpringBoot常用注解整理(最全收藏版)》本文系统整理了常用的Spring/SpringBoot注解,按照功能分类进行介绍,每个注解都会涵盖其含义、提供来源、应用场景以及代码示例,帮助开发... 目录Spring & Spring Boot 常用注解整理一、Spring Boot 核心注解二、Spr
阅读更多...
SpringBoot实现接口数据加解密的三种实战方案

SpringBoot实现接口数据加解密的三种实战方案

《SpringBoot实现接口数据加解密的三种实战方案》在金融支付、用户隐私信息传输等场景中,接口数据若以明文传输,极易被中间人攻击窃取,SpringBoot提供了多种优雅的加解密实现方案,本文将从原... 目录一、为什么需要接口数据加解密？二、核心加解密算法选择1. 对称加密（AES）2. 非对称加密（R
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2