关于Java函数式编程

最近在学习分布式治理框架，学习到服务调用模块时，了解到调用方式有1、同步调用； 2、异步调用；3、并发调用；其中并发调用可以使用到Fork/Join线程池的方式发起调用。第一次接触Fork/Join并发模式（以下简称FJ），所以就顺便了解下API。在试验FJ实现的二分排序时，打算用java.util.Random初始化一个数组，发现Random有生成stream的功能，我就很好奇，Random和Stream有什么关系。原来这里Stream和IO Stream是两码事，此Stream是操作流的的意思，进一步翻API和资料，原来这是JAVA实现Lambda函数式编程的一块内容。现在将今天翻阅的资料做个整理。

为啥要引入Lambda函数式编程，Lambda表达式的格式、java如何引入Lambda表达式的，这里很描述详细。

需要注意的是Lambda表达式里面This指的所包含的类，匿名类中的this是匿名类本身

点击打开链接

点击打开链接

这篇文章介绍了Java8引入了Interface的默认方法的原因：支持接口的扩展；带来的好处就是java.util.collection框架支持lambda函数表达式。

Interface引入default方法实现，同时也引入了多继承。但不支持Interface直接实例化对象，除非用在lambda表达式中

点击打开链接

这里有更多关于Lambda表达式使用的例子。不过我不认同作者说lambda表达式只是语法糖的说法，而是另一种编程思维方式。有利于扩大Java语言适用的领域

点击打开链接

经过测试，用stream来实现排序，效率时不高的。具体代码如下：

如果服务器CPU不多排序的数量级在万级以下，则使用Arrays.sort()足够了，如果服务器是多核的，且排序量大，只可以考虑使用递归并发排序。

package jdk;

import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.stream.LongStream;

public class ForkTaskTest {

	static class SortTask extends RecursiveAction {
		final long[] array;
		final int lo, hi;

		SortTask(long[] array, int lo, int hi) {
			this.array = array;
			this.lo = lo;
			this.hi = hi;
		}

		SortTask(long[] array) {
			this(array, 0, array.length);
		}

		protected void compute() {
			if (hi - lo < THRESHOLD)
				sortSequentially(lo, hi);
			else {
				int mid = (lo + hi) >>> 1;
				invokeAll(new SortTask(array, lo, mid), new SortTask(array,
						mid, hi));
				merge(lo, mid, hi);
			}
		}

		// implementation details follow:
		static final int THRESHOLD = 1000;

		void sortSequentially(int lo, int hi) {
			Arrays.sort(array, lo, hi);
		}

		void merge(int lo, int mid, int hi) {
			long[] buf = Arrays.copyOfRange(array, lo, mid);
			for (int i = 0, j = lo, k = mid; i < buf.length; j++)
				array[j] = (k == hi || buf[i] < array[k]) ? buf[i++]
						: array[k++];
		}
	}

	public static void main(String[] args) {
		ForkJoinPool pool = new ForkJoinPool();
		int i = 0;
		long[] array = new long[9999999];
		long[] a1 = new long[9999999];
		long[] a2 = new long[9999999];
		Random random = new Random();
		while(i<9999999){
			long randomLong = random.nextLong();
			array[i] = randomLong;
			a1[i] = randomLong;
			a2[i] = randomLong;
			i++;
		}
		
		SortTask task = new SortTask(array);
		Long start = System.currentTimeMillis();
		pool.invoke(task);
		Long end = System.currentTimeMillis();
		System.out.println(end - start);
		start = System.currentTimeMillis();
		Arrays.sort(a2);
		end = System.currentTimeMillis();
		System.out.println(end - start);
		
		LongStream stream = Arrays.stream(a1);
		start = System.currentTimeMillis();
		long[] a3 = stream.sorted().toArray();
		end = System.currentTimeMillis();
		System.out.println(end - start);
		
		long j = array[0];
		for(i=0;i<9999999;i++){
			
			if(array[i]!=a3[i]){
				System.err.println("not equal");
			}
			if(j > array[i]){
				
				System.err.println("not order");
			}
			j = array[i];
		}
	}

}

测试结果：

963     ---使用递归并发排序
1079   ---使用Arrays.sort, 这个算法比较稳定
1267   ---使用流式排序