Java 函数式编程

引言

Java 8 引入的 Lambda 表达式和函数式接口，让 Java 具备了函数式编程的能力。函数式编程不是要替代面向对象，而是提供了一种更简洁、更具表达力的编程范式，特别适合集合操作、事件处理和异步编程。

一、Lambda 表达式

1.1 语法

// 完整语法(Type1param1,Type2param2)->{expression;returnvalue;}// 简化规则// 1. 类型推断：参数类型可省略(a,b)->a+b// 2. 单参数：括号可省略name->System.out.println(name)// 3. 单表达式：花括号和 return 可省略(a,b)->a+b// 4. 多行语句：需要花括号和 return(a,b)->{intsum=a+b;returnsum;}

1.2 常见用法

// 替代匿名内部类// BeforeRunnabler1=newRunnable(){@Overridepublicvoidrun(){System.out.println("hello");}};// AfterRunnabler2=()->System.out.println("hello");// ComparatorComparator<String>c1=(a,b)->a.length()-b.length();// 自定义接口@FunctionalInterfaceinterfaceStringProcessor{Stringprocess(Stringinput);}StringProcessortoUpper=s->s.toUpperCase();

1.3 变量捕获

// Lambda 可以捕获 effectively final 的局部变量Stringprefix="Hello, ";// effectively finalFunction<String,String>greeter=name->prefix+name;greeter.apply("Alice");// "Hello, Alice"// Lambda 内部不能修改捕获的变量// prefix = "Hi, "; // 编译错误

二、函数式接口

2.1 @FunctionalInterface

// 函数式接口：只包含一个抽象方法的接口@FunctionalInterfacepublicinterfaceConverter<T,R>{Rconvert(Tinput);}// 默认方法和静态方法不影响@FunctionalInterfacepublicinterfaceSmartConverter<T,R>{Rconvert(Tinput);defaultRconvertOrDefault(Tinput,RdefaultValue){returninput==null?defaultValue:convert(input);}static<T>SmartConverter<T,T>identity(){returnt->t;}}

2.2 JDK 内置函数式接口

基本类型特化（避免装箱拆箱）：

IntSuppliersupplier=()->42;// int -> intIntFunction<String>func=i->"N"+i;// int -> StringIntPredicatepred=i->i>0;// int -> booleanIntConsumerconsumer=i->log(i);// int -> voidIntUnaryOperatorop=i->i*2;// int -> intIntBinaryOperatorbinOp=(a,b)->a+b;// int,int -> int

三、方法引用

3.1 四种形式

3.2 示例

// 1. 静态方法引用Function<String,Integer>parser=Integer::parseInt;// 2. 实例方法引用Stringprefix="Hello, ";Function<String,String>greeter=prefix::concat;// 3. 类型方法引用（最常用）Function<String,Integer>lengthFn=String::length;BiPredicate<String,String>equalsFn=String::equals;// 4. 构造器引用Supplier<List<String>>listFactory=ArrayList::new;Function<Integer,int[]>arrayFactory=int[]::new;

3.3 方法引用 vs Lambda

// 优先使用方法引用，更简洁list.forEach(System.out::println);// 方法引用list.forEach(s->System.out.println(s));// Lambda，稍冗长// 方法引用无法表达时使用 Lambdalist.stream().map(s->s+"!");// Lambda

四、函数组合

4.1 Function 组合

Function<String,String>trim=String::trim;Function<String,String>toUpper=String::toUpperCase;Function<String,String>addPrefix=s->"Hello, "+s;// andThen：先执行当前，再执行参数Function<String,String>pipeline=trim.andThen(toUpper).andThen(addPrefix);Stringresult=pipeline.apply(" alice ");// "Hello, ALICE"// compose：先执行参数，再执行当前Function<String,String>pipeline2=addPrefix.compose(toUpper).compose(trim);Stringresult2=pipeline2.apply(" alice ");// "Hello, ALICE"

4.2 Predicate 组合

