函数式程序设计的定义
Clojure的喜悦简介介绍如下：
函数式编程是具有不确定定义的那些计算术语之一。如果您问100个程序员的定义，您可能会收到100个不同的答案...
功能编程关注并促进功能的应用和组成。为了使语言被视为功能语言，其功能概念必须是一流的。一流的函数可以像其他任何数据一样进行存储，传递和返回。除此核心概念外，[FP的定义可能包括]纯度，不变性，递归，惰性和参照透明性。
在Scala 2nd Edition中编程。10具有以下定义：
函数式编程以两个主要思想为指导。第一个想法是函数是一流的值...您可以将函数作为参数传递给其他函数，将它们作为函数的结果返回或存储在变量中...
函数式编程的第二个主要思想是程序的操作应将输入值映射到输出值，而不是就地更改数据。
如果我们接受第一个定义，那么使代码“起作用”的唯一要做的就是将循环内翻。第二个定义包括不变性。
一流的功能
想象一下，当前您从公共汽车对象中获得了一个乘客名单，然后对其进行迭代，从而使每个乘客的银行帐户减少了公共汽车票价的金额。执行相同操作的功能性方法是在Bus上有一个方法，该方法可能称为forEachPassenger，它具有一个参数的功能。然后，Bus会对其乘客进行迭代，但这是最好的方法，并且将向您收取车费的客户代码放入函数中，并传递给forEachPassenger。瞧！您正在使用函数式编程。
当务之急：
for (Passenger p : Bus.getPassengers()) {
p.debit(fare);
}
功能（在Scala中使用匿名函数或“ lambda”）：
myBus = myBus.forEachPassenger(p:Passenger -> { p.debit(fare) })
更多含糖的Scala版本：
myBus = myBus.forEachPassenger(_.debit(fare))
非一流的功能
如果您的语言不支持一流的功能，这可能会很丑陋。在Java 7或更早版本中，您必须提供一个“功能对象”接口，如下所示：
// Java 8 has java.util.function.Consumer, but in earlier
// versions you have to roll your own:
public interface Consumer<T> {
public void accept(T t);
}
然后，Bus类提供一个内部迭代器：
public void forEachPassenger(Consumer<Passenger> c) {
for (Passenger p : passengers) {
c.accept(p);
}
}
最后，将一个匿名函数对象传递给总线：
// Java 8 has syntactic sugar to make this look more like
// the Scala solution, but earlier versions require manually
// instantiating a "Function Object," in this case, a
// Consumer:
Bus.forEachPassenger(new Consumer<Passenger>() {
@Override
public void accept(final Passenger p) {
p.debit(fare);
}
}
Java 8允许在匿名函数的范围内捕获局部变量，但是在早期版本中，任何此类变量都必须声明为final。为了解决这个问题，您可能需要制作一个MutableReference包装器类。这是一个特定于整数的类，可让您向上述代码添加循环计数器：
public static class MutableIntWrapper {
private int i;
private MutableIntWrapper(int in) { i = in; }
public static MutableIntWrapper ofZero() {
return new MutableIntWrapper(0);
}
public int value() { return i; }
public void increment() { i++; }
}
final MutableIntWrapper count = MutableIntWrapper.ofZero();
Bus.forEachPassenger(new Consumer<Passenger>() {
@Override
public void accept(final Passenger p) {
p.debit(fare);
count.increment();
}
}
System.out.println(count.value());
即使很丑陋，通过提供一个内部迭代器，有时仍然可以消除遍及整个程序的循环中复杂且重复的逻辑。
Java 8中已修复了此丑陋问题，但在一流函数中处理检查的异常仍然非常丑陋，并且Java仍在其所有集合中都保留了可变性的假设。这将我们带到通常与FP相关的其他目标：
不变性
乔什·布洛赫（Josh Bloch）的第13项是“首选不变性”。尽管常见的垃圾谈话与此相反，但是OOP可以用不可变的对象完成，并且这样做会更好。例如，Java中的String是不可变的。StringBuffer，OTOH需要是可变的，以构建不可变的String。有些任务（例如使用缓冲区）固有地需要可变性。
纯度
每个函数至少应该是可记忆的-如果您给它提供相同的输入参数（并且除了它的实际参数外，它应该没有输入），它每次都应产生相同的输出而不会引起“副作用”，例如更改全局状态，执行I / O或引发异常。
有人说，在函数式编程中，“通常需要一些邪恶才能完成工作。” 100％的纯度通常不是目标。减少副作用是。
结论
确实，在上述所有想法中，就简化我的代码（无论是OOP还是FP）而言，不变性是实际应用中最大的胜利。将函数传递给迭代器是第二大胜利。在的Java 8 Lambda表达式的文档有为什么最好的解释。递归对于处理树非常有用。懒惰使您可以处理无限的集合。
如果您喜欢JVM，建议您看一下Scala和Clojure。两者都是对函数式编程的深刻理解。Scala具有类似于C的语法，是类型安全的，尽管它与Haskell的语法确实与C具有相同的语法。Clojure不是类型安全的，它是Lisp。我最近发布了Java，Scala和Clojure关于一个特定重构问题的比较。 洛根·坎贝尔（Logan Campbell）使用生命游戏进行的比较还包括Haskell和键入的Clojure。
聚苯乙烯
吉米·霍法（Jimmy Hoffa）指出，我的巴士课程是可变的。我认为这将证明该问题的重构方式，而不是解决原始问题。可以通过以下方法解决此问题：将“公共汽车”上的每种方法设为工厂以生产新的公共汽车，将“乘客”上的每种方法设为工厂以生产新的乘客。因此，我向所有内容添加了返回类型，这意味着我将复制Java 8的java.util.function.Function而不是Consumer接口：
public interface Function<T,R> {
public R apply(T t);
// Note: I'm leaving out Java 8's compose() method here for simplicity
}
然后在巴士上：
public Bus mapPassengers(Function<Passenger,Passenger> c) {
// I have to use a mutable collection internally because Java
// does not have immutable collections that return modified copies
// of themselves the way the Clojure and Scala collections do.
List<Passenger> newPassengers = new ArrayList(passengers.size());
for (Passenger p : passengers) {
newPassengers.add(c.apply(p));
}
return Bus.of(driver, Collections.unmodifiableList(passengers));
}
最后，匿名函数对象返回事物的修改状态（带有新乘客的新公共汽车）。假设p.debit（）现在返回的新不变乘客的钱比原始人少：
Bus b = b.mapPassengers(new Function<Passenger,Passenger>() {
@Override
public Passenger apply(final Passenger p) {
return p.debit(fare);
}
}
希望您现在可以自行决定要使用命令式语言的功能，并决定使用功能性语言重新设计项目是否会更好。在Scala或Clojure中，集合和其他API旨在简化函数式编程。两者都有很好的Java互操作性，因此您可以混合和匹配语言。实际上，为了实现Java互操作性，Scala将其第一类函数编译为几乎与Java 8功能接口兼容的匿名类。您可以在深度部分的Scala中阅读有关详细信息。1.3.2。