Java 函数式编程合集

前言

    很多编程语言可以把函数当作参数进行传递，例如js中事件触发后的函数调用、C语言中的函数指针，都可以完成函数的传递。但是在Java里一直没有一个传函数的标准，直到jdk8开始，有了函数传递的一套规范。

1. lambda表达式

1.1 支持版本

    JDK8及以上

1.2 概念

    也叫箭头函数，得益于javac的类型推断，编译器能够根据上下文信息推断出参数的类型。本质上是一个可传递的匿名函数，但是区别于匿名内部类，它不会编译出额外的类，例如 Main$1.class

1.3 基本语法

    

基本形式：parameter -> expression

完整形式：(Type parameter1, Type parameter2) -> { code block； return result; }

省略参数类型: (parameter1, parameter2) -> { code block； return result; }

单参数省略参数括号：parameter -> { code block； return result; }

只有一句表达式省略方法体括号：(Type parameter1, Type parameter2) -> expression

1.4 省略关键

    小括号内参数的类型可以省略
    如果小括号内有且仅有一个参数，则小括号可以省略
    如果方法体大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及分号

1.5 注意事项

        lambda表达式一般用作接口的实现上，用于简化代码。

new Thread(new Runnable() {
    @Override
    public void run() {
    }
});//通过匿名内部类创建Runnable接口实现类作为Thread的参数

new Thread(() -> {
});//通过Labmda表达式创建Thread的参数

// Thread一定是只有一个抽象方法

        lambda表达式往往是使用在方法内部的方法，因此lambda表达式里面声明的基本类型变量都会分配到栈上，每个都是线程安全的，因为栈上的变量不共享。如果lambda表达式方法内部需要修改外部变量的状态，这个变量要保证是在堆上分配，且要注意线程安全问题。 

2. 接口式函数

2.1 支持版本

    JDK8及以上

2.2 概念

    JDK8新增了@FunctionalInterface，用来标注一个接口是符合“函数式”的。即，自定义接口有且只有一个抽象方法（可以理解为，创建此接口的对象只要实现一个方法即可，可能因为lambda只能有一个函数），就认为这个接口是符合函数式的，可以使用lambda语法。

2.3 基本语法

    定义一个普通接口，再定义一个抽象方法即可。这里强调因为JDK8版本的接口可能不止有抽象方法，还能有默认方法和静态方法，这些特性在JDK7里是不存在的。

2.4 default、static

    JDK8的新特性，接口可以定义方法的实现了。default修饰的方法叫默认方法，这种方法不需要手动实现，也不会报错，如果默认方法不能满足需求，重写就好了。
    JDK8的新特性，接口支持定义static方法，调用方法和普通静态方法调用一样：接口名.静态方法名。但是要注意，接口的实现类是没有这个静态方法的。强行调用会报错：This static method of interface 接口名 can only be accessed as 接口名.静态方法名

2.5 示例代码

@FunctionalInterface
public interface Operator {

	int operation(int a, int b);
	
	default void sayHello() {
		System.out.println("Hello everyone.");
	}
	
	static void sayBye() {
		System.out.println("Bye everyone.");
	}
}

3. 函数式编程

3.1 支持版本

    JDK8及以上

3.2 概念

    函数像变量一样使用，能当作入参也能作为返回函数

3.3 实现思路

        借助“接口式函数”和lambda表达式，创建一个函数的调用句柄，参数列表处用接口式函数作为入参，方法体里用接口的唯一抽象方法执行业务逻辑。

3.3 示例代码

3.1 接口部分

// 添加FunctionalInterface注解，表示这是一个方法式接口，不加也行，加上可以让编译器检查语法
// 建议添加，以防他人修改接口
@FunctionalInterface
public interface Operator {

    // 只有这个方法是抽象的
	int operation(int a, int b);
	// 默认方法，子类可以不实现直接用，不满足需求可以重写
	default void sayHello() {
		System.out.println("Hello everyone.");
	}
	// 静态方法，子类不可用，只能 Operator.sayBye()
	static void sayBye() {
		System.out.println("Bye everyone.");
	}
}

 3.2 接口式函数及调用

public class CalculateDemo {

	public static void main(String [] s) {
		
		/**
		 * define anonymous function
		 */
		// +
		Operator add = (int a, int b) -> a+b;
		// FunctionTest 未省略方法体的括号及返回 = (int a, int b) -> {return a+b;};
		// -
		// Operator subtract = (int a, int b) -> a-b;
		// *
		// Operator multiply = (int a, int b) -> a*b;
		// /
		// Operator divide = (int a, int b) -> a/b;
		// %
		// Operator mod = (int a, int b) -> a%b;
		// 定义入参
		int a = 10;
		int b = 2;
        // 调用计算函数时，把操作函数传过去，这里就测了一个相加的
        // add可以看作是一个函数，但是它还是一个对象
		calculate(add, a,  b);
	}

	private static void calculate(Operator oper, int a, int b) {
		// 调用default方法，没重写过的
        oper.sayHello();
        // 实际上是调用的Operator对象的那个抽象方法
		int result = oper.operation(a,b);
		System.out.println(result);
//		oper.sayBye(); 报错：This static method of interface Operator can only be accessed as Operator.sayBye
        // 静态方法只能这样调用，子类是调用不到的
		Operator.sayBye();
		
	}
	
}

4.java.util.function包主要类

        4.1 - 4.4 示例代码均来自Java8之Consumer、Supplier、Predicate和Function攻略 - 掘金

