public record Order (String orderId, String userId, Double amount, LocalDateTime createAt, String status) { }

package com.water.base.lambda; import java.time.LocalDateTime; import java.util.*; import java.util.function.Predicate; import java.util.stream.Collectors; import java.util.stream.Stream; import static java.util.Map.Entry.comparingByValue; public class OrderService { private final List<Order> orders = List.of( new Order ( "001" , "userA" , 12.8 , LocalDateTime.now().minusDays( 7 ), "PAID" ), new Order ( "002" , "userB" , 22.8 , LocalDateTime.now().minusDays( 14 ), "PAID" ), new Order ( "003" , "userA" , 16.97 , LocalDateTime.now().minusDays( 6 ), "PENDING" ), new Order ( "004" , "userC" , 19.81 , LocalDateTime.now().minusDays( 1 ), "PAID" ), new Order ( "005" , "userC" , 32.18 , LocalDateTime.now().minusDays( 12 ), "PAID" ), new Order ( "006" , "userB" , 42.12 , LocalDateTime.now().minusDays( 5 ), "PAID" ) ); // 1、获取已支付订单列表 public List<Order> getOrdersOnPaid () { return orders .stream() .filter(item -> "PAID" .equals(item.status())) .toList(); } // 2、统计每个用户的订单数量，降序排列 public Map<String, Long> countUserOrderNum () { return getOrdersOnPaid() .stream() .filter(o -> o.userId() != null ) .collect(Collectors.groupingBy( Order::userId, TreeMap:: new , Collectors.counting())) .entrySet() .stream() .sorted(Map.Entry.<String, Long>comparingByValue().reversed()) .collect(Collectors.toMap( Map.Entry<String, Long>::getKey, Map.Entry<String, Long>::getValue, (oldVal, newVal) -> oldVal, LinkedHashMap:: new )); } // 3、按用户分组计算订单总金额 public Map<String, Double> getUserTotalAmountMap () { return getOrdersOnPaid() .stream() .collect(Collectors.groupingBy(Order::userId, Collectors.summingDouble(Order::amount))); } // 4、获取近七天内的订单 public List<Order> listIn7Days () { LocalDateTime sevenDaysAgo = LocalDateTime.now().minusDays( 7 ); return getOrdersOnPaid() .stream() .filter(o -> o.createAt().isAfter(sevenDaysAgo)) .toList(); } // 5、计算每位用户的平均订单金额 public Map<String, Double> getAvgAmountForUserId () { return getOrdersOnPaid() .stream() .collect(Collectors.groupingBy(Order::userId, Collectors.averagingDouble(Order::amount))); } // 6、计算每位用户的最高金额订单 public Map<String, Double> getMaxAmountForUser () { return getOrdersOnPaid() .stream() .collect(Collectors.groupingBy(Order::userId, Collectors.maxBy(Comparator.comparingDouble(Order::amount)) )) .entrySet() .stream() .collect(Collectors.toMap( Map.Entry::getKey, e -> e.getValue().map(Order::amount).orElse( 0.0 ) )); } // 7、获取特殊userID public String getSpecUserId () { return getOrdersOnPaid() .stream() .skip( 2L ) // 跳过前两个 .peek(System.out::println) // 打印 .filter(t -> t.amount() > 40 ) .peek(System.out::println) // 看看过滤后有哪些订单 .map(Order::userId) .peek(u -> { System.out.println( "id: " + u); System.out.println( "下一个是什么？这里peek方法可用于调试流式中间操作，看看目前有什么元素" ); }) .sorted() .findFirst() .orElse( "defaultUser" ); } // 使用函数式接口构建组合查询条件 public List<Order> getOrderByCondition (OrderPredicate orderPredicate) { return orders .stream() .filter(orderPredicate::test) // 方法引用（对象引用实例方法），格式匹配，并不是调用方法test .toList(); } public List<Order> getOrderByCondition2 (Predicate<Order> orderPredicate) { return orders .stream() .filter(orderPredicate) // 就是该类型 Predicate<Order> .toList(); } }

package com.water.base.lambda; // 自定义函数式接口，订单过滤器 public interface OrderPredicate { boolean test (Order order) ; default OrderPredicate and (OrderPredicate and) { // 且 return o->test(o) && and.test(o); } default OrderPredicate or (OrderPredicate or) { // 或 return o -> test(o) || or.test(o); } default OrderPredicate not () { // 非 return o -> !test(o); } }

package com.water.base.lambda; import java.time.LocalDateTime; import java.util.Map; import java.util.function.Predicate; import java.util.stream.Stream; public class OrderTest { public static void main (String[] args) { OrderService orderService = new OrderService (); // 1、获取用户已支付订单列表 orderService.getOrdersOnPaid().forEach(System.out::println); // 2、统计每个用户的订单数量，降序 System.out.println( "用户ID： 数量" ); orderService.countUserOrderNum().forEach((k, v) -> System.out.println(k + ": " + v)); printLine(); // 3、按用户分组计算订单总金额 System.out.println( "用户ID： 订单总额（元）" ); orderService.getUserTotalAmountMap().forEach((k, v) -> System.out.println(k + ": " + v)); printLine(); // 4、获取最近7天内的订单 System.out.println( "七天内的订单列表：" ); System.out.println(orderService.listIn7Days()); printLine(); // 5、计算每位用户的平均订单金额 System.out.println( "用户ID： 订单均值（元）" ); orderService.getAvgAmountForUserId().forEach((k, v) -> System.out.println(k + ": " + v)); printLine(); // 6、 计算每位用户的最高订单金额 System.out.println( "用户ID： 订单金额（元）" ); orderService.getMaxAmountForUser().forEach((k, v) -> System.out.println(k + ": " + v)); printLine(); // 7、获取特殊userID System.out.println( "特殊userID：" + orderService.getSpecUserId()); printLine(); // 8、获取userId = userA或userB的，已支付订单 OrderPredicate c1 = o -> "PAID" .equals(o.status()) && ( "userA" .equals(o.userId()) || "userB" .equals(o.userId())); Predicate<Order> c2 = o -> "PAID" .equals(o.status()) && ( "userA" .equals(o.userId()) || "userB" .equals(o.userId())); System.out.println(orderService.getOrderByCondition(c1)); printLine(); System.out.println(orderService.getOrderByCondition2(c2)); printLine(); // 添加一个条件：订单金额大于20 OrderPredicate c3 = o -> o.amount() > 20 ; // 添加一个条件：订单金额小于40，引用外面静态变量c33 OrderPredicate c4 = c1.and(c3).or(c33).not(); // 等同理解 && || ！，布尔表达式 System.out.println(orderService.getOrderByCondition(c4)); printLine(); } // 定义订单过滤器，本质是一个只有一个抽象接口的实现，匿名内部类-》匿名对象-》lambda化 static OrderPredicate c33 = o -> o.amount() < 40 ; // 定义订单过滤器，lambda化-》方法引用（复用已有方法） static OrderPredicate c44 = OrderTest::over50; public static boolean over50 (Order order) { return order != null && order.amount() > 50 ; } public static void printLine () { System.out.println( "==============================================================================" ); } }

Order[orderId= 001 , userId=userA, amount= 12.8 , createAt= 2025 - 07 -12T18: 43 : 57.361465200 , status=PAID] Order[orderId= 002 , userId=userB, amount= 22.8 , createAt= 2025 - 07 -05T18: 43 : 57.361465200 , status=PAID] Order[orderId= 004 , userId=userC, amount= 19.81 , createAt= 2025 - 07 -18T18: 43 : 57.361465200 , status=PAID] Order[orderId= 005 , userId=userC, amount= 32.18 , createAt= 2025 - 07 -07T18: 43 : 57.361465200 , status=PAID] Order[orderId= 006 , userId=userB, amount= 42.12 , createAt= 2025 - 07 -14T18: 43 : 57.361465200 , status=PAID] 用户ID： 数量 userB: 2 userC: 2 userA: 1 ============================================================================== 用户ID： 订单总额（元） userA: 12.8 userB: 64.91999999999999 userC: 51.99 ============================================================================== 七天内的订单列表： [Order[orderId= 004 , userId=userC, amount= 19.81 , createAt= 2025 - 07 -18T18: 43 : 57.361465200 , status=PAID], Order[orderId= 006 , userId=userB, amount= 42.12 , createAt= 2025 - 07 -14T18: 43 : 57.361465200 , status=PAID]] ============================================================================== 用户ID： 订单均值（元） userA: 12.8 userB: 32.459999999999994 userC: 25.995 ============================================================================== 用户ID： 订单金额（元） userA: 12.8 userB: 42.12 userC: 32.18 ============================================================================== Order[orderId= 004 , userId=userC, amount= 19.81 , createAt= 2025 - 07 -18T18: 43 : 57.361465200 , status=PAID] Order[orderId= 005 , userId=userC, amount= 32.18 , createAt= 2025 - 07 -07T18: 43 : 57.361465200 , status=PAID] Order[orderId= 006 , userId=userB, amount= 42.12 , createAt= 2025 - 07 -14T18: 43 : 57.361465200 , status=PAID] Order[orderId= 006 , userId=userB, amount= 42.12 , createAt= 2025 - 07 -14T18: 43 : 57.361465200 , status=PAID] id: userB 下一个是什么？这里peek方法可用于调试流式中间操作，看看目前有什么元素 特殊userID：userB ============================================================================== [Order[orderId= 001 , userId=userA, amount= 12.8 , createAt= 2025 - 07 -12T18: 43 : 57.361465200 , status=PAID], Order[orderId= 002 , userId=userB, amount= 22.8 , createAt= 2025 - 07 -05T18: 43 : 57.361465200 , status=PAID], Order[orderId= 006 , userId=userB, amount= 42.12 , createAt= 2025 - 07 -14T18: 43 : 57.361465200 , status=PAID]] ============================================================================== [Order[orderId= 001 , userId=userA, amount= 12.8 , createAt= 2025 - 07 -12T18: 43 : 57.361465200 , status=PAID], Order[orderId= 002 , userId=userB, amount= 22.8 , createAt= 2025 - 07 -05T18: 43 : 57.361465200 , status=PAID], Order[orderId= 006 , userId=userB, amount= 42.12 , createAt= 2025 - 07 -14T18: 43 : 57.361465200 , status=PAID]] ============================================================================== [] ==============================================================================

public class Student { // 状态（属性值）只有行为（方法）才能改变 private int stuNo; priavte String name; private int countSetInvokeName; private static int num = 1 ; public static int nextNo () { // 每调用一次，num+1，改变了num属性，状态发生变化 return num++; } public void setName () { // 该方法就是专门用来改变对象状态的，setXX，而且是改变两个属性值 this .name = name; countSetInvokeName++; } public String getName () { // 该方法只是一个获取属性信息，没有改变对象的状态，无状态 return name; } }

public class Student { private String name; private int age; public String getName () { return name; } public void setName (String name) { this .name = name; } public int getAge () { return age; } public void setAge ( int age) { this .age = age; } @Override public String toString () { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}' ; }

public class LambdaTest2 { public static void main (String[] args) { // 1、基础数据类型，如：int、byte、short、long这些，若要背包，建议添加final显式修饰，避免后续更改值报错 int a = 100 ; final int b = 10 ; // final 修饰，不变性，才能进入到lambda方法体内，不变才能成为规则的一部分 int result = getResult(a,()->{ System.out.println( "从外面带过来的变量值：" +b); return 99 *b; }); //        b = 21; // b若没final修饰，则可以任意改变，那么此时lambda里面的b也会改变，所以是不允许的 System.out.println( "结果：" +result); // 2、对象的地址值，不改变即可，对象属性可以改变 final Student student = new Student (); // final可以显式修饰避免修改引用值，如果省略，需要保证隐式final（也就是不再将student指向其他对象地址值） student.setName( "water" ); student.setAge( 18 ); System.out.println( "学生A初始信息：" +student.getName()+ ", " +student.getAge()); System.out.println( "=============" ); //        student = new Student(); // 不可以再次改变student变量的引用地址值， int result2 = getResult(student.getAge(),()->{ System.out.println( "学生A进来了：" +student.getName()+ ", " +student.getAge()); student.setName( "Bob" ); student.setAge( 20 ); System.out.println( "学生A信息（状态）变更：" +student.getName()+ ", " +student.getAge()); return student.getAge(); }); System.out.println( "结果2：" +result2); System.out.println( "现在学生A的信息：" +student.getName()+ ", " +student.getAge()); } public static int getResult ( int num, Supplier<Integer> randomNumFactory) { return randomNumFactory == null ? num : num + randomNumFactory.get(); } } }

从外面带过来的变量值： 10 结果： 1090 学生A初始信息：water, 18 ============= 学生A进来了：water, 18 学生A信息（状态）变更：Bob, 20 结果 2 ： 38 现在学生A的信息：Bob, 20

package java.util.function; import java.util.Objects; /** * Represents an operation that accepts a single input argument and returns no * result. Unlike most other functional interfaces, { @code Consumer} is expected * to operate via side-effects. * * <p>This is a <a href="package-summary.html">functional interface</a> * whose functional method is { @link #accept(Object)}. * * @param <T> the type of the input to the operation * * @since 1.8 */ @FunctionalInterface public interface Consumer <T> { /** * Performs this operation on the given argument. * * @param t the input argument */ void accept (T t) ; /** * Returns a composed { @code Consumer} that performs, in sequence, this * operation followed by the { @code after} operation. If performing either * operation throws an exception, it is relayed to the caller of the * composed operation.  If performing this operation throws an exception, * the { @code after} operation will not be performed. * * @param after the operation to perform after this operation * @return a composed { @code Consumer} that performs in sequence this * operation followed by the { @code after} operation * @throws NullPointerException if { @code after} is null */ default Consumer<T> andThen (Consumer<? super T> after) { // 一个接一个消费，可以搞任务执行链 Objects.requireNonNull(after); return (T t) -> { accept(t); after.accept(t); }; } }

public class FunctionInterfaceTest { public static void main (String[] args) { // 体会消费接口行为参数化，行为在方法体内执行，实参传递方式，分为外面和里面 test_consume( "appleCake" , // 外面入参 new BigDecimal ( "20" ), // 外面入参 list -> { // 自定义消费者实现 System.out.println( "一共去了" + list.size() + "个地方玩！" ); StringJoiner joiner = new StringJoiner ( "," , "*****" , "*****" ); list.forEach(joiner::add); System.out.println( "这些地方如下：" + joiner); }, List.of( "Beijing" , "Guangzhou" , "Shenzhen" , "Shanghai" ) // 提供给上述消费者实现的实参 ); } private static void printLine () { System.out.println( "=============================================================" ); } // 添加final 修饰表示不可变，便于方法体内其他消费实现使用 public static void test_consume ( final String foodInput, final BigDecimal priceInput, Consumer<List<String>> haveFunWith, final List<String> places) { // case1：定义consume实现[吃东西] Consumer<String> eatFood = food -> { System.out.println( "give " + food + " some ice, please" ); System.out.println( "Tell you boy, I just ate something like " + food); }; // 调用 eatFood.accept(foodInput); printLine(); // case2：定义consumer实现【花多少钱】 Consumer<BigDecimal> howMuch = price -> { BigDecimal result = switch (foodInput) { // 使用背包，里面的不可变局部变量 case "apple" -> BigDecimal.ONE.multiply(price); case "applePile" -> BigDecimal.TWO.multiply(price); case "appleCake" -> BigDecimal.TEN.multiply(price); default -> price; }; System.out.println(foodInput + " cost me " + result + " $" ); }; // 调用 howMuch.accept(priceInput); printLine(); // case3：方法外定义Consumer实现【去了哪些地方玩】 Objects.requireNonNull(haveFunWith, "input can not be null" ); haveFunWith.accept(places); } }

give appleCake some ice, please Tell you boy, I just ate something like appleCake ============================================================= appleCake cost me 200 $ ============================================================= 一共去了 4 个地方玩！ 这些地方如下：*****Beijing,Guangzhou,Shenzhen,Shanghai*****

/** * Represents a supplier of results. * * <p>There is no requirement that a new or distinct result be returned each * time the supplier is invoked. * * <p>This is a <a href="package-summary.html">functional interface</a> * whose functional method is { @link #get()}. * * @param <T> the type of results supplied by this supplier * * @since 1.8 */ @FunctionalInterface public interface Supplier <T> { /** * Gets a result. * * @return a result */ T get () ; }

package com.water.base.lambda; import java.util.Arrays; import java.util.Random; import java.util.concurrent.TimeUnit; import java.util.function.Supplier; public class _02_SupplierTest { public static void main (String[] args) throws InterruptedException { // 打印随机名称 String[] names = { "Amy" , "John" }; System.out.println(getRandomName(names)); System.out.println(getRandomName( null )); printLine(); // 获取线程t1，执行打印任务 Thread t1 = newThread( "water_Thread" , () -> { System.out.println(Thread.currentThread().getName() + " print something..." ); System.out.println( "result: " + Arrays.toString(names)); }); // 获取线程t2，执行打印任务：每隔一秒打印一次 Thread t2 = newThread( null , () -> { int loop = 10 ; int count = 1 ; while (count <= loop) { try { TimeUnit.SECONDS.sleep( 1L ); } catch (InterruptedException e) { throw new RuntimeException (e); } System.out.println(Thread.currentThread().getName() + " print num: " + count); count++; } }); // 定义根据随机名称长度*100，获得多少钱 Supplier<Integer> moneyWithNameLenMultiple = ()->names[random.nextInt( 0 , names.length)].length() * 100 ; System.out.println( "获得多少钱：" +getWhatYouWant(moneyWithNameLenMultiple)); printLine(); // 定义任务生产者，打印加了多少钱 Supplier<Runnable> addMoneyTask = ()-> ()-> System.out.println(Thread.currentThread().getName()+ " 加了多少钱：" +names.length + 100 ); Thread t3 = newThread( "addMoney" , addMoneyTask.get()); // 编排线程执行顺序 System.out.println( "执行线程t2" ); t2.start(); t2.join(); printLine(); System.out.println( "执行线程t1" ); t1.start(); t1.join(); printLine(); System.out.println( "执行线程3" ); t3.start(); t3.join(); printLine(); System.out.println( "over ..." ); } static final Random random = new Random (); // 1、定义生产者【产生个随机名字】 public static String getRandomName (String[] input) { if (input == null ) { input = new String [] { "water" , "Bob" , "Mary" , "Mike" }; } final String[] names = input; Supplier<String> nameSupplier = ()-> names[random.nextInt( 0 ,names.length) % names.length]; return nameSupplier.get(); } // 2、定义生产者【提供新线程】 public static Thread newThread (String threadName, Runnable task) { if (threadName == null ) { threadName = System.currentTimeMillis()+ "_Thread" ; } final String finalName = threadName; Supplier<Thread> threadSupplier = ()-> new Thread (task,finalName); return threadSupplier.get(); } // 3、自定义生产者，总是返回调用者期待的 public static <T> T getWhatYouWant (Supplier<T> supplier) { return supplier.get(); } private static void printLine () { System.out.println( "=====================================================" ); } }

Amy water ===================================================== 获得多少钱： 400 ===================================================== 执行线程t2 1752983593563_Thread print num: 1 1752983593563_Thread print num: 2 1752983593563_Thread print num: 3 1752983593563_Thread print num: 4 1752983593563_Thread print num: 5 1752983593563_Thread print num: 6 1752983593563_Thread print num: 7 1752983593563_Thread print num: 8 1752983593563_Thread print num: 9 1752983593563_Thread print num: 10 ===================================================== 执行线程t1 water_Thread print something... result: [Amy, John] ===================================================== 执行线程 3 addMoney 加了多少钱： 2100 ===================================================== over ...

package java.util.function; import java.util.Objects; /** * Represents a predicate (boolean-valued function) of one argument. * * <p>This is a <a href="package-summary.html">functional interface</a> * whose functional method is { @link #test(Object)}. * * @param <T> the type of the input to the predicate * * @since 1.8 */ @FunctionalInterface public interface Predicate <T> { /** * Evaluates this predicate on the given argument. * * @param t the input argument * @return { @code true} if the input argument matches the predicate, * otherwise { @code false} */ boolean test (T t) ; /** * Returns a composed predicate that represents a short-circuiting logical * AND of this predicate and another.  When evaluating the composed * predicate, if this predicate is { @code false}, then the { @code other} * predicate is not evaluated. * * <p>Any exceptions thrown during evaluation of either predicate are relayed * to the caller; if evaluation of this predicate throws an exception, the * { @code other} predicate will not be evaluated. * * @param other a predicate that will be logically-ANDed with this *              predicate * @return a composed predicate that represents the short-circuiting logical * AND of this predicate and the { @code other} predicate * @throws NullPointerException if other is null */ default Predicate<T> and (Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) && other.test(t); } /** * Returns a predicate that represents the logical negation of this * predicate. * * @return a predicate that represents the logical negation of this * predicate */ default Predicate<T> negate () { return (t) -> !test(t); } /** * Returns a composed predicate that represents a short-circuiting logical * OR of this predicate and another.  When evaluating the composed * predicate, if this predicate is { @code true}, then the { @code other} * predicate is not evaluated. * * <p>Any exceptions thrown during evaluation of either predicate are relayed * to the caller; if evaluation of this predicate throws an exception, the * { @code other} predicate will not be evaluated. * * @param other a predicate that will be logically-ORed with this *              predicate * @return a composed predicate that represents the short-circuiting logical * OR of this predicate and the { @code other} predicate * @throws NullPointerException if other is null */ default Predicate<T> or (Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); } /** * Returns a predicate that tests if two arguments are equal according * to { @link Objects#equals(Object, Object)}. * * @param <T> the type of arguments to the predicate * @param targetRef the object reference with which to compare for equality, *               which may be { @code null} * @return a predicate that tests if two arguments are equal according * to { @link Objects#equals(Object, Object)} */ static <T> Predicate<T> isEqual (Object targetRef) { return ( null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); } /** * Returns a predicate that is the negation of the supplied predicate. * This is accomplished by returning result of the calling * { @code target.negate()}. * * @param <T>     the type of arguments to the specified predicate * @param target  predicate to negate * * @return a predicate that negates the results of the supplied *         predicate * * @throws NullPointerException if target is null * * @since 11 */ @SuppressWarnings("unchecked") static <T> Predicate<T> not (Predicate<? super T> target) { Objects.requireNonNull(target); return (Predicate<T>)target.negate(); } }

package com.water.base.lambda; import java.time.LocalDateTime; import java.util.List; import java.util.function.Predicate; /** * 断言，过滤器 * 场景：员工表，根据各种条件过滤员工信息 */ public class _03_PredicateTest { private static final LocalDateTime now = LocalDateTime.now(); private static final List<Person> PERSON_LIST = List.of( new Person ( "001" , "p1" ,Status.WORK.name(),now.minusDays( 7 )), new Person ( "002" , "p2" ,Status.LEAVE.name(),now.minusDays( 5 )), new Person ( "003" , "p3" ,Status.WORK.name(),now.minusDays( 5 )), new Person ( "004" , "p4" ,Status.LEAVE.name(),now.minusDays( 2 )), new Person ( "005" , "p5" ,Status.LEAVE.name(),now.minusDays( 5 )) ); enum Status { WORK, // 在职 LEAVE // 离职 } public static void main (String[] args) { // 1、查询全部在职员工 System.out.println(getByCondition(p-> Status.WORK.name().equals(p.status()))); printLine(); // 2、查询2天前入职的员工 System.out.println(getByCondition(p->p.join().isBefore(LocalDateTime.now().minusDays( 2 )))); printLine(); // 3、最近3天入职，但现在已离职的员工 Predicate<Person> c1 = p->p.join().isAfter(LocalDateTime.now().minusDays( 3 )); Predicate<Person> c2 = p->Status.LEAVE.name().equals(p.status()); System.out.println(getByCondition(c1.and(c2))); } private static void printLine () { System.out.println( "=====================================================" ); } public static List<Person> getByCondition (Predicate<Person> condition) { return PERSON_LIST .stream() .filter(condition) .toList(); } } record Person (String id, String name, String status, LocalDateTime join) {}

[Person[id= 001 , name=p1, status=WORK, join= 2025 - 07 -13T17: 05 : 44.181833600 ], Person[id= 003 , name=p3, status=WORK, join= 2025 - 07 -15T17: 05 : 44.181833600 ]] ===================================================== [Person[id= 001 , name=p1, status=WORK, join= 2025 - 07 -13T17: 05 : 44.181833600 ], Person[id= 002 , name=p2, status=LEAVE, join= 2025 - 07 -15T17: 05 : 44.181833600 ], Person[id= 003 , name=p3, status=WORK, join= 2025 - 07 -15T17: 05 : 44.181833600 ], Person[id= 004 , name=p4, status=LEAVE, join= 2025 - 07 -18T17: 05 : 44.181833600 ], Person[id= 005 , name=p5, status=LEAVE, join= 2025 - 07 -15T17: 05 : 44.181833600 ]] ===================================================== [Person[id= 004 , name=p4, status=LEAVE, join= 2025 - 07 -18T17: 05 : 44.181833600 ]]

package java.util.function; import java.util.Objects; /** * Represents a function that accepts one argument and produces a result. * * <p>This is a <a href="package-summary.html">functional interface</a> * whose functional method is { @link #apply(Object)}. * * @param <T> the type of the input to the function * @param <R> the type of the result of the function * * @since 1.8 */ @FunctionalInterface public interface Function <T, R> { /** * Applies this function to the given argument. * * @param t the function argument * @return the function result */ R apply (T t) ; /** * Returns a composed function that first applies the { @code before} * function to its input, and then applies this function to the result. * If evaluation of either function throws an exception, it is relayed to * the caller of the composed function. * * @param <V> the type of input to the { @code before} function, and to the *           composed function * @param before the function to apply before this function is applied * @return a composed function that first applies the { @code before} * function and then applies this function * @throws NullPointerException if before is null * * @see #andThen(Function) */ default <V> Function<V, R> compose (Function<? super V, ? extends T> before) { Objects.requireNonNull(before); return (V v) -> apply(before.apply(v)); } /** * Returns a composed function that first applies this function to * its input, and then applies the { @code after} function to the result. * If evaluation of either function throws an exception, it is relayed to * the caller of the composed function. * * @param <V> the type of output of the { @code after} function, and of the *           composed function * @param after the function to apply after this function is applied * @return a composed function that first applies this function and then * applies the { @code after} function * @throws NullPointerException if after is null * * @see #compose(Function) */ default <V> Function<T, V> andThen (Function<? super R, ? extends V> after) { Objects.requireNonNull(after); return (T t) -> after.apply(apply(t)); } /** * Returns a function that always returns its input argument. * * @param <T> the type of the input and output objects to the function * @return a function that always returns its input argument */ static <T> Function<T, T> identity () { return t -> t; } }

package com.water.base.lambda; import java.math.BigDecimal; import java.util.*; import java.util.function.Function; import java.util.stream.Collectors; /** * 映射器、转换器、计算器 * 场景：商品处理 */ public class _04_FunctionTest { private static final List<Goods> GOODS_LIST = List.of( new Goods ( "G001" , "牛奶" , new BigDecimal ( "4.5" ), 200 , "盒" ,GoodsStatus.UP.name()), new Goods ( "G002" , "旺旺饼干" , new BigDecimal ( "8.5" ), 100 , "包" ,GoodsStatus.DOWN.name()), new Goods ( "G003" , "冰红茶" , new BigDecimal ( "3.5" ), 150 , "瓶" ,GoodsStatus.UP.name()), new Goods ( "G004" , "巧克力" , new BigDecimal ( "5.0" ), 10 , "块" ,GoodsStatus.DOWN.name()), new Goods ( "G005" , "棒棒糖" , new BigDecimal ( "0.5" ), 250 , "个" ,GoodsStatus.UP.name()) ); enum GoodsStatus { UP, // 上架 DOWN // 下架 } public static void main (String[] args) { // 1、获取所有商品价格 System.out.println( "商品价格列表：" ); System.out.println(func(Goods::price)); printLine(); // 2、获取所有商品信息列表，如：牛奶-15元/件-剩余80件 System.out.println( "商品信息：" ); System.out.println(func(g-> String.format( "%s-%.2f元/%s-库存剩余%d%s" , g.name(),g.price().doubleValue(),g.unit(),g.num(),g.unit()))); printLine(); // 3、获取商品下拉列表map System.out.println( "ID： 名称" ); getGoodsNameMap().forEach((k,v)-> System.out.println(k+ ": " +v)); printLine(); // 4、获取所有下架商品 System.out.println( "所有下架商品：" ); GOODS_LIST.stream().filter(g->GoodsStatus.DOWN.name().equals(g.status())) .map(Goods::name) .forEachOrdered(System.out::println); } private static void printLine () { System.out.println( "====================================================" ); } public static Map<String,String> getGoodsNameMap () { return GOODS_LIST .stream() .collect(Collectors.toMap(Goods::id,Goods::name)); } public static <T> List<T> func (Function<Goods,T> handler) { return GOODS_LIST .stream() .map(handler) .toList(); } } record Goods (String id, String name, BigDecimal price, Integer num,String unit, String status) {}

商品价格列表： [ 4.5 , 8.5 , 3.5 , 5.0 , 0.5 ] ==================================================== 商品信息： [牛奶- 4.50 元/盒-库存剩余 200 盒, 旺旺饼干- 8.50 元/包-库存剩余 100 包, 冰红茶- 3.50 元/瓶-库存剩余 150 瓶, 巧克力- 5.00 元/块-库存剩余 10 块, 棒棒糖- 0.50 元/个-库存剩余 250 个] ==================================================== ID： 名称 G002: 旺旺饼干 G001: 牛奶 G004: 巧克力 G003: 冰红茶 G005: 棒棒糖 ==================================================== 所有下架商品： 旺旺饼干 巧克力

package com.water.base.lambda; import java.util.Objects; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; public class RefTest { // 对象内属性：姓名 private String name; // 无参构造 public RefTest () {} // 有参构造 public RefTest (String name) { this .name = name; } public void setName (String name) { this .name = name; // 在实例方法中引用其他实例方法，this Supplier<Integer> lenSupplier = this ::nameLength; System.out.println( "名称长度：" +lenSupplier.get()); } // 实例方法：获取姓名的长度 public Integer nameLength () { Objects.requireNonNull(name, "name is null" ); Function<RefTest,Integer> lenSupplier = RefTest::count; System.out.println( "静态方法count引用，名称长度是多少：" +lenSupplier.apply( this )); return this .name.length(); } // 实例方法：姓名长度是否超过5 public boolean isNameLengthOver5 () { Predicate<RefTest> judge = RefTest::judgeOver5; System.out.println( "静态方法JudgeOver5引用，名称长度是否大于5：" +judge.test( this )); return this .name != null && this .name.length() > 5 ; } @Override public String toString () { // 在实例方法中引用父类实例方法，super Supplier<String> superObjIndex = super ::toString; System.out.println( "地址：" +superObjIndex.get()); return name != null ? name : "defaultName" ; } public static RefTest of () { return new RefTest (); } // 静态方法：统计内容长度 public static Integer count (RefTest content) { return content == null ? 0 : (content.name == null ? 0 : content.name.length()); } // 静态方法：判断内容超过5 public static boolean judgeOver5 (RefTest content) { return content != null && content.name != null &&  content.name.length() > 5 ; } public static void main (String[] args) { // 定义生产者 Supplier<RefTest> s1 = ()-> new RefTest (); Supplier<RefTest> s2 = ()-> new RefTest ( "water" ); Supplier<RefTest> s3 = RefTest:: new ; Supplier<RefTest> s4 = RefTest::of; // 使用生产者 RefTest r1 = s1.get(); RefTest r2 = s2.get(); RefTest r3 = s3.get(); RefTest r4 = s4.get(); System.out.println( "r1:" +r1); System.out.println( "r2:" +r2); System.out.println( "r3:" +r3); System.out.println( "r4:" +r4); printLine(); // 2、定义消费者 Consumer<RefTest> c1 = t -> t.setName( "Kobe Brand" ); // 使用 c1.accept(r1); System.out.println( "r1被消费后：" +r1); printLine(); // 3、定义断言 Predicate<RefTest> p1 = p->p.name.length() > 5 ; Predicate<RefTest> p2 = RefTest::isNameLengthOver5; Predicate<RefTest> p3 = RefTest::judgeOver5; // 使用 System.out.println( "p1: " +p1.test(r1)); System.out.println( "p2: " +p2.test(r2)); System.out.println( "p3: " +p3.test(r3)); printLine(); // 4、定义转换、计算器 Function<RefTest,Integer> f1 = rt -> rt.name.length(); Function<RefTest,Integer> f2 = RefTest::nameLength; Function<RefTest,Integer> f3 = RefTest::count; // 使用 System.out.println( "f1: " +f1.apply(r1)); System.out.println( "f2: " +f2.apply(r2)); System.out.println( "f3: " +f3.apply(r3)); } private static void printLine () { System.out.println( "================================================" ); } }

地址：com.water.base.lambda.RefTest@39ed3c8d r1:defaultName 地址：com.water.base.lambda.RefTest@71dac704 r2:water 地址：com.water.base.lambda.RefTest@123772c4 r3:defaultName 地址：com.water.base.lambda.RefTest@2d363fb3 r4:defaultName ================================================ 静态方法count引用，名称长度是多少： 10 名称长度： 10 地址：com.water.base.lambda.RefTest@39ed3c8d r1被消费后：Kobe Brand ================================================ p1: true 静态方法JudgeOver5引用，名称长度是否大于 5 ： false p2: false p3: false ================================================ f1: 10 静态方法count引用，名称长度是多少： 5 f2: 5 f3: 0

package com.water.base.lambda; import java.util.function.Function; import java.util.function.Predicate; /** * 知识点：参数行为化 * 1、参数类型为函数接口 * 2、使用匿名内部类方式 * 3、使用lambda表达式 * 4、使用方法引用 */ public class LambdaAsParamTest { public static void main (String[] args) { // 1、常规参数 invoke( "driver" , new Father (), new DefaultCallback ()); printLine(); // 2、匿名内部类：重写父类方法、实现接口，匿名对象参数 invoke( "doctor" , new Father () { @Override public boolean isGood (String job) { System.out.println( "覆盖父类方法" ); return job != null && job.startsWith( "c" ); // cook } }, new Callback () { @Override public void onSuccess () { System.out.println( "执行成功" ); } @Override public void onFail () { System.out.println( "执行失败" ); } }); printLine(); // 3、函数式接口，lambda表达式，方法引用，参数行为化 final String task = "calOrderAmount" ; call(task, t -> t.toLowerCase().contains( "order" ), LambdaAsParamTest::cal, () -> { System.out.println( "任务操作成功：" + task); System.out.println( "触发配送业务" ); }, () -> { System.out.println( "操作异常" ); System.out.println( "发送短信提醒：" + task + " 执行失败，请查看日志" ); } ); } // 匹配：Function<String,Boolean>，可以使用方法引用 LambdaAsParamTest::cal public static boolean cal (String task) { return task != null && task.length() > 3 ; } private static void printLine () { System.out.println( "====================================================" ); } public static void invoke (String job, Father father, Callback callback) { if (father.isGood(job)) { callback.onSuccess(); } else { callback.onFail(); } } public static void call (String task, Predicate<String> check, Function<String, Boolean> invoke, SuccessCallback success, FailCallback fail) { if (check.test(task)) { Boolean result = invoke.apply(task); if (result) { success.onSuccess(); } else { fail.onFail(); } } else { fail.onFail(); } } } class Father { public boolean isGood (String job) { System.out.println( "I am father" ); return job != null && job.length() > 5 ; } } interface Callback { void onSuccess () ; void onFail () ; } class DefaultCallback implements Callback { @Override public void onSuccess () { System.out.println( "success" ); } @Override public void onFail () { System.out.println( "fail" ); } } @FunctionalInterface interface SuccessCallback { void onSuccess () ; } @FunctionalInterface interface FailCallback { void onFail () ; }

I am father success ==================================================== 覆盖父类方法 执行失败 ==================================================== 任务操作成功：calOrderAmount 触发配送业务

public class StreamTest { public static void main (String[] args) { List<String> list = new ArrayList <>(); // ... Stream<String> stream1 = list.stream(); Set<String> set = new HashSet <>(); // ... Stream<String> stream2 = set.stream(); Vector<String> vector = new Vector <>(); // ... Stream<String> stream3 = vector.stream(); } }

public class StreamTest { public static void main (String[] args) { Map<String, String> map = new HashMap <>(); // ... Stream<String> keyStream = map.keySet().stream(); Stream<String> valueStream = map.values().stream(); Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream(); } }

public class StreamTest { public static void main (String[] args) { String[] array = { "water" , "Mike" , "Bob" , "Mary" }; Stream<String> stream = Stream.of(array); } }

public Map<String, Long> countUserOrderNum () { return getOrdersOnPaid() .stream() .filter(o -> o.userId() != null ) .collect(Collectors.groupingBy( Order::userId, TreeMap:: new , Collectors.counting())) .entrySet() .stream() .sorted(Map.Entry.<String, Long>comparingByValue().reversed()) .collect(Collectors.toMap( Map.Entry<String, Long>::getKey, Map.Entry<String, Long>::getValue, (oldVal, newVal) -> oldVal, LinkedHashMap:: new )); }

package com.water.base.lambda; import java.math.BigDecimal; import java.util.Comparator; import java.util.List; import java.util.stream.Collectors; /** * 常用Stream-API */ public class StreamAPITest { private static final List<ConsumeOrder> ORDER_LIST = List.of( new ConsumeOrder ( 1L , "C001" , new BigDecimal ( "20" ), "张三" ,OrderStatus.PAID.name(),List.of( new ConsumeOrderItem ( 1L , 1L , "炒时蔬" , new BigDecimal ( "2" ), 2 ), new ConsumeOrderItem ( 2L , 1L , "香菇炒肉" , new BigDecimal ( "3" ), 4 ), new ConsumeOrderItem ( 3L , 1L , "凉拌黄瓜" , new BigDecimal ( "1" ), 4 ) )), new ConsumeOrder ( 2L , "C002" , new BigDecimal ( "30" ), "李四" ,OrderStatus.RETURNED.name(),List.of( new ConsumeOrderItem ( 4L , 2L , "炖汤" , new BigDecimal ( "1" ), 10 ), new ConsumeOrderItem ( 5L , 2L , "牛扒" , new BigDecimal ( "5" ), 3 ), new ConsumeOrderItem ( 6L , 2L , "凉拌黄瓜" , new BigDecimal ( "1" ), 5 ) )), new ConsumeOrder ( 3L , "C003" , new BigDecimal ( "18" ), "赵五" ,OrderStatus.PAID.name(),List.of( new ConsumeOrderItem ( 7L , 3L , "炒时蔬" , new BigDecimal ( "2" ), 2 ), new ConsumeOrderItem ( 8L , 3L , "香菇炒肉" , new BigDecimal ( "3" ), 3 ), new ConsumeOrderItem ( 9L , 3L , "凉拌木耳" , new BigDecimal ( "2.5" ), 2 ) )) ); enum OrderStatus { CREATED, // 已创建 PENDING, // 进行中 PAID, // 已支付 RETURNED, // 已退款 CLOSED // 已关闭 } public static void main (String[] args) { // 1、【filter】过滤出已支付订单 System.out.println(ORDER_LIST.stream().filter(o->OrderStatus.PAID.name().equals(o.status())).toList()); printLine(); // 2、【map、flatMap、max】找出订单明细中单价最高的菜品 String name = ORDER_LIST.stream().flatMap(o -> o.items().stream()) .max(Comparator.comparing(ConsumeOrderItem::price)) .map(ConsumeOrderItem::dishName) .orElse( "一样" ); System.out.println( "单价最高菜品：" +name); printLine(); // 3、【collect，count，grouping，forEach】按订单状态分组并统计订单数 System.out.println( "状态： 数量" ); ORDER_LIST.stream().collect(Collectors.groupingBy(ConsumeOrder::status,Collectors.counting())) .forEach((k,v)-> System.out.println(k+ ": " +v)); printLine(); // 4、【reduce】统计订单总金额 BigDecimal sum = ORDER_LIST.stream().map(ConsumeOrder::totalAmount).reduce(BigDecimal.ZERO, BigDecimal::add); System.out.println( "订单总金额：" +sum); printLine(); // 5、【toSet】订单ID集合 System.out.println(ORDER_LIST.stream().map(ConsumeOrder::id).collect(Collectors.toSet())); printLine(); // 6、【distinct、toList】从订单明细中收集订单ID System.out.println(ORDER_LIST.stream().flatMap(o -> o.items().stream()) .map(ConsumeOrderItem::consumeId) .distinct() .toList()); } private static void printLine () { System.out.println( "======================================================================" ); } } record ConsumeOrder (Long id, String orderNo, BigDecimal totalAmount, String name, String status, List<ConsumeOrderItem> items) {} record ConsumeOrderItem (Long id,Long consumeId, String dishName, BigDecimal price, Integer num) {}

[ConsumeOrder[id= 1 , orderNo=C001, totalAmount= 20 , name=张三, status=PAID, items=[ConsumeOrderItem[id= 1 , consumeId= 1 , dishName=炒时蔬, price= 2 , num= 2 ], ConsumeOrderItem[id= 2 , consumeId= 1 , dishName=香菇炒肉, price= 3 , num= 4 ], ConsumeOrderItem[id= 3 , consumeId= 1 , dishName=凉拌黄瓜, price= 1 , num= 4 ]]], ConsumeOrder[id= 3 , orderNo=C003, totalAmount= 18 , name=赵五, status=PAID, items=[ConsumeOrderItem[id= 7 , consumeId= 3 , dishName=炒时蔬, price= 2 , num= 2 ], ConsumeOrderItem[id= 8 , consumeId= 3 , dishName=香菇炒肉, price= 3 , num= 3 ], ConsumeOrderItem[id= 9 , consumeId= 3 , dishName=凉拌木耳, price= 2.5 , num= 2 ]]]] ====================================================================== 单价最高菜品：牛扒 ====================================================================== 状态： 数量 RETURNED: 1 PAID: 2 ====================================================================== 订单总金额： 68 ====================================================================== [ 1 , 2 , 3 ] ====================================================================== [ 1 , 2 , 3 ]

/** * Returns a new { @code Collector} described by the given { @code supplier}, * { @code accumulator}, { @code combiner}, and { @code finisher} functions. * * @param supplier The supplier function for the new collector * @param accumulator The accumulator function for the new collector * @param combiner The combiner function for the new collector * @param finisher The finisher function for the new collector * @param characteristics The collector characteristics for the new *                        collector * @param <T> The type of input elements for the new collector * @param <A> The intermediate accumulation type of the new collector * @param <R> The final result type of the new collector * @throws NullPointerException if any argument is null * @return the new { @code Collector} */ public static <T, A, R> Collector<T, A, R> of (Supplier<A> supplier, BiConsumer<A, T> accumulator, BinaryOperator<A> combiner, Function<A, R> finisher, Characteristics... characteristics) { Objects.requireNonNull(supplier); Objects.requireNonNull(accumulator); Objects.requireNonNull(combiner); Objects.requireNonNull(finisher); Objects.requireNonNull(characteristics); Set<Characteristics> cs = Collectors.CH_NOID; if (characteristics.length > 0 ) { cs = EnumSet.noneOf(Characteristics.class); Collections.addAll(cs, characteristics); cs = Collections.unmodifiableSet(cs); } return new Collectors .CollectorImpl<>(supplier, accumulator, combiner, finisher, cs); }

Stream.of( 1 , 2 , 3 , 4 ) .parallel() .collect(Collector.of( () -> { System.out.printf( "%-12s %s%n" ,mark(), "create" ); return new ArrayList <Integer>(); }, (list, x) -> { List<Integer> old = new ArrayList <>(list); list.add(x); System.out.printf( "%-12s %s.add(%d)=>%s%n" ,mark(), old, x, list); }, (list1, list2) -> { List<Integer> old = new ArrayList <>(list1); list1.addAll(list2); System.out.printf( "%-12s %s.add(%s)=>%s%n" , mark(),old, list2, list1); return list1; }, list -> list, Collector.Characteristics.IDENTITY_FINISH )); private static String mark () { return "water" ; }

water        create water        [].add( 3 )=>[ 3 ] water        create water        [].add( 1 )=>[ 1 ] water        create water        [].add( 2 )=>[ 2 ] water        create water        [].add( 4 )=>[ 4 ] water        [ 3 ].add([ 4 ])=>[ 3 , 4 ] water        [ 1 ].add([ 2 ])=>[ 1 , 2 ] water        [ 1 , 2 ].add([ 3 , 4 ])=>[ 1 , 2 , 3 , 4 ]