java 函数式编程_Java函数式编程：Javaslang入门

java 函数式编程

Java是一门古老的语言，并且该领域中有很多新手在他们自己的领域（JVM）上挑战Java。但是Java 8到来并带来了一些有趣的功能。这些有趣的功能使编写新的惊人框架（例如Spark Web框架或Javaslang）成为可能。

在本文中，我们将介绍将函数式编程引入Java的Javaslang。

函数式编程：这有什么用？

如今，似乎所有出色的开发人员都希望进行一些功能编程。因为他们以前想使用面向对象的编程。我个人认为函数式编程可以很好地解决某些问题，而其他范例则更好。

在以下情况下，函数式编程非常有用：

您可以将其与不变性配对：纯函数没有副作用，并且更容易推理。纯函数意味着不变性，从而极大地简化了测试和调试。但是，并非所有解决方案都能很好地代表不变性。有时您只是拥有大量数据，这些数据在多个用户之间共享，并且您想就地进行更改。在这种情况下，可变性是解决方法。
您拥有的代码取决于输入，而不取决于状态：如果某些东西取决于状态而不是输入，那么听起来对我来说更像是一个函数。理想情况下，功能代码应非常明确地说明正在使用的信息（因此，仅应使用参数）。这也意味着更多通用和可重用的功能。
您具有独立的逻辑，这些逻辑之间的耦合程度不高：以小型，通用和可重用功能组织的功能代码非常有用
您拥有要转换的数据流：我认为这是最容易看到函数式编程值的地方。实际上，流在Java 8中引起了很多关注。

讨论图书馆

正如您可以在javaslang.com上阅读的那样：

Java 8在我们的程序中引入了λc，但“显然，JDK API不会帮助您编写简洁的功能逻辑（…）” – jOOQ™博客

Javaslang™是编写全面的功能性Java 8+程序的缺失部分和最佳解决方案。

就像我看到的Javaslang一样：Java 8为我们提供了启用功能，以构建更简洁和可组合的代码。但是它没有做最后一步。它打开了一个空间，Javaslang到达了它。

Javaslang带来了许多功能：

currying： currying是功能的部分应用
模式匹配：让我们将其视为函数式编程的动态调度
故障处理：因为异常不利于功能组合
要么：这是函数编程中非常常见的另一种结构。典型的示例是一个函数，当事情进展顺利时返回一个值，而当事情进展不好时返回错误消息
元组：元组是对象的一种很好的轻量级替代方案，非常适合返回多个值。只是不要偷懒，并在合理的时候使用类
备注：这是功能的缓存

对于具有函数式编程经验的开发人员来说，这一切都是众所周知的。对于我们其余的人，让我们看一下如何在实践中使用这些东西。

好的，但是实际上我们如何使用这些东西？

显然，为Javaslang的每个功能显示一个示例远远超出了本文的范围。让我们看看如何使用其中的一些，尤其是让我们专注于函数式编程的精髓：函数操纵。

鉴于我沉迷于Java代码的操作，我们将了解如何使用Javaslang检查某些Java代码的抽象语法树（AST）。使用心爱的JavaParser可以轻松获得AST。

如果使用gradle，则build.gradle文件可能如下所示：

apply plugin: 'java'
apply plugin: 'idea'sourceCompatibility = 1.8repositories {mavenCentral()
}dependencies {compile "com.javaslang:javaslang:2.0.0-beta"compile "com.github.javaparser:javaparser-core:2.3.0"testCompile "junit:junit:4.12"
}

我们将实现非常简单的查询。仅查看AST即可获得解答，而无需求解符号。如果您想使用Java AST并求解符号，则可能需要看一下我的这个项目： java-symbol-solver 。

例如：

用给定名称的方法查找类
使用具有给定数量参数的方法查找类
查找具有给定名称的类
结合previos查询

让我们从给出CompilationUnit的函数开始，方法名称返回一个TypeDeclarations列表，该列表定义了使用该名称的方法。对于从未使用过JavaParser的用户： CompilationUnit代表整个Java文件，可能包含几个TypeDeclaration。 TypeDeclaration可以是类，接口，枚举或注释声明。

