JAVA8函数式编程
因为在写业务代码时写了很多的循环筛选语句，而JAVA8提供了函数式编程的方法，支持对集合框架的stream处理，大大简化了代码，学习了一下，总结如下。
1、什么是函数式编程

函数式编程指的是一种编程范式，它将计算描述为一种表达式求值，函数式编程关心的是数据（代数结构的映射关系）。

函数式编程中的函数不是指命令式编程中的函数，而是指数学中的函数，即自变量的映射（一种东西和另一种东西之间的对应关系）。也就是说，一个函数的值仅决定于函数参数的值，不依赖于其他状态。

2、JAVA8中的函数式编程

1)  Lambda表达式:JAVA8为支持函数式编程引入的新语法，而为了支持lambda表达式，才有了函数式接口。

2）函数式接口：指的是有且只有一个未实现方法的接口，一般通过FunctionalInterface这个注解来表明某个接口是一个函数式接口。函数式接口是Java支持函数式编程的基础。
lambda表达式例子：

以建立线程为例，JAVA8之前建立线程通常的写法是这样的：
new Thread(new Runnable(){
            @Override
            public void run(){
                System.out.println("Hello world");
            }
        }).start();

使用lambda表达式后：
new Thread(()->System.out.println("Hello Helleo")).start();

lambda表示式解析：

一般形式：

（parameter1，parameter2…parametern）->{函数体}

输入：->前面的部分，即被()包围的部分。可以有0个到多个参数，如两个参数时写法：(a, b);当然也可以没有输入，此时直接就可以是()。
函数体：->后面的部分，即被{}包围的部分；可以是一段代码。
输出：函数式编程可以没有返回值，也可以有返回值。如果有返回值时，需要代码段的最后一句通过return的方式返回对应的值。

如果函数体里只有一个语句的时候，可以省略掉{}。
JAVA提供常见的几种函数式编程的接口：

Supplier: 数据提供器，可以提供 T 类型对象；无参的构造器，提供了 get 方法；
Function<T,R>: 数据转换器，接收一个 T 类型的对象，返回一个 R类型的对象； 单参数单返回值的行为接口；提供了 apply, compose, andThen, identity 方法；
Consumer: 数据消费器， 接收一个 T类型的对象，无返回值，通常用于设置T对象的值； 单参数无返回值的行为接口；提供了 accept, andThen 方法；
Predicate: 条件测试器，接收一个 T 类型的对象，返回布尔值，通常用于传递条件函数； 单参数布尔值的条件性接口。提供了 test (条件测试) , and-or- negate(与或非) 方法。

函数式编程的使用：

先来了解一下JAVA8中的Stream，Stream是Java 8新增的接口，Stream可以认为是一个高级版本的 Iterator。它代表着数据流，流中的数据元素的数量可以是有限的，也可以是无限的。

Stream跟Iterator的差别是：

无存储：Stream是基于数据源的对象，它本身不存储数据元素，而是通过管道将数据源的元素传递给操作。
函数式编程：对Stream的任何修改都不会修改背后的数据源，比如对Stream执行filter操作并不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新的Stream。
延迟执行：Stream的操作由零个或多个中间操作（intermediate operation）和一个结束操作（terminal operation）两部分组成。只有执行了结束操作，Stream定义的中间操作才会依次执行，这就是Stream的延迟特性。
可消费性：Stream只能被“消费”一次，一旦遍历过就会失效。就像容器的迭代器那样，想要再次遍历必须重新生成一个新的Stream。

Stream对象的创建

1）创建空的Stream对象
 Stream stream = Stream.empty();

2 通过集合类的stream或者parallelStream方式创建
List<Integer> list = Arrays.asList(1,2,3,4,5);
//串行处理的Stream对象
Stream IntegerStream = list.stream();
//并行处理的Stream对象
Stream parallelStream = list.parallelStream();

3）通过Stream类中的of方法创建
Stream s1 = Stream.of("tttt", "dddd", "cccc", "dooo");

常见的Stream的操作：

forEach()：使用该方法迭代流中的每个数据

