Java8实战之Stream的延迟计算

Java8实战之Stream的延迟计算

目录一、函数式编程1.1 示例一：方法中没有任何操作会修改现有结构1.2 实例二：“尾-递”迭代二、科里化三、函数式数据结构——持久化的四、Stream的延迟计算4.1 列表接口4.2 延迟列表4.3 创建一个无限延迟的列表4.4 创建一个无限延迟的质数列表4.5 使用无限延迟的质数列表总结

一、函数式编程

要被称为函数式，函数或方法不应该抛出任何异常。使用Optional 类型作为返回值。

透明性：方法中没有任何操作会修改现有结构

使用java8进行编程时，尽量使用Stream取代迭代操作。如果递归可以更简洁，且不带副作用，应该使用递归替换迭代。

"尾-递"迭代，不需要在不同的栈桢上保存每次递归计算的中间值。目前Java不支持这种优化，很多的现代JVM语言，比如Scala和Groovy都支持这种形式递归迭代的优化。

1.1 示例一：方法中没有任何操作会修改现有结构

获取列表的子集：

public static List> findAllSubList(List list) {

if (list.size()==0) {

List> res = new ArrayList<>();

res.add(Collections.emptyList());

return res;

}

Integer first = list.get(0);

List subList = list.subList(1, list.size());

List> allSubList = findAllSubList(subList);

List> allSubList2 = insertAll(first, allSubList);

return concat(allSubList, allSubList2);

}

private static List> concat(List> allSubList, List> allSubList2) {

List> res = new ArrayList<>(allSubList);

res.addAll(allSubList2);

return res;

}

private static List> insertAll(Integer item, List> allSubList) {

List> res = new ArrayList<>();

for (List a : allSubList) {

List oneList = new ArrayList<>(a);

oneList.add(item);

res.add(oneList);

}

return res;

}

1.2 实例二：“尾-递”迭代

求n的阶乘：

方案一：迭代

/**

* 使用迭代计算阶乘

* r 和 i 在每轮迭代中都会更新

* @param n

* @return

*/

public static int factorialIterator(int n) {

int r = 1;

for (int i=1; i<=n; i++) {

r *= i;

}

return r;

}

方案二：使用递归

/**

* 使用递归 计算阶乘

* 比迭代都效率差：因为每次递归都需要创建栈桢

* @param n

* @return

*/

public static int factorialRecursive(inDtfIrQrt n) {

return n==1? 1 : n * factorialIterator(n-1);

}

方案三：使用Stream

/**

* 使用Stream 计算阶乘

* @param n

* @return

*/

public static int factoriDtfIrQralStream(int n) {

return IntStream.rangeClosed(1, n).reduce(1, (x, y)->x*y);

}

方案四：递归的优化：“尾-递”迭代

/**

* 尾-递 迭代

* @param n

* @return

*/

public static int factorialTailIterator(int n) {

return factorialTailHelp(1, n);

}

/**

* 尾-递 迭代递帮助类

* @param acc

* @param n

* @return

*/

private static int factorialTailHelp(int acc, int n) {

return n==1?acc:factorialTailHelp(acc*n, n-1);

}

二、科里化

科里化：帮助你模块化函数，提高代码重用性的技术。

科里化表示一种将一个带有n元组参数的函数转换成n个一元函数链的方法。

三、函数式数据结构——持久化的

数据结构的值始终保持一致，不受其他部分变化的影响。

附加条件：所有使用持久化数据结http://构的用户都必须遵守这一“不修改“原则。不对返回值就行修改。

四、Stream的延迟计算

创建一个质数列表：

4.1 列表接口

/**

* @Date 2021/9/5

* @Author lifei

*/

public interface MyList {

T head();

MyList tail();

MyList filter(Predicate p);

default boolean isEmpty() {

return true;

}

}

4.2 延迟列表

public class LazyList implements MyList {

final T head;

final Supplier> tail;

public LazyList(T head, Supplier> tail) {

this.head = head;

this.tail = tail;

}

@Override

public T head() {

return head;

}

@Override

public MyList tail() {

return tail.get();

}

@Override

public DtfIrQrMyList filter(Predicate p) {

return isEmpty()?this:p.test(head())? new LazyList<>(head, ()->tail().filter(p)):tail().filter(p);

}

@Override

public boolean isEmpty() {

return false;

}

}

4.3 创建一个无限延迟的列表

/**

* 创建一个无限延迟的列表

* @param n

* @return

*/

public static LazyList from(int n) {

return new LazyList<>(n, ()->from(n+1));

}

4.4 创建一个无限延迟的质数列表

/**

* 创建一个无限循环的 质数列表

* @param numbers

* @return

*/

public static MyList primes(MyList numbers) {

return new LazyList<>(numbers.head(), ()->primes(numbers.tail().filter(n->n%numbers.head()!=0)));

}

4.5 使用无限延迟的质数列表

public static void main(String[] args) {

LazyList numbers = from(2);

Integer res2 = numbers.head();

Integer res3 = numbers.tail().head();

Integer res4 = numbers.tail().tail().head();

System.out.println(res2);

System.out.println(res3);

System.out.println(res4);

System.out.println("创建一个无限延迟的质数列表");

MyList primes = primes(numbers);

for (int i=0; i<30; i++) {

if (!primes.isEmpty()){

System.out.print(primes.head() + ", ");

primes = primes.tail();

}

}

System.out.println();

}

总结

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。