import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.body.TypeDeclaration;
import javaslang.Function1;
import javaslang.Function2;
import javaslang.collection.List;.../*** Helper method*/public static boolean hasMethodNamed(TypeDeclaration typeDeclaration, String methodName) {return List.ofAll(typeDeclaration.getMembers()).map(Match.whenType(MethodDeclaration.class).then((t)-> Option.of(t.getName())).otherwise(() -> Option.none())).map((n)->n.isDefined() && n.get().equals(methodName)).reduce((a, b)->a || b);}public static List<TypeDeclaration> getTypesWithThisMethod(CompilationUnit cu, String methodName) {return List.ofAll(cu.getTypes()).filter((t) -> hasMethodNamed(t, methodName));}

getTypesWithThisMethod非常简单：我们采用CompilationUnit（ cu.getTypes（） ）中的所有类型，并对它们进行过滤，仅选择具有该名称的方法的类型。真正的工作在hasMethodNamed中完成。

在hasMethodNamed宽 E从我们的java.util.List（List.ofAll（typeDeclaration.getMembers（））创建一个javaslang.collection.List开始，然后我们认为我们只是在MethodDeclarations感兴趣：我们不是在外地感兴趣声明或类型声明中包含的其他内容，因此，如果方法名称与所需的methodName相匹配，则将每个方法声明映射到Option.of（true） ，否则将其映射到Option.of（false） 。不是MethodDeclaration映射到Option.none（） 。

因此，例如，如果我们在一个具有三个字段的类中寻找方法名称“ foo”，其次是名为“ bar”，“ foo”和“ baz”的方法，我们将获得以下列表：

Option.none（）， Option.none（）， Option.none（）， Option.of（false）， Option.of（true） ， Option.of（false） 。

下一步是将Option.none（）和Option.of（false）都映射为false，同时将Option.of（true）映射为true 。请注意，我们可以立即将其连接起来，而不是同时连接两个map操作。但是我更喜欢分步进行。一旦我们获得了一个true和false的列表，我们需要从中导出一个单一值，如果该列表包含至少一个true，则应该为true，否则为false 。从列表中获取单个值称为减少操作。这种操作有不同的变体：我将让您详细研究:)

我们可以这样重写最新的方法：

public List<TypeDeclaration> getTypesWithThisMethod(CompilationUnit cu, String methodName) {Function2<TypeDeclaration, String, Boolean> originalFunction = AstExplorer::hasMethodNamed;Function2<String, TypeDeclaration, Boolean> originalFunctionReversed = originalFunction.reversed();Function1<String, Function1<TypeDeclaration, Boolean>> originalFunctionReversedAndCurried = originalFunction.reversed().curried();Function1<TypeDeclaration, Boolean> originalFunctionReversedAndCurriedAndAppliedToMethodName =originalFunction.reversed().curried().apply(methodName);return List.ofAll(cu.getTypes()).filter(asPredicate(originalFunctionReversedAndCurriedAndAppliedToMethodName));}

为什么我们要这样做？看起来（而且确实）更加复杂，但是它向我们展示了如何操作函数，这是获取更灵活，更强大的代码的中间步骤。因此，让我们尝试了解我们在做什么。

首先快速注意一下：类Function1表示一个带有一个参数的函数。第一个泛型参数是函数接受的参数的类型，而第二个泛型参数是函数返回的值的类型。 Function2取而代之的是2个参数。您可以了解这是怎么回事:)

我们：

反转参数可以传递给函数的顺序
我们创建一个部分应用的函数：这是一个函数，其中第一个参数是“固定的”

所以我们创建originalFunctionReversedAndCurriedAndAppliedToMethodName只运用原有的功能hasMethodNamed。 原始函数有2个参数： TypeDeclaration和方法名称。我们精心设计的函数只接受TypeDeclaration。 它仍然返回一个布尔值。

然后，我们可以简单地用这个小函数将谓词转换为函数，然后可以反复使用：

