函数式编程

函数式编程比较著名的语言有：haskell、Scala？可以避免掉面向对象编程的繁琐的问题

lamda表达式

lamda表达式的实现要求：SAM(Single Abstract Method)。只有一个抽象方法的接口被称为函数式接口，我们称它为函数式接口，只有函数式接口才可以被lamda使用。

public class Demo{
    public static void main(String args[]){
        IMessage msg=(str) -> {
            System.out.println("send message:"+str);
        };
    }
}
interface IMessage{
    public void send(String str);
}

annotation和非abstract（default）方法可以存在

@FunctionalInterface    //函数式接口
interface IMessage{
    public void send(String str);
    public default void print(){}//jdk1.8以后，default也是为了lamda表达式提供出来的
}

所以，lamda表达式有如下格式：
1.方法没有参数：()->{};
2.方法有参数：(parameter1,parameter2)->{};
3.如果现在只有一行语句返回：(parameter1,parameter2)->sentence;

方法引用

不同的方法名称可以描述同一个方法，如果要进行方法引用Java中有四种：
1.引用静态方法：类名称 :: static 方法名称;
2.引用某个实例化对象的方法：实例化对象 :: 普通方法;
3.引用特定类型的方法：特定类 :: 普通方法;
4.引用构造方法：类名称 :: new;
例：1.

public class QuoteMethod {
    public static void main(String args[]){
        IChange<Integer,String> fun=String :: valueOf;//?question
        String str=fun.change(100);
        System.out.println(str);
    }
}
@FunctionalInterface
interface IChange<P,R>{
    public R change(P p);
}

public class QuoteMethod {
    public static void main(String args[]){
        IChange<String> fun="String" :: toUpperCase;
        System.out.println(fun.change());
    }
}
@FunctionalInterface
interface IChange<R>{
    public R change();
}

public class QuoteMethod {
    public static void main(String args[]){
        IChange<String> fun=String :: compareTo;
        System.out.println(fun.change("a","A"));
    }
}
@FunctionalInterface
interface IChange<P>{
    public int change(P p1,P p2);
}

4.方法引用中最具有杀伤力的

public class QuoteMethod {
    public static void main(String args[]){
        IChange<Person> fun=Person :: new ;
        System.out.println(fun.pilfer("mike",18));
    }
}
class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String toString(){
        return this.name+"—— "+this.age;
    }
}
@FunctionalInterface
interface IChange<R>{
    public R pilfer(String str,int age);
}

函数引用可以为一个方法定义多个名字，但是必须用函数式接口
……然而……

内建函数式接口

为了方便可以使用系统提供的大量的函数式接口
比如包：“java.util.function”中有可直接使用的函数式接口，有如下几个核心接口可供使用：
1.功能型函数式接口：
接口定义：

@FunctionalInterface
public interface Function<T,​R>{
    public R apply​(T t);
}

接口使用：

import java.util.function.*;
public class QuoteMethod {
    public static void main(String args[]){
        Function<String,Boolean> fun= "open" :: startsWith ;
        System.out.println(fun.apply("o?"));
    }
}

2.消费型函数式接口：（只能进行数据的处理而没有返回）
System.out.println();
接口定义：

@FunctionalInterface
public interface Consumer<T>{
    public void	accept​(T t);
}

接口使用：

import java.util.function.*;
public class QuoteMethod {
    public static void main(String args[]){
        Consumer<String> con= System.out :: println ;
        con.accept("out");
    }
}

3.供给型函数式接口：（没有接收参数，有返回值）
public String toLowerCase();
接口定义：

@FunctionalInterface
public interface Supplier<T>{
	public T get();
}

接口实现：

import java.util.function.*;
public class QuoteMethod {
    public static void main(String args[]){
        Supplier<String> sup= "STRING" :: toLowerCase ;
        System.out.println(sup.get());
    }
}

4.断言型函数式接口：（进行判断处理）
接口实现：

@FunctionalInterface
public interface Predicate<T>{
	public boolean test​(T t);
}

接口实现：

import java.util.function.*;
public class QuoteMethod {
    public static void main(String args[]){
        Predicate<String> pre= "STRING" :: equalsIgnoreCase ;
        System.out.println(pre.test("string"));
    }
}

……?