Java |收集器minBy（Comparator Comparator）及其示例-yiteyi-C++库

比较器< ? 超级T >（比较器） 用于根据作为参数传递的比较器查找元素。它返回一个收集器，该收集器根据给定的比较器生成最小元素，称为可选 .

null

语法：

public static 
    <T> Collector<T, ?, Optional<T>> 
        minBy(Comparator<? super T> comparator)

其中使用的术语如下：

接口收集器 ：一种可变缩减操作，将输入元素累积到可变结果容器中，可以选择在处理完所有输入元素后将累积结果转换为最终表示形式。还原操作可以顺序执行，也可以并行执行。
- T: 还原操作的输入元素类型。
- A: 还原操作的可变累积类型。
- R: 还原操作的结果类型。
可选： 一个容器对象，它可能包含也可能不包含非空值。如果存在一个值，isPresent（）将返回true，get（）将返回该值。
比较国： 一种比较函数，它对某些对象集合施加总排序。可以将比较器传递给排序方法，以便对排序顺序进行精确控制。比较器还可用于控制某些数据结构（如排序集或排序映射）的顺序，或为没有自然排序的对象集合提供排序。

参数： 此方法接受一个参数 比较器 Comparator类型，这是一个比较函数，它对一些对象集合施加总排序。可以将比较器传递给排序方法，以便对排序顺序进行精确控制。比较器还可用于控制某些数据结构（如排序集或排序映射）的顺序，或为没有自然排序的对象集合提供排序。

返回值： 此方法返回一个收集器，该收集器根据传递的比较器生成最小值。

下面是一些示例来说明minBy（）的实现：

项目1： 使用naturalOrder（）演示minBy（）

                     // Java code to show the implementation of                   
                     // Collectors minBy(Comparator comparator) function                   
                             
                     import                               java.util.Comparator;                   
                     import                               java.util.Optional;                   
                     import                               java.util.stream.Collectors;                   
                     import                               java.util.stream.Stream;                   
                             
                     class                               GFG {                   
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // creating a Stream of strings                   
                                         Stream<String> s = Stream.of(                               "2"                               ,                               "3"                               ,                               "4"                               ,                               "5"                               );                   
                             
                                         // using Collectors minBy(Comparator comparator)                   
                                         // and finding the minimum element                   
                                         // in reverse order                   
                                         Optional<String> obj = s                   
                                         .collect(Collectors                   
                                         .minBy(Comparator                   
                                         .naturalOrder()));                   
                             
                                         // if present, print the element                   
                                         // else print the message                   
                                         if                               (obj.isPresent()) {                   
                                         System.out.println(obj.get());                   
                                         }                   
                                         else                               {                   
                                         System.out.println(                               "no value"                               );                   
                                         }                   
                                         }                   
                     }                   

输出：

项目2： 使用reverseOrder（）演示minBy（）

                     // Java code to show the implementation of                   
                     // Collectors minBy(Comparator comparator) function                   
                             
                     import                               java.util.Comparator;                   
                     import                               java.util.Optional;                   
                     import                               java.util.stream.Collectors;                   
                     import                               java.util.stream.Stream;                   
                             
                     class                               GFG {                   
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // creating a Stream of strings                   
                                         Stream<String> s = Stream.of(                               "2"                               ,                               "3"                               ,                               "4"                               ,                               "5"                               );                   
                             
                                         // using Collectors minBy(Comparator comparator)                   
                                         // and finding the minimum element                   
                                         // in reverse order                   
                                         Optional<String> obj = s                   
                                         .collect(Collectors                   
                                         .minBy(Comparator                   
                                         .reverseOrder()));                   
                             
                                         // if present, print the element                   
                                         // else print the message                   
                                         if                               (obj.isPresent()) {                   
                                         System.out.println(obj.get());                   
                                         }                   
                                         else                               {                   
                                         System.out.println(                               "no value"                               );                   
                                         }                   
                                         }                   
                     }                   

输出：

方案3： 演示没有传递值时的minBy（）。

                     // Java code to show the implementation of                   
                     // Collectors minBy(Comparator comparator) function                   
                             
                     import                               java.util.Comparator;                   
                     import                               java.util.Optional;                   
                     import                               java.util.stream.Collectors;                   
                     import                               java.util.stream.Stream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                             
                                         // creating a Stream of strings                   
                                         Stream<String> s = Stream.of();                   
                             
                                         // using Collectors minBy(Comparator comparator)                   
                                         // and finding the minimum element                   
                                         // in reverse order                   
                                         Optional<String> obj = s                   
                                         .collect(Collectors                   
                                         .minBy(Comparator                   
                                         .reverseOrder()));                   
                             
                                         // if present, print the element                   
                                         // else print the message                   
                                         if                               (obj.isPresent()) {                   
                                         System.out.println(obj.get());                   
                                         }                   
                                         else                               {                   
                                         System.out.println(                               "no value"                               );                   
                                         }                   
                                         }                   
                     }                   

输出：

no value

文章版权归作者所有，未经允许请勿转载。

THE END

Java