Java8 特性笔记（二）Lamdba和函数式推导

r囧r小猫 2022-03-15 03:22 124阅读 0赞

在前面的一章节我们介绍了，有且只有一个抽象函数的接口就是函数式接口，利用函数式接口我们就可以创建lamdba，但是其中可以包括静态方法和default

### 1，lamdba表达式的语法 ###

> 首先我们来看一个简单的lamdba表达式的应用，就是在创建线程时候

//创建一个线程，将线程的名字打印出来
            new Thread(()-
           System.out.println(Thread.currentThread().getName())).start();
            Thread.currentThread().join();
            //Thread-0

> 根据上篇文章的数据我们看下面的例子

Comparator<Apple> byColor = new Comparator<Apple>() { 
                @Override
                public int compare(Apple o1, Apple o2) { 
                    return o1.getColor().compareTo(o2.getColor());
                }
            };
            listApple.sort(byColor);
            Comparator<Apple> byCOlor2 = (o1,o2) -> o1.getColor().compareTo(o2.getColor());

> 我们不难看到lamdba的语法构成如下:

`参数+函数体`就像上面的o1 和o2就是参数，后面的就是函数体  
（Apple a） -> a.getColor()  
（parameters）-> expression  
(parameters) ->\{statements\}

> compareTo函数介绍

// 根据Unicode来判断，返回一个boolean 根据boolean来说明，这两个对象需不需要交换，其实我们可以不用这个CompareTo，我们可以自己写判断条件，只要是返回boolean就行
      public int compareTo(String anotherString) { 
            int len1 = value.length;
            int len2 = anotherString.value.length;
            int lim = Math.min(len1, len2);
            char v1[] = value;
            char v2[] = anotherString.value;
    
            int k = 0;
            while (k < lim) { 
                char c1 = v1[k];
                char c2 = v2[k];
                if (c1 != c2) { 
                    return c1 - c2;
                }
                k++;
            }
            return len1 - len2;
        }

### 2，常见的函数式接口 ###

*  Predicate boolean test(T t)
 *  Consumer accept(T t)
 *  Function<T, R> R apple(T,t)
 *  Supplier T get()

Predicate ：传入一个变量返回一个Boolean值

private static List<Apple> filterApple(List<Apple> list, Predicate<Apple> predicate){ 
            List<Apple> lists = new ArrayList<>();
            for (Apple apple:list){ 
                if (predicate.test(apple)){ 
                    lists.add(apple);
                }
            }
            return lists;
        }
    //使用
            List<Apple> list = filterApple(listApple, apple -> apple.getWeight() > 100);
            System.out.println(list);
    //我们发现在 filterApple 函数里面我们传入了两个参数，一个是list 一个是Predicate抽象函数式接口，我们调用这个抽象函数式接口，但是我们不实现它，我们在调用的时候实现它是根据重量来比较，当然我们在调用的时候也可以根据颜色来比较
    /** 举一反三：Predicate是传入一个参数进行判断，BiPredicate是传入两个参数进行判断，例如下面的例子 */
    
    private static List<Apple> filterAppleByBiPredicaTe(List<Apple> apples, BiPredicate<String, Long> predicate){ 
    List<Apple> lists = new ArrayList()
    for(Apple apple:apples){ 
    	if (predicate.test(apple.getColor(),apple.getWeight())){ 
    			lists.add(apple)
    	}
    }
    //从上面的例子上来看我们知道BiPredicate传入两个参数，根据颜色和重量来进行比较，我们在调用的时候可以实现者两个参数的比较规则
    }

`Consumer 这个单词中文意思是消费者，既然消费了就不会有返回值`

private static void printlnApple(List<Apple> list, Consumer<Apple> consumer){ 
            if (list.size()>0){ 
                for (Apple apple:list){ 
                    consumer.accept(apple);
                }
            }
        }
    //使用
    printlnApple(listApple,apple -> System.out.println(apple.getColor()));
    /** 从上面我们可以看到 这个Consumer不会返回任何对象 举一反三: 上面有BiPredicate，那么我们这个Consumer有没有BiConsumer，答案肯定是有的，下面我们来看下BiConsumer的用法 */
    private static void printGreenAppleByBiConsumer(List<Apple> apples, Consumer<Apple, String> consumer){ 
    	if(apples.size()>0){ 
    		for(Apple apple:apples){ 
    			consumer.accept(apple, apple.getColor())
    		}
    	}
    }
    //使用
    printGreenAppleByBiConsumer(list,(apple, color)->{ 
    	if(apple.getWeight()>100&&color.equal("green")){ 
    		System.out.println(apple);
    		}
    })
    //学习玩上面的例子 我再提一个 LongConsumer，从字面上看，我们知道，它接收的是一个Long类型的，其他的并没什么区别，这里我们就不多啰嗦了

