超越Java8:Stream的延迟盘算

倨傲的王者

逾越Java8:Stream的提早策画


文章目录

• 逾越Java8:Stream的提早策画
  
• 
  
  
  
  • 1、函数式编程
    
  • 
    
    
    
    • 1.1 示例一：办法中出有任何操纵会修正现有构造
      
    • 1.2 真例两：“尾-递”迭代
      
    • 
      
      
      
      • 计划一：迭代
        
      • 计划两：操纵递回
        
      • 计划三：操纵Stream
        
      • 计划四：递回的劣化：“尾-递”迭代
        
         
      
       
    
  • 2、科里化
    
  • 3、函数式数据构造——持久化的
    
  • 4、Stream的提早策画
    
  • 
    
    
    
    • 4.1 列表接心
      
    • 4.2 提早列表
      
    • 4.3 创立一个有限提早的列表
      
    • 4.4 创立一个有限提早的量数列表
      
    • 4.5 操纵有限提早的量数列表
      
      
    
  
  

1、函数式编程

• 要被称为函数式，函数或办法不该该扔出任何非常。操纵Optional 规范做为返回值。
  
• 通明性：办法中出有任何操纵会修正现有构造
  
• 操纵Java8停止编程时，尽管操纵Stream替代迭代操纵。假如递回能够更简约，且没有带反作用，该当操纵递回交换迭代。
     

      "尾-递"迭代，没有需求正在差别的栈桢上保留每次递回策画的中心值。如今Java没有撑持这类劣化，许多确当代JVM言语，好比Scala战Groovy皆撑持这类情势递回迭代的劣化。
     

  
  

1.1 示例一：办法中出有任何操纵会修正现有构造

获得列表的子散：

1.     public static List<List<Integer>> findAllSubList(List<Integer> list) {
2.         if (list.size()==0) {
3.             List<List<Integer>> res = new ArrayList<>();
4.             res.add(Collections.emptyList());
5.             return res;
6.         }
7.         Integer first = list.get(0);
8.         List<Integer> subList = list.subList(1, list.size());
9.         List<List<Integer>> allSubList = findAllSubList(subList);
10.         List<List<Integer>> allSubList2 = insertAll(first, allSubList);
11.         return concat(allSubList, allSubList2);
12.     }
13.    
14.     private static List<List<Integer>> concat(List<List<Integer>> allSubList, List<List<Integer>> allSubList2) {
15.         List<List<Integer>> res = new ArrayList<>(allSubList);
16.         res.addAll(allSubList2);
17.         return res;
18.     }
20.     private static List<List<Integer>> insertAll(Integer item, List<List<Integer>> allSubList) {
21.         List<List<Integer>> res = new ArrayList<>();
22.         for (List<Integer> a : allSubList) {
23.             List<Integer> oneList = new ArrayList<>(a);
24.             oneList.add(item);
25.             res.add(oneList);
26.         }
27.         return res;
28.     }

复造代码

1.2 真例两：“尾-递”迭代

供n的阶乘：
计划一：迭代

1.     /**
2.      * 利用迭代计较阶乘
3.      * r 战 i 正在每轮迭代中城市更新
4.      * @param n
5.      * @return
6.      */
7.     public static int factorialIterator(int n) {
8.         int r = 1;
9.         for (int i=1; i<=n; i++) {
10.             r *= i;
11.         }
12.         return r;
13.     }

复造代码

计划四：递回的劣化：“尾-递”迭代

1.     /**
2.      * 利用递回 计较阶乘
3.      *  比迭代皆服从好：由于每次递回皆需求创立栈桢
4.      * @param n
5.      * @return
6.      */
7.     public static int factorialRecursive(int n) {
8.         return n==1? 1 : n * factorialIterator(n-1);
9.     }

复造代码

2、科里化

科里化：赞助您模块化函数，进步代码重用性的手艺。
科里化暗示一种将一个带有n元组参数的函数转换成n个一元函数链的办法。
3、函数式数据构造——持久化的

数据构造的值一直连结分歧，没有受其他部门变革的影响。
附减前提：一切操纵持久化数据构造的用户皆必需服从那一“没有修正“准绳。不合错误返回值便止修正。
4、Stream的提早策画

创立一个量数列表：
4.1 列表接心

1.     /**
2.      * 利用Stream 计较阶乘
3.      * @param n
4.      * @return
5.      */
6.     public static int factorialStream(int n) {
7.         return IntStream.rangeClosed(1, n).reduce(1, (x, y)->x*y);
8.     }

复造代码

4.2 提早列表

1.     /**
2.      * 尾-递 迭代
3.      * @param n
4.      * @return
5.      */
6.     public static int factorialTailIterator(int n) {
7.         return factorialTailHelp(1, n);
8.     }
10.     /**
11.      * 尾-递 迭代递协助类
12.      * @param acc
13.      * @param n
14.      * @return
15.      */
16.     private static int factorialTailHelp(int acc, int n) {
17.         return n==1?acc:factorialTailHelp(acc*n, n-1);
18.     }

复造代码

4.3 创立一个有限提早的列表

1. /**
2. * @Date 2021/9/5
3. * @Author lifei
4. */
5. public interface MyList<T> {
7.     T head();
8.     MyList<T> tail();
10.     MyList<T> filter(Predicate<T> p);
12.     default boolean isEmpty() {
13.         return true;
14.     }
15. }

复造代码

4.4 创立一个有限提早的量数列表

1. public class LazyList<T> implements MyList<T> {
2.     final T head;
3.     final Supplier<MyList<T>> tail;
5.     public LazyList(T head, Supplier<MyList<T>> tail) {
6.         this.head = head;
7.         this.tail = tail;
8.     }
9.     @Override
10.     public T head() {
11.         return head;
12.     }
14.     @Override
15.     public MyList<T> tail() {
16.         return tail.get();
17.     }
19.     @Override
20.     public MyList<T> filter(Predicate<T> p) {
21.         return isEmpty()?this:p.test(head())? new LazyList<>(head, ()->tail().filter(p)):tail().filter(p);
22.     }
24.     @Override
25.     public boolean isEmpty() {
26.         return false;
27.     }
28. }

复造代码

4.5 操纵有限提早的量数列表

[code]    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