标签：static ted compare run end line ret lambda表达式 pat
函数式编程的中心思想：是把函数作为参数传递给另一个函数，或把函数作为一个返回值。
只是为了使程序适合有限的内存，程序员通过修改内存中的代码来节省代码空间，以便在程序执行时执行不同的操作。这种技术被称为自修改代码 （self-modifying code）
OO（object oriented，面向对象）是抽象数据，
FP（functional programming，函数式编程）是抽象行为
纯粹的函数式语言在安全性方面更进一步。它强加了额外的约束，即所有数据必须是不可变的：设置一次，永不改变。
“不可变对象和无副作用”范式解决了并发编程中最基本和最棘手的问题之一
因此，经常提出纯函数式语言作为并行编程的解决方案（还有其他可行的解决方案）。
package functional;
interface Strategy {
String approach(String msg);
}
class Soft implements Strategy {
@Override
public String approach(String msg) {
return msg.toLowerCase() + "?";
}
}
class Unrealted {
static String twice(String msg) {
return msg + " " + msg;
}
}
public class Strategize {
Strategy strategy;
String msg;
Strategize(String msg){
strategy = new Soft(); // [1]在 Strategize 中，Soft 作为默认策略，在构造函数中赋值。
this.msg = msg;
}
void communicate(){
System.out.println(strategy.approach(msg));
}
void changeStategy(Strategy strategy){
this.strategy = strategy;
}
public static void main(String[] args) {
Strategy[] strategies = {
new Strategy() {// [2]匿名内部类
@Override
public String approach(String msg) {
return msg.toUpperCase() + "!";
}
},
msg -> msg.substring(0,5),// [3]Java 8 的 Lambda 表达式
// 由箭头 -> 分隔开参数和函数体，箭头左边是参数，箭头右侧是从 Lambda 返回的表达式，即函数体。这实现了与定义类、匿名内部类相同的效果，但代码少得多。
Unrealted::twice// [4]Java 8 的方法引用，由 :: 区分。在 :: 的左边是类或对象的名称，在 :: 的右边是方法的名称，但没有参数列表。
};
Strategize s = new Strategize("Hello there");
s.communicate();
for (Strategy newStrategy : strategies){//遍历数组中的所有 Strategy
s.changeStategy(newStrategy);// [5]将每个 Strategy 放入 变量 s 中
s.communicate();// [6]产生不同的行为，具体取决于此刻正在使用的策略代码对象.我们传递的是行为，而非仅数据。
}
}
}
/*
hello there?
HELLO THERE!
Hello
Hello there Hello there
*/package functional;
interface Description {
String brief();
}
interface Body {
String detailed(String head);
}
interface Multi {
String twoArg(String head, Double d);
}
public class LambdaExpressions {
static Body bod = h -> h + " No Parens!"; //当只用一个参数，可以不需要括号 ()。 然而，这是一个特例。
static Body bod2 = (h) -> h + " More details"; //正常情况使用括号 () 包裹参数。 为了保持一致性，也可以使用括号 () 包裹单个参数，虽然这种情况并不常见。
static Description desc = () -> "Short info"; //如果没有参数，则必须使用括号 () 表示空参数列表。
static Multi mult = (h, n) -> h + n; // 对于多个参数，将参数列表放在括号 () 中。
//到目前为止，所有 Lambda 表达式方法体都是单行。 该表达式的结果自动成为 Lambda 表达式的返回值，在此处使用 return 关键字是非法的。 这是 Lambda 表达式缩写用于描述功能的语法的另一种方式。
static Description moreLines = () -> { //如果在 Lambda 表达式中确实需要多行，则必须将这些行放在花括号中。 在这种情况下，就需要使用 return。
System.out.println("moreLines()");
return "from moreLines()";
};
public static void main(String[] args) {
System.out.println(bod.detailed("Oh"));
System.out.println(bod2.detailed("Hi"));
System.out.println(desc.brief());
System.out.println(mult.twoArg("pi ", 3.14159));
System.out.println(moreLines.brief());
}
}
/*
Oh No Parens!
Hi More details
Short info
pi 3.14159
moreLines()
from moreLines()
*/
递归方法必须是实例变量或静态变量，否则会出现编译时错误。
package functional;
interface IntCall{
int call(int arg);
}
阶乘函数
package functional;
public class RecursiveFactorial {
static IntCall fact; //fact 是一个静态变量
public static void main(String[] args) {
fact = n -> n == 0 ? 1: n* fact.call(n-1);
for (int i = 0; i <=10; i++)
System.out.println(fact.call(i));
}
}
/*
1
1
2
6
24
120
720
5040
40320
362880
3628800
*/package functional;
public class RecursiveFibonacci {
IntCall fib; //实例变量
RecursiveFibonacci() {
fib = n -> n == 0 ? 0 :
n == 1 ? 1 :
fib.call(n - 1) + fib.call(n - 2);
}
int fibonacci(int n) {
return fib.call(n);
}
public static void main(String[] args) {
RecursiveFibonacci rf = new RecursiveFibonacci();
for (int i = 0; i <= 10; i++)
System.out.println(rf.fibonacci(i));
}
}
/*
0
1
1
2
3
5
8
13
21
34
55
*/Java 8 方法引用没有历史包袱。方法引用组成：类名或对象名，后面跟 :: ，然后跟方法名称。
package functional;
interface Callable { // [1]
void call(String s);
}
class Describe {
void show(String msg) {// [2] show() 的签名（参数类型和返回类型）符合 Callable 的 call() 的签名。
System.out.println(msg);
}
}
public class MethodReferences {
static void hello(String name) {// [3] hello() 也符合 call() 的签名。
System.out.println("Hello," + name);
}
static class Description {
String about;
Description(String desc) {
about = desc;
}
void help(String msg) { // [4] //help() 也符合，它是静态内部类中的非静态方法。
System.out.println(about + " " + msg);
}
}
static class Helper {
static void assist(String msg) {// [5] //assist() 是静态内部类中的静态方法。
System.out.println(msg);
}
}
public static void main(String[] args) {
Describe d = new Describe();
Callable c = d::show; // [6] 我们将 Describe 对象的方法引用赋值给 Callable ，它没有 show() 方法，而是 call() 方法。 但是，Java 似乎接受用这个看似奇怪的赋值，因为方法引用符合 Callable 的 call() 方法的签名。
c.call("call()"); // [7] 可以通过调用 call() 来调用 show()，因为 Java 将 call() 映射到 show()。
c = MethodReferences::hello; // [8] 静态方法引用
c.call("Bob");
c = new Description("valueable")::help; // [9] 这是 [6] 的另一个版本：对已实例化对象的方法的引用，有时称为绑定方法引用。
c.call("information");
c = Helper::assist; // [10] 获取静态内部类的方法引用的操作与 [8] 中外部类方式一样
c.call("Help!");
}
}
/*
call()
Hello,Bob
valueable information
Help!
*/
package functional;
class Go{
static void go(){
System.out.println("Go::go()");
}
}
public class RunnableMethodReference {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Anonymous");
}
}).start();
new Thread(() -> System.out.println("lambda")).start();//Lambda 表达式
new Thread(Go::go).start();//方法引用
}
}
/*
Anonymous
lambda
Go::go()
*/
未绑定的方法引用是指没有关联对象的普通（非静态）方法。 使用未绑定的引用之前，我们必须先提供对象
package functional;
class X {
String f() {
return "X::f()";
}
}
interface MakeString {
String make();
}
interface TransformX {
// 使用未绑定的引用时，函数方法的签名（接口中的单个方法）不再与方法引用的签名完全匹配。
// 理由是：你需要一个对象来调用方法。
String transform(X x);
}
public class UnboundMethodReference {
public static void main(String[] args) {
// 即使 make() 与 f() 具有相同的签名，编译也会报“invalid method reference”（无效方法引用）错误。
// 这是因为实际上还有另一个隐藏的参数：我们的老朋友 this。 你不能在没有 X 对象的前提下调用 f()。
// 因此，X :: f 表示未绑定的方法引用，因为它尚未“绑定”到对象
// MakeString ms = X::f; // [1]
TransformX sp = X::f;
X x =new X();
System.out.println(sp.transform(x));// [2] [2] 的结果有点像脑筋急转弯。 我接受未绑定的引用并对其调用 transform()，将其传递给 X，并以某种方式导致对 x.f() 的调用。 Java 知道它必须采用第一个参数，这实际上就是 this，并在其上调用方法。
System.out.println(x.f());// 同等效果
}
}
/*
X::f()
X::f()
*/
未绑定的方法与多参数的结合运用
package functional;
class This {
void two(int i, double d) {
}
void three(int i, double d, String s) {
}
void four(int i, double d, String s, char c) {
}
}
interface TwoArgs {
void call2(This athis, int i, double d);
}
interface ThreeArgs {
void call3(This athis,int i,double d, String s);
}
interface FourArgs{
void call4(This athis,int i,double d,String s, char c);
}
public class MultiUnbound {
public static void main(String[] args) {
TwoArgs twoArgs = This::two;
ThreeArgs threeArgs = This::three;
FourArgs fourArgs = This::four;
This athis = new This();
twoArgs.call2(athis,11,3.14);
threeArgs.call3(athis,11,3.14,"Three");
fourArgs.call4(athis,11,3.14,"Four",'Z');
}
}
package functional;
class Dog {
String name;
int age = -1; // For "unknown"
Dog() {
name = "stray";
}
Dog(String nm) {
name = nm;
}
Dog(String nm, int yrs) {
name = nm;
age = yrs;
}
}
interface MakeNoArgs {
Dog make();
}
interface Make1Arg {
Dog make(String nm);
}
interface Make2Args {
Dog make(String nm, int age);
}
public class CtorReference {
public static void main(String[] args) {
MakeNoArgs mna = Dog::new;// [1]
Make1Arg m1a = Dog::new;// [2]
Make2Args m2a = Dog::new;// [3]
Dog dn = mna.make();
Dog d1 = m1a.make("Comet");
Dog d2 = m2a.make("Ralph",4);
}
}
//我们如何对 [1]，[2] 和 [3] 中的每一个使用 Dog :: new。 这 3 个构造函数只有一个相同名称：:: new，但在每种情况下都赋值给不同的接口。编译器可以检测并知道从哪个构造函数引用。
//
//编译器能识别并调用你的构造函数（ 在本例中为 make()）。
每个接口只包含一个抽象方法，称为函数式方法。
package functional;
@FunctionalInterface
interface Functional{
String goodbye(String arg);
}
interface FunctionalNoAnn{
String goodbye(String arg);
}
/*
@FunctionalInterface
interface NotFunctional{
String goodbye(String arg);
String hello(String arg);
}
产生错误信息:
NotFunctional is not a functional interface
multiple non-overriding abstract methods
found in interface NotFunctional
*/
public class FunctionalAnnotation {
public String goodbye(String arg){
return "Goodbye, " + arg;
}
public static void main(String[] args) {
FunctionalAnnotation fa = new FunctionalAnnotation();
// Java 8 在这里添加了一点小魔法：
// 如果将方法引用或 Lambda 表达式赋值给函数式接口（类型需要匹配），
// Java 会适配你的赋值到目标接口。
// 编译器会自动包装方法引用或 Lambda 表达式到实现目标接口的类的实例中。
Functional f = fa::goodbye;
FunctionalNoAnn fna = fa::goodbye;
// Functional fac = fa;// Incompatible
Functional f1 = a -> "Goodbye, " + a;
FunctionalNoAnn fnal = a -> "Goodbye, " + a;
}
}
基本命名准则：
如果只处理对象而非基本类型，名称则为 Function，Consumer，Predicate 等。参数类型通过泛型添加。
如果接收的参数是基本类型，则由名称的第一部分表示，如 LongConsumer，DoubleFunction，IntPredicate 等，但基本 Supplier 类型例外。
如果返回值为基本类型，则用 To 表示，如 ToLongFunction
如果返回值类型与参数类型一致，则是一个运算符：单个参数使用 UnaryOperator，两个参数使用 BinaryOperator。
如果接收两个参数且返回值为布尔值，则是一个谓词（Predicate）。
如果接收的两个参数类型不同，则名称中有一个 Bi。
下面枚举了基于 Lambda 表达式的所有不同 Function 变体的示例
package functional;
import java.util.function.*;
class Foo{}
class Bar{
Foo f;
Bar(Foo f){this.f = f;}
}
class IBaz{
int i;
IBaz(int i){
this.i = i;
}
}
class LBaz{
long l;
LBaz(long l){
this.l = l;
}
}
class DBaz{
double d;
DBaz(double d){
this.d = d;
}
}
public class FunctionVariants {
static Function<Foo,Bar> f1 = f -> new Bar(f);
static IntFunction<IBaz> f2 = i -> new IBaz(i);
static LongFunction<LBaz> f3 = l ->new LBaz(l);
static DoubleFunction<DBaz> f4 = d -> new DBaz(d);
static ToIntFunction<IBaz> f5 = ib -> ib.i;
static ToLongFunction<LBaz> f6 = lb -> lb.l;
static ToDoubleFunction<DBaz> f7 = db -> db.d;
static IntToLongFunction f8 = i -> i;
static IntToDoubleFunction f9 = i -> i;
static LongToIntFunction f10 = l -> (int)l;
static LongToDoubleFunction f11 = l -> l;
static DoubleToIntFunction f12 = d -> (int)d;
static DoubleToLongFunction f13 = d -> (long)d;
public static void main(String[] args) {
Bar b = f1.apply(new Foo());
IBaz ib = f2.apply(11);
LBaz lb = f3.apply(11);
DBaz db = f4.apply(11);
int i = f5.applyAsInt(ib);
long l = f6.applyAsLong(lb);
double d = f7.applyAsDouble(db);
l = f8.applyAsLong(12);
d = f9.applyAsDouble(12);
i = f10.applyAsInt(12);
d = f11.applyAsDouble(12);
i = f12.applyAsInt(13.0);
l = f13.applyAsLong(13.0);
}
}
方法引用
package functional;
import java.util.function.BiConsumer;
class In1{}
class In2{}
public class MethodConversion {
static void accept(In1 i1,In2 i2){ // 只要参数类型、返回类型与 BiConsumer 的 accept() 相同即可。
System.out.println("accept()");
}
static void someOtherName(In1 i1,In2 i2){ //只要参数类型、返回类型与 BiConsumer 的 accept() 相同即可。
System.out.println("someOtherName()");
}
public static void main(String[] args) {
BiConsumer<In1,In2> bic;
bic = MethodConversion::accept;
bic.accept(new In1(),new In2());
bic = MethodConversion::someOtherName;
bic.accept(new In1(),new In2());
}
}
/*
accept()
someOtherName()
*/
基于类的函数式，应用于方法引用
创建最简单的函数式签名
package functional;
import java.util.Comparator;
import java.util.function.*;
class AA{}
class BB{}
class CC{}
public class ClassFunctionals {
static AA f1(){return new AA();}
static int f2(AA aa1, AA aa2){ return 1;}
static void f3(AA aa){}
static void f4(AA aa, BB bb){}
static CC f5(AA aa){return new CC();}
static CC f6(AA aa, BB bb){return new CC();}
static boolean f7(AA aa){return true;}
static boolean f8(AA aa, BB bb){return true;}
static AA f9(AA aa){return new AA();}
static AA f10(AA aa1,AA aa2){return new AA();}
public static void main(String[] args) {
Supplier<AA> s = ClassFunctionals::f1;
s.get();
Comparator<AA> c = ClassFunctionals::f2;
c.compare(new AA(),new AA());
Consumer<AA> cons = ClassFunctionals::f3;
cons.accept(new AA());
BiConsumer<AA,BB> bicons = ClassFunctionals::f4;
bicons.accept(new AA(),new BB());
Function<AA,CC> f = ClassFunctionals::f5;
CC cc = f.apply(new AA());
BiFunction<AA,BB,CC> bif = ClassFunctionals::f6;
cc = bif.apply(new AA(),new BB());
Predicate<AA> p = ClassFunctionals::f7;
boolean result = p.test(new AA());
BiPredicate<AA,BB> bip = ClassFunctionals::f8;
result = bip.test(new AA(),new BB());
UnaryOperator<AA> uo = ClassFunctionals::f9;
AA aa = uo.apply(new AA());
BinaryOperator<AA> bo = ClassFunctionals::f10;
aa = bo.apply(new AA(),new AA());
}
}
package functional;
@FunctionalInterface
public interface TriFunction<T,U,V,R> {
R apply(T t, U u, V v);
}验证 测试了方法引用和 Lambda 表达式
package functional;
public class TriFunctionTest {
static int f(int i,long l,double d){return 99;}
public static void main(String[] args) {
TriFunction<Integer,Long,Double,Integer> tf = TriFunctionTest::f;
tf = (i,l,d) -> 12;
}
}
package functional;
import java.util.function.BiConsumer;
public class BitConsumerPermutations {
static BiConsumer<Integer,Double> bicid =(i,d) -> System.out.printf("%d, %f%n",i,d); // %n 跨平台
static BiConsumer<Double,Integer> bicdi = (d,i) -> System.out.printf("%d, %f%n",i,d);
static BiConsumer<Integer,Long> bicil = (i, l) -> System.out.printf("%d, %d%n",i,l);
public static void main(String[] args) {
bicid.accept(47,11.34);
bicdi.accept(22.45,92);
bicil.accept(1,11L);
}
}
/*
47, 11.340000
92, 22.450000
1, 11
*/
package functional;
import java.util.function.Function;
import java.util.function.IntToDoubleFunction;
public class FunctionWithWrapped {
public static void main(String[] args) {
// Function<Integer,Double> fid = i -> i; // Integer cannot be converted to Double
Function<Integer,Double> fid = i -> (double)i;
IntToDoubleFunction fid2 = i -> i;
}
}高阶函数（Higher-order Function）只是一个消费或产生函数的函数。
产生函数
package functional;
import java.util.function.Function;
interface FuncSS extends Function<String,String> {} // [1] 继承
public class ProduceFunction {
static FuncSS produce(){
return s -> s.toLowerCase(); // [2] lambda表达式
}
public static void main(String[] args) {
FuncSS f = produce();
System.out.println(f.apply("YELLING"));
}
}
消费函数
package functional;
import java.util.function.Function;
class One{}
class Two{}
public class ConsumeFunction {
static Two consume(Function<One,Two> onetwo){
return onetwo.apply(new One());
}
public static void main(String[] args) {
Two two = consume(one -> new Two());
}
}
package functional;
import java.util.function.Function;
class I {
public I(){
System.out.println("Create I");
}
@Override
public String toString(){
return "I";
}
}
class O{
public O(){
System.out.println("Create O");
}
@Override
public String toString(){
return "O";
}
}
public class TransformFunction {
static Function<I,O> transform(Function<I,O> in){
System.out.println("2");
return in.andThen(o -> {
System.out.println(o);
return o;
});
}
public static void main(String[] args) {
System.out.println("1");
Function<I,O> f2 = transform(i -> {
System.out.println("lalla");
System.out.println(i);
return new O();
});
System.out.println("3");
O o = f2.apply(new I());
}
}
/*
1
2
3
Create I
lalla
I
Create O
*/
使用匿名内部类重写之前的例子
package functional;
import java.util.function.IntSupplier;
public class AnonymousClosure {
IntSupplier makeFun(int x){
int i = 0;
// 同样规则的应用:
// i++; // 非等同 final 效果
// x++; // 同上
return new IntSupplier() {
@Override
public int getAsInt() {
return x + i ;
}
};
}
}
package functional;
import java.util.function.Function;
public class FunctionComposition {
static Function<String,String> f1 = s -> {
System.out.println(s);
return s.replace('A','_');
},
f2 = s -> s.substring(3),
f3 = s -> s.toLowerCase(),
f4 = f1.compose(f2).andThen(f3); // 创建的新函数 f4。它调用 apply() 的方式与常规几乎无异.
// 当 f1 获得字符串时，它已经被f2 剥离了前三个字符。这是因为 compose（f2） 表示 f2 的调用发生在 f1 之前。
public static void main(String[] args) {
System.out.println(f4.apply("GO AFTER ALL AMBULANCES"));
}
}
/*
AFTER ALL AMBULANCES
_fter _ll _mbul_nces
*/
package functional;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class PredicateComposition {
static Predicate<String>
p1 = s -> s.contains("bar"),
p2 = s -> s.length() < 5,
p3 = s -> s.contains("foo"),
p4 = p1.negate().and(p2).or(p3);
public static void main(String[] args) {
Stream.of("bar","foobar","foobaz","fongopuckey")
.filter(p4)
.forEach(System.out::println);
}
}
/*
foobar
foobaz
*/柯里化（Currying）名称来自于其发明者之一 Haskell Curry
将一个多参数的函数，转换为一系列单参数函数。
package functional;
import java.util.function.Function;
public class CurryingAndPartials {
// 未柯里化
static String uncurried(String a,String b){
return a + b;
}
public static void main(String[] args) {
// 柯里化的函数
Function<String,Function<String,String>> sum = a -> b -> a + b; //[1] 这一连串的箭头很巧妙。注意，在函数接口声明中，第二个参数是另一个函数。
System.out.println(uncurried("Hi","Ho"));
Function<String,String> hi = sum.apply("Hi"); // [2]柯里化的目的是能够通过提供一个参数来创建一个新函数，所以现在有了一个“带参函数”和剩下的 “无参函数” 。实际上，你从一个双参数函数开始，最后得到一个单参数函数。
System.out.println(hi.apply("Ho"));
//部分应用：
Function<String,String> sumHi = sum.apply("Hup ");
System.out.println(sumHi.apply("Ho"));
System.out.println(sumHi.apply("Hey"));
}
}
/*HiHo
HiHo
Hup Ho
Hup Hey
*/
通过添加级别来柯里化一个三参数函数
package functional;
import java.util.function.Function;
public class Curry3Args {
public static void main(String[] args) {
Function<String,
Function<String,
Function<String,String>>> sum =
a -> b -> c -> a + b + c;
Function<String,
Function<String,String>> hi = sum.apply("Hi ");
Function<String,String> ho = hi.apply("Ho ");
System.out.println(ho.apply("Hup"));
}
}
/*
对于每个级别的箭头级联（Arrow-cascading），你在类型声明中包裹了另一个 Function。
Hi Ho Hup
*/
处理基本类型和装箱时，请使用适当的 Function 接口
package functional;
import java.util.function.IntFunction;
import java.util.function.IntUnaryOperator;
public class CurriedIntAdd {
public static void main(String[] args) {
IntFunction<IntUnaryOperator> curriedIntAdd = a -> b -> a + b;
IntUnaryOperator add4 = curriedIntAdd.apply(4);
System.out.println(add4.applyAsInt(5));
}
}要确保一切是 final 的，同时你的所有方法和函数没有副作用。因为 Java 在本质上并非是不可变语言，我们无法通过编译器查错。
标签：static ted compare run end line ret lambda表达式 pat
原文地址：https://www.cnblogs.com/erinchen/p/12310374.html
