函数式编程

当涉及到Java中Lambda表达式的用法，以下是一个总结，包括了各种常见的使用情境：

1. 基本语法：

   Lambda表达式的基本语法是 (parameters) -> expression，其中：

   • parameters：Lambda函数的参数列表，可以为空或包含一个或多个参数。
   • >：Lambda运算符，用于分隔参数和表达式。
   • expression：Lambda函数的返回值表达式。

2. 创建函数式接口的实例：

   Lambda表达式通常与函数式接口（只包含一个抽象方法的接口）一起使用，用于实现接口的抽象方法。

   interface MathOperation {
       int operate(int a, int b);
   }
   
   MathOperation addition = (a, b) -> a + b;
   MathOperation subtraction = (a, b) -> a - b;

3. 集合操作与Lambda：

   Lambda表达式可用于集合操作，如映射、过滤和排序。

   List<String> names = List.of("Alice", "Bob", "Charlie");
   
   // 映射：将名字转为大写
   List<String> upperCaseNames = names.stream()
       .map(name -> name.toUpperCase())
       .collect(Collectors.toList());
   
   // 过滤：筛选出长度大于等于5的名字
   List<String> filteredNames = names.stream()
       .filter(name -> name.length() >= 5)
       .collect(Collectors.toList());
   
   // 排序：按字母顺序排序
   List<String> sortedNames = names.stream()
       .sorted((a, b) -> a.compareTo(b))
       .collect(Collectors.toList());

4. 方法引用与Lambda：

   方法引用是Lambda表达式的一种简化形式，可用于调用已存在的方法。

   List<String> names = List.of("Alice", "Bob", "Charlie");
   
   // 使用方法引用将名字转为大写
   List<String> upperCaseNames = names.stream()
       .map(String::toUpperCase)
       .collect(Collectors.toList());

5. 函数式接口与Lambda：

   Java 8引入了java.util.function包，其中包含了一些常用的函数式接口，如Consumer、Supplier、Predicate等。

   import java.util.function.Consumer;
   
   Consumer<String> printer = message -> System.out.println(message);

6. Lambda与多行代码：

   Lambda表达式也可以包含多行代码，需要使用花括号 {} 包裹代码块，并使用 return 来指定返回值。

   interface Printer {
       void print(String message);
   }
   
   Printer printer = message -> {
       System.out.println("Printing message: " + message);
       System.out.println("Done printing.");
   };

Lambda表达式在Java 8及以后的版本中广泛应用于函数式编程、集合操作和各种需要传递函数作为参数的情况。使用Lambda表达式能够让代码更为简洁，提高代码的可读性和维护性。但也要注意在适当的场景使用，以免过度使用导致代码变得难以理解。

• map集合按照key或者value大小排序输出

  要按照Map中的值（Value）进行排序并输出，你可以使用Java中的Stream API 来实现。下面是一个示例，展示如何按照Map中的值进行排序输出：

  假设有一个Map如下：

  Map<String, Integer> map = new HashMap<>();
  map.put("Alice", 25);
  map.put("Bob", 30);
  map.put("Charlie", 22);

  现在我们将按照值从小到大排序，并输出排序后的结果：

  import java.util.*;
  import java.util.stream.Collectors;
  
  public class MapValueSort {
      public static void main(String[] args) {
          Map<String, Integer> map = new HashMap<>();
          map.put("Alice", 25);
          map.put("Bob", 30);
          map.put("Charlie", 22);
  
          // 使用Stream API按照值排序并输出
          map.entrySet().stream()
              .sorted(Map.Entry.comparingByValue())  // 按照值排序
              .forEach(entry -> System.out.println(entry.getKey() + ": " + entry.getValue()));
      }
  }

  在上面的代码中，我们使用map.entrySet().stream()来获取Map中每个键值对的Stream。然后，我们使用sorted()方法并传入Map.Entry.comparingByValue()作为比较器来按照值进行排序。最后，使用forEach()方法遍历排序后的键值对并输出。

  如果你想要逆序（从大到小）排序，可以在sorted()方法中使用Comparator.reverseOrder()：

  map.entrySet().stream()
      .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))  // 逆序排序
      .forEach(entry -> System.out.println(entry.getKey() + ": " + entry.getValue()));

  就可以根据Map的值进行排序并输出结果了。

• 排序

  

• flatMap扁平化操作

  flatMap 是 Java 中 Stream API 中的一个中间操作，它用于将流的元素进行映射后，再将映射结果扁平化为一个新的流。在其他语言中也有类似的概念，例如函数式编程中的 flatMap。

  通常情况下，map 操作用于对流中的每个元素执行一个映射操作，而 flatMap 则允许你在映射操作的基础上进一步展开（扁平化）嵌套的流结构。

  flatMap 的常见用法之一是用于处理嵌套的集合结构，例如一个列表中包含了多个子列表，而你希望将所有子列表的元素合并为一个扁平化的流。

  以下是 flatMap 方法的示例用法：

  List<List<Integer>> nestedList = Arrays.asList(
      Arrays.asList(1, 2, 3),
      Arrays.asList(4, 5, 6),
      Arrays.asList(7, 8, 9)
  );
  
  List<Integer> flattenedList = nestedList.stream()
      .flatMap(List::stream)  // 扁平化操作
      .collect(Collectors.toList());
  
  // flattenedList 包含 [1, 2, 3, 4, 5, 6, 7, 8, 9]

  在这个示例中，flatMap 方法将嵌套的列表结构转换为一个扁平化的流，其中的元素为所有子列表中的元素。

  另一个常见的用例是将一个流中的元素进行分割后，再扁平化为一个新的流。例如，可以将一个字符串流拆分为单词流，然后使用 flatMap 扁平化这些单词为一个流。

  总之，flatMap 是 Stream API 中的一个强大操作，能够在映射操作的基础上展开嵌套的结构，从而创建更灵活的流处理管道。

  • peek()方法

    在 Java 的 Stream API 中，peek 是一个中间操作（Intermediate Operation），用于对流中的元素执行某些操作，而不会改变流的内容。它接受一个函数作为参数，这个函数会在每个流元素上执行，但是不会改变元素本身，也不会产生新的流。

    peek 方法通常用于调试、观察流的处理过程，以及执行一些对流元素的副作用操作，例如打印元素内容、记录日志、验证数据等。它不会改变流的内容，而是返回一个与原始流相同的新流。

    以下是 peek 方法的示例用法：

    List<String> words = Arrays.asList("apple", "banana", "orange", "grape");
    
    List<String> upperCaseWords = words.stream()
        .map(String::toUpperCase)
        .peek(System.out::println)  // 打印大写字母的单词
        .collect(Collectors.toList());
    
    // 输出：
    // APPLE
    // BANANA
    // ORANGE
    // GRAPE

    在这个示例中，peek 方法被用来在 map 操作后打印大写字母的单词，但是它并不会改变流的元素或产生新的流。这对于调试和观察流的处理过程非常有用，能够帮助开发者了解流的中间状态。注意，peek 的使用应该仅用于观察和调试，而不应该用来执行对流的实际修改。

• :: 作用，ArrayList::new,new 一个ArrayList，等于调用Arraylist的构造函数