什么是函数式编程
函数式编程（英语：functional programming）又称函数程序设计和泛函编程，是一种编程范型，它将电脑运算视为数学上的函数计算，并且避免使用程序状态以及易变对象。函数编程语言最重要的基础是λ演算（lambda calculus）。而且λ演算的函数可以接受函数当作输入（引数）和输出（传出值）。
函数式风格优点
1、代码简洁
通常情况下，函数式编程更加简明扼要，精简的代码更易于维护。而Java代码的冗余性也是出了名的，大部分对于Java语言的攻击都会直接针对Java繁琐，而且死板的语法（不过这也不是缺点），然而，引入函数式编程范式后，这种情况发生了改变。我们可以让Java用更少的代码完成更多的工作。
代码块
Java
static int[] arr = {1,3,4,5,6,7,8,9,10};
//传统的处理方式：
for(int i=0;i<arr.length;i++){
if(arr[i]%2 != 0){
arr[i]++;
}
System.out.println(arr[i]);
}
//函数式处理方式：
arr.stream().map(x->(x%2==0?x:x+1)).foreach(System.out::println);
2、易于多线程
由于对象都处于不变的状态，因此函数式编程更加易于并行。实际上，你甚至完全不用担心线程安全的问题。我们之所以要关注线程安全，一个很大的原因是当多个线程对同一个对象进行写操作时，容易“使得对象状态不一致”。但是，由于不变模式的存在，对象自创建以来，就不可能发生改变，因此，在多线程环境下，也就没有必要进行任何同步操作。这样不仅有利于并行化，同时，在并行化后，由于没有同步和锁机制，其性能也会比较好。例如java.lang.String对象。很显然，String对象可以在多线程中很好的工作，但是，得益于不变模式，它的每一个方法都没有进行同步处理。
3、可读性更高
函数式编程风格只需要声明计算机需要干什么事，而不是像命令式风格一样将计算机的操作具体到每一步，所以可读性会更高。
常用Lambda表达式
1.替代匿名内部类
毫无疑问，lambda表达式用得最多的场合就是替代匿名内部类，而实现Runnable接口是匿名内部类的经典例子。lambda表达式的功能相当强大，用()->就可以代替整个匿名内部类！请看代码：
如果使用匿名内部类：
代码块
Java
@Test
public void oldRunable() {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("The old runable now is using!");
}
}).start();
}
而如果使用lambda表达式：
代码块
Java
@Test
public void runable() {
new Thread(() -> System.out.println("It's a lambda function!")).start();
}
2.使用lambda表达式对集合进行迭代
Java的集合类是日常开发中经常用到的，甚至说没有哪个java代码中没有使用到集合类。。。而对集合类最常见的操作就是进行迭代遍历了。请看对比：
代码块
Java
@Test
public void iterTest() {
List<String> languages = Arrays.asList("java","scala","python");
//before java8
for(String each:languages) {
System.out.println(each);
}
//after java8
languages.forEach(x -> System.out.println(x));
languages.forEach(System.out::println);
}
3.用lambda表达式实现map
一提到函数式编程，一提到lambda表达式，怎么能不提map。。。没错，java8肯定也是支持的。请看示例代码：
代码块
Java
@Test
public void mapTest() {
List<Double> cost = Arrays.asList(10.0, 20.0,30.0);
cost.stream().map(x -> x + x*0.05).forEach(x -> System.out.println(x));
}
map函数可以说是函数式编程里最重要的一个方法了。map的作用是将一个对象变换为另外一个。在我们的例子中，就是通过map方法将cost增加了0,05倍的大小然后输出。
4.用lambda表达式实现map与reduce
既然提到了map，又怎能不提到reduce。reduce与map一样，也是函数式编程里最重要的几个方法之一。。map的作用是将一个对象变为另外一个，而reduce实现的则是将所有值合并为一个，reduce方法允许我们用自己的方式去计算元素或者将一个Stream中的元素以某种规律关联
代码块
Java
@Test
public void mapReduceTest() {
List<Double> cost = Arrays.asList(10.0, 20.0,30.0);
double allCost = cost.stream().map(x -> x+x*0.05).reduce((sum,x) -> sum + x).get();
System.out.println(allCost);
}
最终的结果为：63.00
5.filter操作
filter也是我们经常使用的一个操作。在操作集合的时候，经常需要从原始的集合中过滤掉一部分元素。
代码块
Java
@Test
public void filterTest() {
List<Double> cost = Arrays.asList(10.0, 20.0,30.0,40.0);
List<Double> filteredCost = cost.stream().filter(x -> x > 25.0).collect(Collectors.toList());
filteredCost.forEach(x -> System.out.println(x));
}
最终结果：30 40
6.与函数式接口Predicate配合
除了在语言层面支持函数式编程风格，Java 8也添加了一个包，叫做 java.util.function。它包含了很多类，用来支持Java的函数式编程。其中一个便是Predicate，使用 java.util.function.Predicate 函数式接口以及lambda表达式，可以向API方法添加逻辑，用更少的代码支持更多的动态行为。Predicate接口非常适用于做过滤。
代码块
Java
public static void filterTest(List<String> languages, Predicate<String> condition) {
languages.stream().filter(x -> condition.test(x)).forEach(x -> System.out.println(x + " "));
}
public static void main(String[] args) {
List<String> languages = Arrays.asList("Java","Python","scala","Shell","R");
System.out.println("Language starts with J: ");
filterTest(languages,x -> x.startsWith("J"));
System.out.println("\nLanguage ends with a: ");
filterTest(languages,x -> x.endsWith("a"));
System.out.println("\nAll languages: ");
filterTest(languages,x -> true);
System.out.println("\nNo languages: ");
filterTest(languages,x -> false);
System.out.println("\nLanguage length bigger three: ");
filterTest(languages,x -> x.length() > 4);
}
可以看到，Stream API的过滤方法也接受一个Predicate，这意味着可以将我们定制的 filter() 方法替换成写在里面的内联代码。
7.Match（匹配）
用来判断某个predicate是否和流对象相匹配，最终返回Boolean类型结果，例如
代码块
JSON
List<String> list = new ArrayList<String>();
list.add("a1");
list.add("b1");
// 流对象中只要有一个元素匹配就返回true
boolean anyStartWithA = list.stream().anyMatch((s -> s.startsWith("a")));
System.out.println(anyStartWithA);
// 流对象中每个元素都匹配就返回true
boolean allStartWithA = list.stream().allMatch((s -> s.startsWith("a")));
System.out.println(allStartWithA);
8.Limit（限制）
imit 方法用于获取指定数量的流。 以下代码片段使用 limit 方法打印出 10 条数据：
代码块
JSON
@Test
public void streamSortedTest() {
Random random = new Random();
random.ints().limit(10).sorted().forEach(System.out::println);
}
9.compare（排序）
代码块
JSON
list.compare((a,b)->a-b); 升序