Predicate<String>nonEmpty=s->!s.isEmpty();Predicate<String>shortStr=s->s.length()<10;Predicate<String>startsWithA=s->s.startsWith("A");// and / or / negatePredicate<String>combined=nonEmpty.and(shortStr).and(startsWithA.negate());combined.test("Hello");// truecombined.test("ABCDEF");// false

4.3 Consumer 组合

Consumer<String>log=s->System.out.println("LOG: "+s);Consumer<String>audit=s->System.out.println("AUDIT: "+s);Consumer<String>logAndAudit=log.andThen(audit);logAndAudit.accept("user login");// LOG: user login// AUDIT: user login

五、高阶函数实战

5.1 策略模式

// 传统策略模式需要多个类// 函数式策略模式：用 Map + Lambda 替代Map<String,Function<Double,Double>>strategies=Map.of("regular",p->p*0.95,"vip",p->p*0.8,"svip",p->p*0.7);doublediscounted=strategies.getOrDefault(userLevel,p->p).apply(originalPrice);

5.2 装饰器模式

// 函数式装饰器Function<String,String>base=s->s;Function<Function<String,String>,Function<String,String>>trimDecorator=fn->s->fn.apply(s.trim());Function<Function<String,String>,Function<String,String>>upperDecorator=fn->s->fn.apply(s.toUpperCase());Function<Function<String,String>,Function<String,String>>prefixDecorator=fn->s->fn.apply(">> "+s);Function<String,String>decorated=trimDecorator.andThen(upperDecorator).andThen(prefixDecorator).apply(base);decorated.apply(" hello ");// ">> HELLO"

5.3 惰性求值

publicclassLazy<T>{privateSupplier<T>supplier;privateTvalue;privatebooleancomputed=false;publicLazy(Supplier<T>supplier){this.supplier=supplier;}publicTget(){if(!computed){value=supplier.get();computed=true;supplier=null;}returnvalue;}public<R>Lazy<R>map(Function<T,R>fn){returnnewLazy<>(()->fn.apply(this.get()));}public<R>Lazy<R>flatMap(Function<T,Lazy<R>>fn){returnnewLazy<>(()->fn.apply(this.get()).get());}}// 使用Lazy<String>lazy=newLazy<>(()->{System.out.println("Computing...");return"hello";});// 此时未计算Stringresult=lazy.get();// "Computing..." -> "hello"Stringagain=lazy.get();// 直接返回缓存值，不再计算

5.4 回调模式

public<T>voidexecuteAsync(Supplier<T>task,Consumer<T>onSuccess,Consumer<Exception>onError){newThread(()->{try{Tresult=task.get();onSuccess.accept(result);}catch(Exceptione){onError.accept(e);}}).start();}// 使用executeAsync(()->fetchData(),result->System.out.println("Success: "+result),error->System.err.println("Error: "+error.getMessage()));

六、常见陷阱

6.1 Lambda 中的 this

publicclassDemo{privateStringname="Outer";publicvoidtest(){// Lambda 中的 this 指向外部类实例Runnabler=()->System.out.println(this.name);// "Outer"// 匿名内部类中的 this 指向匿名类实例Runnabler2=newRunnable(){privateStringname="Inner";publicvoidrun(){System.out.println(this.name);// "Inner"}};}}

6.2 Lambda 与受检异常

// Lambda 中受检异常必须处理list.forEach(s->{try{Files.readString(Path.of(s));}catch(IOExceptione){thrownewUncheckedIOException(e);}});// 封装工具方法privatestatic<T>Supplier<T>unchecked(Callable<T>callable){return()->{try{returncallable.call();}catch(Exceptione){thrownewRuntimeException(e);}};}

6.3 Lambda 与重载歧义

// 编译错误：Lambda 类型推断歧义execute(()->{});// 是 Runnable 还是 Callable<Void>?// 显式指定类型execute((Runnable)()->{});execute((Callable<Void>)()->null);

总结