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实现检查多个时间段是否有重合,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录流程概述步骤详解China编程步骤1：定义时间段类步骤2：添加时间段步骤3：检查时间段是否有重合步骤4：输出结果示例代码结语作
阅读更多...
Java中String字符串使用避坑指南

Java中String字符串使用避坑指南

《Java中String字符串使用避坑指南》Java中的String字符串是我们日常编程中用得最多的类之一,看似简单的String使用,却隐藏着不少“坑”,如果不注意,可能会导致性能问题、意外的错误容... 目录8个避坑点如下：1. 字符串的不可变性：每次修改都创建新对象2. 使用 == 比较字符串，陷阱满
阅读更多...
Java判断多个时间段是否重合的方法小结

Java判断多个时间段是否重合的方法小结

《Java判断多个时间段是否重合的方法小结》这篇文章主要为大家详细介绍了Java中判断多个时间段是否重合的方法,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录判断多个时间段是否有间隔判断时间段集合是否与某时间段重合判断多个时间段是否有间隔实体类内容public class D
阅读更多...
IDEA编译报错“java: 常量字符串过长”的原因及解决方法

IDEA编译报错“java: 常量字符串过长”的原因及解决方法

《IDEA编译报错“java:常量字符串过长”的原因及解决方法》今天在开发过程中,由于尝试将一个文件的Base64字符串设置为常量,结果导致IDEA编译的时候出现了如下报错java:常量字符串过长,... 目录一、问题描述二、问题原因2.1 理论角度2.2 源码角度三、解决方案解决方案①：StringBui
阅读更多...
Java覆盖第三方jar包中的某一个类的实现方法

Java覆盖第三方jar包中的某一个类的实现方法

《Java覆盖第三方jar包中的某一个类的实现方法》在我们日常的开发中,经常需要使用第三方的jar包,有时候我们会发现第三方的jar包中的某一个类有问题,或者我们需要定制化修改其中的逻辑,那么应该如何... 目录一、需求描述二、示例描述三、操作步骤四、验证结果五、实现原理一、需求描述需求描述如下：需要在
阅读更多...
Java中ArrayList和LinkedList有什么区别举例详解

Java中ArrayList和LinkedList有什么区别举例详解

《Java中ArrayList和LinkedList有什么区别举例详解》：本文主要介绍Java中ArrayList和LinkedList区别的相关资料,包括数据结构特性、核心操作性能、内存与GC影... 目录一、底层数据结构二、核心操作性能对比三、内存与 GC 影响四、扩容机制五、线程安全与并发方案六、工程
阅读更多...
JavaScript中的reduce方法执行过程、使用场景及进阶用法

JavaScript中的reduce方法执行过程、使用场景及进阶用法

《JavaScript中的reduce方法执行过程、使用场景及进阶用法》：本文主要介绍JavaScript中的reduce方法执行过程、使用场景及进阶用法的相关资料,reduce是JavaScri... 目录1. 什么是reduce2. reduce语法2.1 语法2.2 参数说明3. reduce执行过程
阅读更多...
如何使用Java实现请求deepseek

如何使用Java实现请求deepseek

《如何使用Java实现请求deepseek》这篇文章主要为大家详细介绍了如何使用Java实现请求deepseek功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1.deepseek的api创建2.Java实现请求deepseek2.1 pom文件2.2 json转化文件2.2
阅读更多...
Java调用DeepSeek API的最佳实践及详细代码示例

Java调用DeepSeek API的最佳实践及详细代码示例

《Java调用DeepSeekAPI的最佳实践及详细代码示例》：本文主要介绍如何使用Java调用DeepSeekAPI,包括获取API密钥、添加HTTP客户端依赖、创建HTTP请求、处理响应、... 目录1. 获取API密钥2. 添加HTTP客户端依赖3. 创建HTTP请求4. 处理响应5. 错误处理6.
阅读更多...
Spring AI集成DeepSeek的详细步骤

Spring AI集成DeepSeek的详细步骤

《SpringAI集成DeepSeek的详细步骤》DeepSeek作为一款卓越的国产AI模型,越来越多的公司考虑在自己的应用中集成,对于Java应用来说,我们可以借助SpringAI集成DeepSe... 目录DeepSeek 介绍Spring AI 是什么？1、环境准备2、构建项目2.1、pom依赖2.2
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2