Function：函数，我们知道函数都是有输出的，这里的意思也就是说传入一个参数，返回一个参数，下面我们来看下怎么使用这个Function

private static Long getWeightList(Apple apple, Function<Apple,Long> function)
        { 
            return function.apply(apple);
        }
    //使用
      Long green = getWeightList(new Apple("green", 120), Apple::getWeight);
            System.out.println(green);
    //在这里我们可以看到，Function函数的apply抽象方法接收一个值，返回一个Long类型的值
    
    //根据上面的经验，想必大家也已经知道了还有 BiFunction 这个函数式接口，没错它只是传进去的参数有两个而已，还是返回一个结果。除此之外还有呢，大家别着急，还有 IntFunction DoubleFunction,这些有什么作用呢，其实可以看成是Function的具体情况 IntFuntion也就是 apply里面的参数是Int类型的 DoubleFunction也就是apply的参数是double类型的，大家再看一下，是不是非常非常的简单呢

Supplier，这个单词的意思是提供的意思，那也就是给你返回数据，这个函数接口里面会给你返回数据，不需要你传入数据

private static Apple  getApple(Supplier<Apple> supplier){ 
           return  supplier.get();
        }
        //使用
            Apple green1 = getApple(() -> new Apple("green", 150));
            System.out.println(green1);
       //有人肯定再想了，这样创建对象那不是脱裤子放屁吗 多此一举，这里只是举一个小例子，在实际开发中肯定不会这样

### 3，Lamdba表达式之函数式推导 ###

1，通过一个类的静态方法去推断
      2，用对象的实例方法去推断

private static void printstr(Consumer<String> consumer, String str){ 
            consumer.accept(str);
        }
        //使用
            Consumer<String> consumer = a -> System.out.println(a);
            printstr(consumer,"hello world");
       //写成
       		Consumer<String> consumer = System.out::println
       		printstr(consumer,"hello world");
       //思考我们为什么可以写成这样呢，我们看下println的源码
           // public final static PrintStream out = null;，在源码里面我们可以看到PrintStream是一个静态的类，而println是这个静态类下面的方法，因此可以做函数推导
           public void println(String x) { 
           //刚好是接收一个参数，没有返回
            synchronized (this) { 
                print(x);
                newLine();
            }
        }
    
    ```再举个例子
    
    ```java
    //将字符串转换成数字
    int  value = Integer.parseInt("123")
     Function<String, Integer> stringFunction = Integer::parseInt;
     Integer result = stringFunction.apply("123");
     System.out.println(result)
     /** 很多人看到这里就很纳闷了，怎么冒出一个 Function来了呢，这就是类方法推导，parseInt是Integer的类方法它需要传入一个数，然后输出一个数，这样的模式就是前面我们介绍的Function函数式接口，接着再来看一个例子 */
     String string = new String("hello");
     Function<Integer, Character> f = string::charAt;
     Character c = f3.apply(4);
     System.out.println(c);

构造函数推导

Supplier<String> supplier = String::new
    String s = supplier.get();
    System.out.print(s)
    //但是Apple是两个构造参数的，怎么办呢，还是有办法的
    BiFunction<String, Long,Apple> appleFunction = Apple::new;
    Apple apple = appleFunction.apply("red",100L);
    //如果有更多的参数呢，在这里我们就可以自定义函数式接口
    public interface CMyFuction<T,U,W,R>{ 
    	R get(T t,U u, W w,R,r);
    }
    CMyFuction<String,String, Long> cmyfunction = Apple::new;
    Apple apple =  cmyfunction.get("green","large",120);
    //ok 这样自定义的函数式接口就完成了

例子：sort分类与函数式推导

//定义一个集合
      static List<Apple> listApple = Arrays.asList(
                new Apple("green",122),
                new Apple("red",  34),
                new Apple("black",135),
                new Apple("green",114),
                new Apple("yellow",54),
                new Apple("yellow",94));
     //以前我们排序的时候只知道调用 sort方法例如
     listAplle.sort()
     //但是我们不知道它怎么操作的，下面我们可以自定义排序的规则
     list.sort() //写道这里系统提示参数可以为Comparator，我们接着写
     list.sort(new Comparator<Apple>{ 
    	public int compare(Apple o1, Apple o2){ 
    		return o1.getColor().compareTo(o2.getColor());
    	}
    })
     //从上面的里例子来看我们是根据apple的颜色来进行比较的，当然我们也可以根据apple的weight来进行比较.接着我们进行函数推导
     list.sort(Comparator.comparing(Apple::getColor))
     //就这么一句完全代替了我们上面的功能，很明显简化了代码

### lamdba和函数式推导就介绍到这里 ###