private static <T> Predicate<T> asPredicate(Function1<T, Boolean> function) {return v -> function.apply(v);}

现在，这就是我们可以使其更通用的方法：

/** * Get all the types in a CompilationUnit which satisfies the given condition */
public List<TypeDeclaration> getTypes(CompilationUnit cu, Function1<TypeDeclaration, Boolean> condition) {return List.ofAll(cu.getTypes()).filter(asPredicate(condition));
}/*** It returns a function which tells has if a given TypeDeclaration has a method with a given name.*/
public Function1<TypeDeclaration, Boolean> hasMethodWithName(String methodName) {Function2<TypeDeclaration, String, Boolean> originalFunction = AstExplorer::hasMethodNamed;return originalFunction.reversed().curried().apply(methodName);
}/*** We could combine previous function to get this one and solve our original question.*/
public List<TypeDeclaration> getTypesWithThisMethod(CompilationUnit cu, String methodName) {return getTypes(cu, hasMethodWithName(methodName));
}

好的，现在我们可以泛化hasMethodWithName了：

/*** This function returns true if the TypeDeclaration has at * least one method satisfying the given condition.*/public static boolean hasAtLeastOneMethodThat(TypeDeclaration typeDeclaration, Function1<MethodDeclaration, Boolean> condition) {return List.ofAll(typeDeclaration.getMembers()).map(Match.whenType(MethodDeclaration.class).then(m -> condition.apply(m)).otherwise(false)).reduce((a, b)->a || b);}/*** We refactor this function to reuse hasAtLeastOneMethodThat*/public static boolean hasMethodWithName(TypeDeclaration typeDeclaration, String methodName) {return hasAtLeastOneMethodThat(typeDeclaration, m -> m.getName().equals(methodName));}

经过一些重构，我们得到以下代码：

package me.tomassetti.javaast;import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.body.TypeDeclaration;
import javaslang.Function1;
import javaslang.Function2;
import javaslang.collection.List;
import javaslang.control.Match;import java.util.function.Predicate;public class AstExplorer {public static boolean hasAtLeastOneMethodThat(TypeDeclaration typeDeclaration, Function1<MethodDeclaration, Boolean> condition) {return hasAtLeastOneMethodThat(condition).apply(typeDeclaration);}public static Function1<TypeDeclaration, Boolean> hasAtLeastOneMethodThat(Function1<MethodDeclaration, Boolean> condition) {return t -> List.ofAll(t.getMembers()).map(Match.whenType(MethodDeclaration.class).then(m -> condition.apply(m)).otherwise(false)).reduce((a, b)-> a || b);}public static boolean hasMethodNamed(TypeDeclaration typeDeclaration, String methodName) {return hasAtLeastOneMethodThat(typeDeclaration, m -> m.getName().equals(methodName));}private static <T> Predicate<T> asPredicate(Function1<T, Boolean> function) {return v -> function.apply(v);}public static List<TypeDeclaration> typesThat(CompilationUnit cu, Function1<TypeDeclaration, Boolean> condition) {return List.ofAll(cu.getTypes()).filter(asPredicate(condition));}public static Function1<TypeDeclaration, Boolean> methodHasName(String methodName) {Function2<TypeDeclaration, String, Boolean> originalFunction = AstExplorer::hasMethodNamed;return originalFunction.reversed().curried().apply(methodName);}public static List<TypeDeclaration> typesWithThisMethod(CompilationUnit cu, String methodName) {return typesThat(cu, methodHasName(methodName));}}

现在让我们看看如何使用它：

