总结JDK8Lambda表达式

1.总结Lambda表达式各符号的意思，及使用方法。我学习的视频地址：

https://ke.qq.com/course/397477?taid=3334870307049637

视频里面讲的很详细，及使用，我也总结了其中的一部分

1.1 介绍

Lambda表达式就是一个匿名内部类，函数式接口只有一个方法。使用@FunctionalInterface直接修饰

//Lambda表达式使用，（）表示参数传递，{}方法体。里面可以写其他代码

package com.synt;

/**
 * Lambda表达式就是一个匿名内部类，函数式接口只有一个方法。使用@FunctionalInterface直接修饰
 */
public class Lamda1 {
    public static void main(String[] args) {

        //Lambda表达式使用，（）表示参数传递，{}方法体。里面可以写其他代码
        LamdaNoneGNoneParam s = () -> {
            System.out.println("hello，word");
        };

        //开始调用，方法体的代码
        s.hello();

        //上面的Lambda写法就是下面的匿名内部类的写法。但是前面的可以省略，只留下（）方法体里面的代码也可以省。留下输出
        LamdaNoneGNoneParam s1 = new LamdaNoneGNoneParam() {
            @Override
            public void hello() {
                System.out.println("hello，word");
            }
        };
        s1.hello();
    }
}

@FunctionalInterface
interface LamdaNoneGNoneParam{
    void hello();
}

 

2.有参数有返回值的

package com.demo;

public class Lamda {
    public static void main(String[] args) {
        LamdaMutiGParam lam = (a,b)->{return a+b;};
        int sum = lam.sum(2, 3);
        System.out.println("相加的和"+sum);

        //匿名函数实现
        LamdaMutiGParam lam2 = new LamdaMutiGParam() {
            @Override
            public int sum(int a, int b) {
                return 0;
            }
        };
        lam2.sum(2,3);

        //lamda实现
        LamdaMutiGParam lam3 = (a,b) -> a+b;
        lam3.sum(5,6);

        //总结lamda实现更简单
    }
}
@FunctionalInterface
interface LamdaMutiGParam{
    int sum(int a ,int b);
}

3. list的使用

package com.demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 写一下list调用lamda的方法实现
 */
public class LamdaList {
    public static void main(String[] args) {
        List<Integer> list =new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,8,9);
        System.out.println(list);
        //list 排序，里面实现了Comparator接口
        list.sort((o1, o2) -> o2 - o1);
        
        //a::b代表调用方法，其中a代表所属的类，b代表所属的方法
        Integer integer = list.stream().reduce(LamdaList::plus).get();


        //打印输出集合
        list.forEach(ele -> System.out.println(ele));
    }

    private static int plus(int a, int b) {
        System.out.println(a+b);
        return a+b;
    }
}

 

4.这还是需要多练习，理解。使用起来确实很简单，而且jdk8内置了很多函数式接口 

这也是一个学习的网址：https://www.runoob.com/java/java8-lambda-expressions.html

5.jdk中写 的测试的代码，供大家参考

package jdk8;

import org.apache.commons.compress.utils.Lists;
import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import java.util.stream.Stream;

public class Test1 {
    public static Test1 create(Supplier<Test1> supplier){
        return supplier.get();
    }
    public static String add(){
        return "2";
    }


    @Test
    public void lamd(){
        int a1 = 2;
        // 没有大括号及返回语句
        MathOperation division = a -> 3*a;
        System.out.println(division.operation(5));
    }
    @Test
    public void lamd2(){
        // 没有大括号及返回语句
        MathOperation division = a -> { System.out.println(3*a);return 4;};
        System.out.println(division.operation(5));
    }
    @Test
    public void lamd3(){
        List<Integer> lis = Arrays.asList(1,2,3,4,5);
        Integer reduce = lis.stream().reduce(Test1::plus).get();
        System.out.println(reduce);
//        CLam <Integer> k = Test1::plus;
//        k.plus(5,6);

    }
    @Test
    public void lamd4() throws UnsupportedEncodingException {
//        Random random = new Random();
//        random.ints().filter(s -> s>0).limit(10).forEach(System.out::println);
        String s = Base64.getEncoder().encodeToString("dsdds".getBytes());
        byte[] decode = Base64.getDecoder().decode(s);
        System.out.println("原始字符串: " + new String(decode, "utf-8"));


    }

    private int applyAsInt(String a) {
        return 4;
    }
    private void apsInt(ToIntFunction<String> s) {
    }

    private static int plus(int a, int b) {
        System.out.println(a+b);
        return a+b;
    }

    private static String add(int i) {
        return i+"i";
    }

    private static void add(String s) {

    }
    public static void printInfo(String[] strArr, Consumer<String> con1, Consumer<String> con2){

        for (int i = 0; i < strArr.length; i++) {
            con1.andThen(con2).accept(strArr[i]);
        }

    }

    public static void main(String[] args) {
        String[] strArr = {"迪丽热巴,女","郑爽,女","杨紫,女"};
        printInfo(strArr,(message)->{
            System.out.print("姓名:" + message.split(",")[0] + "。  ");
        },(message)->{
            System.out.println("性别:" + message.split(",")[1] + "。");

        });
    }
}
interface MathOperation {
    int operation(int a);
//    String pstr(String s);

 }
@FunctionalInterface
interface Lam <R>{
    R add(int a);

}
@FunctionalInterface
interface CLam <R>{
    void plus(int a, int b) ;
}

//class cf implements CLam<Integer>{
//    @Override
//    public void plus(int a, int b) {
//
//    }
//}
class df implements Lam<String>{


    @Override
    public String add(int a) {
        return "null";
    }


}

//引用构造方法
@FunctionalInterface
interface IMessage3<C> {
    C create(String t, double p);
}

class Book {
    private String title;
    private double price;
    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }

    @Override
    public String toString() {
        return "书名: " + this.title + ", 价格: " + this.price;
    }
}

 class MethodReferenceDemo1 {
    public static void main(String... args) {
        IMessage3<Book> msg = Book::new; // 引用构造方法
        Book book = msg.create("Java开发", 20.22);
        System.out.println(book.toString());
    }
}