# Java8实战之Stream的延迟计算

## 一、函数式编程

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

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

```    public static List> findAllSubList(List list) {
if (list.size()==0) {
List> res = new ArrayList<>();
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);
return res;
}

private static List> insertAll(Integer item, List> allSubList) {
List> res = new ArrayList<>();
for (List a : allSubList) {
List oneList = new ArrayList<>(a);
}
return res;
}
```

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

```    /**
* 使用迭代计算阶乘
* 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(int n) {
return n==1? 1 : n * factorialIterator(n-1);
}
```

```    /**
* 使用Stream 计算阶乘
* @param n
* @return
*/
public static int factorialStream(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);
}
```

## 四、Stream的延迟计算

### 4.1 列表接口

```/**
* @Date 2021/9/5
* @Author lifei
*/
public interface MyList {

MyList tail();

MyList filter(Predicate p);

default boolean isEmpty() {
return true;
}
}
```

### 4.2 延迟列表

```public class LazyList implements MyList {
final Supplier> tail;

public LazyList(T head, Supplier> tail) {
this.tail = tail;
}
@Override
public T head() {
}

@Override
public MyList tail() {
return tail.get();
}

@Override
public MyList filter(Predicate 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) {
}
```

### 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();

}
```