package me.tomassetti.javaast;import com.github.javaparser.JavaParser;
import com.github.javaparser.ParseException;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.body.TypeDeclaration;
import javaslang.Function1;
import javaslang.collection.List;
import org.junit.Test;import java.io.InputStream;
import static me.tomassetti.javaast.AstExplorer.*;
import static org.junit.Assert.*;public class AstExplorerTest {@Testpublic void typesNamedA() throws ParseException {InputStream is = AstExplorerTest.class.getResourceAsStream("/SomeJavaFile.java");CompilationUnit cu = JavaParser.parse(is);Function1<MethodDeclaration, Boolean> isNamedBar = m -> m.getName().equals("bar");List<TypeDeclaration> res = typesThat(cu, hasAtLeastOneMethodThat(isNamedBar));assertEquals(2, res.length());assertEquals("A", res.get(0).getName());assertEquals("B", res.get(1).getName());}@Testpublic void typesHavingAMethodNamedBar() throws ParseException {InputStream is = AstExplorerTest.class.getResourceAsStream("/SomeJavaFile.java");CompilationUnit cu = JavaParser.parse(is);Function1<MethodDeclaration, Boolean> isNamedBar = m -> m.getName().equals("bar");List<TypeDeclaration> res = typesThat(cu, hasAtLeastOneMethodThat(isNamedBar));assertEquals(2, res.length());assertEquals("A", res.get(0).getName());assertEquals("B", res.get(1).getName());}@Testpublic void typesHavingAMethodNamedBarWhichTakesZeroParams() throws ParseException {InputStream is = AstExplorerTest.class.getResourceAsStream("/SomeJavaFile.java");CompilationUnit cu = JavaParser.parse(is);Function1<MethodDeclaration, Boolean> hasZeroParam = m -> m.getParameters().size() == 0;Function1<MethodDeclaration, Boolean> isNamedBar = m -> m.getName().equals("bar");List<TypeDeclaration> res = typesThat(cu, hasAtLeastOneMethodThat(m -> hasZeroParam.apply(m) && isNamedBar.apply(m)));assertEquals(1, res.length());assertEquals("A", res.get(0).getName());}@Testpublic void typesHavingAMethodNamedBarWhichTakesOneParam() throws ParseException {InputStream is = AstExplorerTest.class.getResourceAsStream("/SomeJavaFile.java");CompilationUnit cu = JavaParser.parse(is);Function1<MethodDeclaration, Boolean> hasOneParam = m -> m.getParameters().size() == 1;Function1<MethodDeclaration, Boolean> isNamedBar = m -> m.getName().equals("bar");List<TypeDeclaration> res = typesThat(cu, hasAtLeastOneMethodThat(m -> hasOneParam.apply(m) && isNamedBar.apply(m)));assertEquals(1, res.length());assertEquals("B", res.get(0).getName());}}

我们在此测试中使用的源文件是以下文件：

class A {void foo() { }void bar() { }
}class B {void bar(int x) { }void baz() { }
}

当然，这是对Javaslang潜力的非常非常非常有限的介绍。对于那些刚接触函数式编程的人来说，我认为重要的是倾向于编写很小的函数 ，这些函数可以组合和操纵以获得非常灵活和强大的代码。当我们开始使用函数式编程时，它似乎显得晦涩难懂，但是如果您看一下我们编写的测试，我认为它们相当清晰和具有描述性。

函数式编程：炒作是否合理？

我认为对函数式编程有很多兴趣，但是如果过分炒作，可能会导致糟糕的设计决策。考虑一下OOP成为新的冉冉升起的新星的时间：Java设计人员一路走低，迫使程序员将每个代码都放在一个类中，现在我们有了带有一堆静态方法的实用程序类。换句话说，我们参加了活动，并要求他们假装成为获得OOP奖牌的班级。是否有意义？我不这么认为。强烈鼓励人们学习OOP原则可能有点极端主义。这就是为什么如果您想学习函数式编程，那么可能会想要使用像Haskell这样的仅函数式语言：因为它们确实，真的，真的将您推向了函数式编程。这样您就可以学习原理并在有意义的时候使用它们。

结论

我认为函数式编程是一个功能强大的工具，它可以产生非常有表现力的代码。当然，它不是解决每种问题的正确工具。不幸的是，Java 8没有在标准库中正确支持功能编程模式。但是，一些启用功能已经以该语言引入，并且Javaslang现在使编写出色的功能代码成为可能。我认为以后会出现更多的库，也许它们可以使Java保持健康和健康的状态。