4.1 Supplier

4.1.1 概念

        provider，只出不入的一个类型，负责对外提供数据，类似信号发生器、工厂。

4.1.2 示例代码

    @Test
    public void test_Supplier() {
        //① 使用Supplier接口实现方法,只有一个get方法，无参数，返回一个值
        Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                //返回一个随机值
                return new Random().nextInt();
            }
        };

        System.out.println(supplier.get());

        System.out.println("********************");

        //② 使用lambda表达式，
        supplier = () -> new Random().nextInt();
        System.out.println(supplier.get());
        System.out.println("********************");

        //③ 使用方法引用
        Supplier<Double> supplier2 = Math::random;
        System.out.println(supplier2.get());
    }

4.2 Consumer 

4.2.1 概念

        consumer，消费者，只入不出。负责使用数据，并不会返回。

4.2.2 示例代码

    @Test
    public void test_Consumer() {
        //① 使用consumer接口实现方法
        Consumer<String> consumer = new Consumer<String>() {

            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        Stream<String> stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
        stream.forEach(consumer);

        System.out.println("********************");

        //② 使用lambda表达式，forEach方法需要的就是一个Consumer接口
        stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
        Consumer<String> consumer1 = (s) -> System.out.println(s);//lambda表达式返回的就是一个Consumer接口
        stream.forEach(consumer1);
        //更直接的方式
        //stream.forEach((s) -> System.out.println(s));
        System.out.println("********************");

        //③ 使用方法引用，方法引用也是一个consumer
        stream = Stream.of("aaa", "bbb", "ddd", "ccc", "fff");
        Consumer consumer2 = System.out::println;
        stream.forEach(consumer);
        //更直接的方式
        //stream.forEach(System.out::println);
    }

4.3 Predicate

4.3.1 概念 

        直译是谓词，理解为判断器就行了。有输入有输出，但是输出一定是bool型。

4.3.2 示例代码

   @Test
    public void test_Predicate() {
        //① 使用Predicate接口实现方法,只有一个test方法，传入一个参数，返回一个bool值
        Predicate<Integer> predicate = new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                if(integer > 5){
                    return true;
                }
                return false;
            }
        };

        System.out.println(predicate.test(6));

        System.out.println("********************");

        //② 使用lambda表达式，
        predicate = (t) -> t > 5;
        System.out.println(predicate.test(1));
        System.out.println("********************");

    }

4.4 Functional

 4.4.1 概念

        有输入有输出，且类型可以自定义的一个类型。

4.4.2 示例代码

   @Test
    public void test_Function() {
        //① 使用map方法，泛型的第一个参数是转换前的类型，第二个是转化后的类型
        Function<String, Integer> function = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();//获取每个字符串的长度，并且返回
            }
        };

        Stream<String> stream = Stream.of("aaa", "bbbbb", "ccccccv");
        Stream<Integer> stream1 = stream.map(function);
        stream1.forEach(System.out::println);

        System.out.println("********************");

    }

4.5 整体示例代码 

    @Test
    public void testFunctions() {
    	
    	// provider.get
    	Supplier<Integer> s  = () -> new Random().nextInt();
        
    	// consumer.accept
        Consumer<String> c = System.out::println;
        
        // provide
        Integer integer = s.get();
        
        // functional
        Function<Integer, String> f = i -> {
        	if (i >= 0) {
        		return "functional判断为正整数";
        	} else {
        		return "functional判断为负数";
        	}
        };
        
        // function
        c.accept(f.apply(integer));
        
        // judgment.test
        Predicate<Integer> p = (i) -> i>0;
        c.accept(integer+"");
        
        // predicate
        if (p.test(integer)) {
        	c.accept("predicate判断为正整数");
        } else {
        	c.accept("predicate判断为负数");
        }
    }

5. 总结

        Java的这个函数式编程，总感觉还是很拗，说是传递的函数，实际上是传递函数所属的对象，然后调用接口，并不是纯的传递函数，只不过是借助lambda简化了一下写法，或者是终于官方提供了一个“传函数”的规范。

        最大的好处是能通过Stream方便的处理数据，且性能更好。

6 . 示例

6.1 两次循环过滤数据

public class Test1 {

	public static void main(String[] args) {
		// 字典
		List<Integer> l1 = new ArrayList<Integer>();
		l1.add(3);
		l1.add(4);

		// 数据集合
		List<T> l2 = new ArrayList<T>();
		l2.add(new T(1, "one"));
		l2.add(new T(2, "two"));
		l2.add(new T(3, "three"));
		l2.add(new T(4, "four"));
		l2.add(new T(5, "five"));
		l2.add(new T(6, "six"));
		l2.add(new T(7, "seven"));
		l2.add(new T(8, "eight"));
		
		// 判断哪些对象是在字典中
        // 先把数据集合转化成流，开始循环
		List<T> nl2 = l2.stream().filter(tItem -> {
            // 把字典转换成流，并判断是否和数据流中有匹配
			return l1.stream().anyMatch(i -> tItem.key == i);
        // 把过滤后的数据返回给一个新的数据集合
		}).collect(Collectors.toList());
		
		nl2.stream().forEach(i -> {
			System.out.println(i.key+"---"+i.value);
		});
	}
}

class T {
	
	public T(Integer key, String value) {
		super();
		this.key = key;
		this.value = value;
	}
	public Integer key;
	public String value;
}