例子：
List<Student> list = Arrays.asList(
                // name，age
                new Student("李丽", 19),
                new Student("王浩", 20),
                new Student("王宇", 18),
                new Student("张路", 17),
                new Student("李明", 22),
                new Student("李之为", 25),
                new Student("李寒", 21)
        );
        list.forEach(student -> System.out.println(student));

    }
}
      class Student{
                private String name;
                private int age;

                Student(String name,int age){
                   this.name = name;
                   this.age = age;
                }

                public String getName() { return name; }

                public void setName(String name) { this.name = name; }

                public int getAge() { return age; }

                public void setAge(int age) { this.age = age; }
                
                @Override
                public String toString(){
                    return this.getName()+"   "+this.getAge();
                }


控制台输出



sorted() ：使用该方法排序数据
list.stream().sorted((student1,student2)->student1.getAge()-student2.getAge()).forEach(student -> System.out.println(student));


一行代码就可以解决。

控制台输出

未排序前



排序后



filter()：过滤操作
list.stream().filter((student) -> student.getAge() > 20).forEach(student -> System.out.println(student));

未过滤前



过滤后



limit:使用该方法截取原Stream
list.stream().limit(3).forEach(student -> System.out.println(student));

未截断前



截断后



skip()：与limit互斥，使用此方法跳过元素
list.stream().skip(2).forEach(student -> System.out.println(student));

跳过前



跳过后：


distinct()：使用该方法去重，注意：必须重写对应泛型的hashCode()和equals()方法****
 List<Student> list = Arrays.asList(
                // name，age
                new Student("李丽", 19),
                new Student("王浩", 20),
                new Student("王宇", 18),
                new Student("张路", 17),
                new Student("李明", 22),
                new Student("李之为", 25),
                new Student("李寒", 21),
                new Student("李丽",25),
                new Student("李明",21)

        );


        list.stream().distinct().forEach(student -> System.out.println(student));
 class Student{
                private String name;
                private int age;

                Student(String name,int age){
                   this.name = name;
                   this.age = age;
                }

                public String getName() { return name; }

                public void setName(String name) { this.name = name; }

                public int getAge() { return age; }

                public void setAge(int age) { this.age = age; }

                @Override
                public String toString(){
                    return this.getName()+"   "+this.getAge();
                }

                @Override
                public int hashCode(){
                    return 1;
                }

                @Override
                public boolean equals(Object stu){
                    Student student = (Student)stu;
                    return  this.name.equals(student.getName());
                }

去重前



去重后



max，min，sum，avg，count ：聚合操作
IntSummaryStatistics intSummaryStatistics = list.stream().mapToInt(s -> s.getAge()).summaryStatistics();
        //学生人数
        System.out.println("count：" + intSummaryStatistics.getCount());
        //学生平均年龄
        System.out.println("average：" + intSummaryStatistics.getAverage());
        //学生中的最大年龄
        System.out.println("maxAge：" + intSummaryStatistics.getMax());
        //学生中的最小年龄
        System.out.println("minAge：" + intSummaryStatistics.getMin());
        //学生的年龄总和
        System.out.println("sumAge：" + intSummaryStatistics.getSum());



map()：接收一个方法作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
 List<String> strList = Arrays.asList("abd","rgt","uudj","ssee");
        System.out.println("转化前");
        strList.stream().forEach(str->System.out.println(str));
        System.out.println("转化后");
    

List<String> transStrList = strList.stream().map(str->str.toUpperCase()).collect(toList());
    transStrList.stream().forEach(str->System.out.println(str));


控制台输出



**collect(toList())：**将Stream转换成List
List<String> transStrList = strList.stream().map(str->str.toUpperCase()).collect(toList());

什么是函数式编程
在介绍函数式编程前，先了解一下平时我们所使用命令式编程，命令式编程是告诉计算机如何一步一步执行编程风格。
比如我们要在一个苹果的对象集合中筛选出颜色为红色的苹果集合。我们需要写以下代码：
创建存储苹果的集合list
遍历这个集合
判断苹果颜色是不是为红色，如果满足条件，加入结果集合
public static List getRedAppleDeclarative(List apples) {
List results = new ArrayList<> ();
for (Apple apple : apples) {
if("red".equals (apple.getColor ())){
results.add (apple);
}
}
return results;
}
那么函数式编程是怎样进行操作的呢？函数式编程类似于我们的sql语句
select * from table where 条件语句
只声明我想要什么，以及条件即可
public static List getRedAppleFunctional(List apples) {
return apples.stream ().filter (apple -> "red".equals (apple.getColor ())).collect (Collectors.toList ());
}
可以看到通过函数式编程大大简化了代码语句，同时如果对函数式结构熟悉的话，很快便可知道这段代码的含义:stream获取apples集合流-filter过滤满足的条件-collect转化为list输出
相比于繁琐的命令式代码，我们函数式编程可以令代码瞬间充满小清新学院风，话不多说，赶紧学习起来以备下次装B之需吧。
通过与数学函数的对比加深理解函数式编程
我们都知道数学的中函数思想，比如根据输入x求的y的值，我们用数学函数表示 y=f(x) = x+10, x为输入，以x+10为结果做为条件
那么用java函数式编程风格可以表示为
Function function = (x)->{return x+10;};
具体调用：
public static Integer calculate(Function function){
return function.apply (10);
}
public static void main(String[] args) {
Function function = (x)->{return x+10;};
Integer result = calculate (function);
}
在上面的代码中我们看到，main函数中我们定义的function 就是数学中的函数f(x) ,我们把定义好的函数传给方法caculate， caculate中function.apply(10)就相当于我们调用了数学函数f(10).
lambda表达式
我们上面Function接口来表达数据函数f(x) = x+10,这个function就是一个lambda表达式,lamdba表达式由参数箭头和主体构成，基本语法为: (参数)->表达语句
使用lamdba的好处是非常直观，编程者的意图十分明显的表现在lambda表达式里。
java8为lambda是使用提供了一个function包，提供lambda接口,比如上面我们使用过的Function接口，它的定义是
@FunctionalInterface
public interface Function {
/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
default  Function compose(Function super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
...
}
可以看到在Function接口中，除了default修饰的方法外，接口中只能有一个方法apply，这也是使用lambda接口的必要条件。他表示给定一个输入T，返回一个输出R，使用lamdba接口时，我们使用表达式来表示实现接口的唯一方法apply()
Function function = (x)->{
System.out.println("x : "+ String.valueof(x));
return x+10;
};
lambda表达式的另一种表现形式为 lambda方法引用：
lambda方法引用 通过描述符号 :: 来区分类和方法 ::前面是类名;后面是方法，但是不加括号
//lamdba
Predicate q = (String a) -> {
return a.isEmpty ();
};
使用方法引用来表示的话：
Predicate p = String::isEmpty;
具体调用：
public class LambdaTest {
public static void lambdaFunc(Consumer consumer, Predicate predicate,String test) {
boolean condition = predicate.test ("");
if(condition){
consumer.accept (test);
}
}
public static void main(String[] args) {
Predicate p = String::isEmpty;
Consumer c = System.out::println;
lambdaFunc (c,p,"test");
}
}
上面代码表示如果方法参数test不为空,则进行打印
lambda引用还包括 代替函数式接口和构造函数引用
代替函数式接口:
例1：
List testList = Arrays.asList ("a", "b", "A", "B");
// testList.sort ((s1, s2) -> s1.compareToIgnoreCase (s2));
testList.sort (String::compareToIgnoreCase);
System.out.println (testList);
例2：
public static void main(String[] args) {
// Function f1 = (String a) -> {return Integer.valueOf (a);};
Function f2 = Integer::valueOf;
Integer result = f2.apply ("2");
System.out.println (result);
}
Function中的泛型 String代表返回类型，Integer代表输入类型，在lambda引用中会根据泛型来进行类型推断。
构造函数引用:
//方法引用之构造函数引用
public void constructQuote(){
// Supplier s1 = () -> new QuoteClass ();
Supplier s2 = QuoteClass::new;
}
例子中Supplier 返回一个泛型中类的实例。
以上是函数式编程和lambda的介绍，接下来我们会对java中的stream进行分析，其中涉及的大量的函数式编程的使用。

目录

1、Java原型

2、高阶函数简化Java函数

2.1、::  的作用

3、匿名函数简化Java函数

4、Lambda简化Java函数

1、Java原型

现在假设这么一种情况，我们有一个人员的List我们需要筛选出这个List中年龄大于指定年龄的人的List，那么先来看一下普通实现。

fun main() {
    //模拟出人员List
    val personList = mutableListOf<Person>()
    repeat(10) {
        if (it % 2 == 0) {
            personList.add(Person("小子$it", 13 + it, "男"))
        } else {
            personList.add(Person("小子$it", 13 + it, "女"))
        }
    }

    val needList = needPersonList(personList, 18)
    println("needList=$needList")
}

fun needPersonList(list: List<Person>, needAge: Int): List<Person> {
    val needList = mutableListOf<Person>()
    for (person in list) {
        if (person.age > needAge) {
            needList.add(person)
        }
    }
    return needList
}
//输出结果
needList=[Person(name=小子6, age=19, sex=男), Person(name=小子7, age=20, sex=女),
 Person(name=小子8, age=21, sex=男), Person(name=小子9, age=22, sex=女)]

2、高阶函数简化Java函数

现在我们有这么一种情况，我不仅想要筛选出年龄大于指定年龄的人，性别也要筛选，如果用上面的方法的话，我们需要再添加一个参数，还要在函数中再添加一层判断如下：

fun needPersonList0(list: List<Person>, needAge: Int, sex: String): List<Person> {
    val needList = mutableListOf<Person>()
    for (person in list) {
        if (person.age > needAge && person.sex == sex) {
            needList.add(person)
        }
    }
    return needList
}

如果以后不断的添加判断条件，我们就需要不断的对这个函数进行重写，那么怎么解决这种情况，高阶函数可以帮助我们解决这种情况的出现，高阶函数就是该函数的参数也是函数，具体可以看这里。

改进的代码如下：可以看到我们可以在另一个函数isAgeAndSex()中随意更改筛选条件但是都不影响我们needPersonList()的代码。

fun main() {
   //模拟出人员List
    val personList = mutableListOf<Person>()
    repeat(10) {
        if (it % 2 == 0) {
            personList.add(Person("小子$it", 13 + it, "男"))
        } else {
            personList.add(Person("小子$it", 13 + it, "女"))
        }
    }

    val isAgeSex = ::isAgeAndSex
    val needList2 = needPersonList1(personList, isAgeSex)
    println("needList2=$needList2")
}

fun isAgeAndSex(person: Person): Boolean {
    return person.age > 18 && person.sex == "女"
}

fun needPersonList1(list: List<Person>, need: (person: Person) -> Boolean): List<Person> {
    val needList = mutableListOf<Person>()
    for (person in list) {
        if (need(person)) {
            needList.add(person)
        }
    }
    return needList
}
//输出结果
needList2=[Person(name=小子7, age=20, sex=女), Person(name=小子9, age=22, sex=女)]

2.1、::  的作用

你看到上面的双引号肯定很困惑，它是干什么用的呢？它有引用的作用，就是将一个函数引用过来，作为参数的形式传给另一个函数。

就比如上面的情况，我们无法直接将isAgeAndSex()函数作为参数传给needPersonList()函数，只能通过函数引用的方式。他还有其他作用。

通过下面的例子，我们看的出来：双引号前面的是函数的参数，后面的是返回的值

参数 ：：返回值

   //这里的getPerson等于函数 getPerson(name:String,age:Int,sex:String) -> Person
    val getPerson = ::Person
    println(getPerson("小白", 18, "男"))
    //这里的getName等于函数 getName(person:Person) -> String
    val getName = Person::name
    println(getName(Person("小女", 19, "女")))
  //输出结果
   Person(name=小白, age=18, sex=男)
   小女

3、匿名函数简化Java函数

如果我不想为了写一个筛选条件，单独写一个isAgeAndSex()函数的话，我们怎么怎么做，这里匿名函数可以帮我们解决这个问题，匿名函数：没有名字的函数。

看下面的代码，我们不需要单独创建一个函数，只需要在参数中直接将这个匿名函数加入进入就可以了。

fun main() {
    //模拟出人员List
    val personList = mutableListOf<Person>()
    repeat(10) {
        if (it % 2 == 0) {
            personList.add(Person("小子$it", 13 + it, "男"))
        } else {
            personList.add(Person("小子$it", 13 + it, "女"))
        }
    }

    val needList3 = needPersonList1(personList, fun(person: Person): Boolean {
        return person.age > 18 && person.sex == "女"
    })
    println("needList3=$needList3")

}

fun needPersonList1(list: List<Person>, need: (person: Person) -> Boolean): List<Person> {
    val needList = mutableListOf<Person>()
    for (person in list) {
        if (need(person)) {
            needList.add(person)
        }
    }
    return needList
}
//输出结果
needList3=[Person(name=小子7, age=20, sex=女), Person(name=小子9, age=22, sex=女)]



4、Lambda简化Java函数

如果你了解Lambda函数的话，它是可以函数的标示fun 去掉，还可以帮我们去掉参数中的 fun(person: Person): Boolean 中的类型的，所以代码我们就简化成了下面的版本，是不是很简洁，功能还比Java式的代码强大了很多啊？

fun main() {

    //模拟出人员List
    val personList = mutableListOf<Person>()
    repeat(10) {
        if (it % 2 == 0) {
            personList.add(Person("小子$it", 13 + it, "男"))
        } else {
            personList.add(Person("小子$it", 13 + it, "女"))
        }
    }

    val needList4 = needPersonList1(personList) { person ->
        person.age > 18 && person.sex == "女"
    }
    println("needList4=$needList4")
}
fun needPersonList1(list: List<Person>, need: (person: Person) -> Boolean): List<Person> {
    val needList = mutableListOf<Person>()
    for (person in list) {
        if (need(person)) {
            needList.add(person)
        }
    }
    return needList
}
//输出结果
needList4=[Person(name=小子7, age=20, sex=女), Person(name=小子9, age=22, sex=女)]

 

 

 

 

 

 

 

 

 

 

为了更清楚的理解为什么需要函数方法和Lambad，我们一步一步的以实际的场景案例来进行分析；

1.我们有很多钱，但是钱的面额有10,50,100，我们为了统计100元的有多少，我们的做法如下：

创建一个A类，A类有一个A'方法，该方法可以统计出100元的个数；

即该类将功能（筛选百元钞票的个数）进行了内嵌，如果需要则只需要创建该实例，调用该方法即可。

2.但当我们还需要筛选出特定要求的百元钞票的编号时，我们的做法如下：

1）基于A类，在A'方法上，进行一定的修改和扩充，实现筛选编号；

2）基于A类，写一个A''方法，实现钞票的筛选；

上面两个方法都只能解决少量的功能的实现，但是当需求增多时，则需会出现一个庞大的方法或者庞大的类；

同时为了遵循设计模式的基本原则：单一原则，一个类或者一个方法，尽可能的只负责一个功能；

我们的做法是：

使用一个B类，该类有一个功能，来实现统计百元钞票的个数，在使用该功能时，我们有以下做法：

1）我们常见创建一个B类实例，只需要将该对象传递给A类，作为A类某个方法的参数，然后在方法中调用B类的方法即可。（注意我们一般是创建一个接口，接口中有方法，然后创建需要的实现类）

3.当功能发生变动时，我们可以做如下改动：

1）在B类的基础上，对原有的方法进行修改；

2）在B类的基础上，创建一个新的方法；

2）创建一个新的类，实现新的功能；

4.当功能频繁变动，上面的方法的弊端就是需要修改或扩充类的方法，从而生成一个庞大的类，或者不停的创建一个新的类，但是对于这两种选择，我们选择横向扩展，即创建多个实现了单一功能的类，这样模块可以尽可能的小，但当进行调用的使用，我们又面临一个问题，即频繁的实例化类，对于不同的功能，我们需要显示的实例化不同的类，我们可以这样做：

1）使用匿名类，需要哪个类，当如果需要新的功能，直接在匿名类中写逻辑代码，但是会造成类的冗余

因此这个时候，Java8新的特性，思想是行为参数化，将一个行为作为参数传递给方法，从而应对频繁的需求改动：

注意：lambda行为参数化，只需要一个函数式接口（只有一个方法的接口），然后再调用的地方，可以直接写Lambda表达式，表达式可以实现同类功能的任意编写，即相同的返回值，只要返回值是接口定义方法的返回值，对于内部的逻辑实现，则可以自由编写，这样就不需要因为需求的变动而增加额外的类。可以将Lambda表达式，看做是函数式接口的实现。

5.当我们使用lambda时，我们通过表达式，有时候很难想起来该表达式实现了什么功能，为了更方便的识别方法的功能，Java8引入了方法引用：

方法引用可以看做是调用特定方法的一种快捷方式，它根据已有的方法创建Lambda表达式。

（ Java8新特性：在接口中可以定义默认方法和声明静态方法，并且可以实现。）

 

这是本人对Lambda表达式和方法引用的一些理解。

 

如有问题，敬请指出，谢谢观看，与君共勉。