java8 lambda表达式的使用

参考：

Java 8：一文掌握 Lambda 表达式

java8 lambda表达式

Java Lambda 表达式

Java语法—— Lambda表达式

关于Java Lambda表达式看这一篇就够了

　　（Collection中的新方法）（Map中的新方法）

lambda表达式操作map

 

Lambda表达式也成为闭包，允许吧函数作为一个方法的参数；
主要是用来避免匿名内部类定义过多，产生代码臃肿不简洁节凑，无法凸显核心代码逻辑的问题；

匿名内部类就是没有名字的内部类，其必须实现接口或抽象父类的所有抽象方法

 

 

二、理解

语法格式

(parameters) -> expression[表达式]
(parameters) -> statements[语句]
(parameters) ->{ statements; }

函数式接口

Functional lnterface(函数式接口)是指任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口，可以通过Lambda表达式创建该接口的对象

public interface Runnable {
    public abstract void run();
}

特征

• 可省略类型声明：不需要声明形式参数类型
• 可省略参数括号：一个参数无需定义括号，但多个参数需要定义括号
• 可省略花括号：如果主体只包含了一个语句就不需要使用花括号
• 可省略返回关键字：如果主体只包含了一个返回值语句则会自动返回

4.匿名内部类

局部内部类还是感觉代码太多了，如果简化呢？比如把类名隐藏？匿名内部类就是没有名字的内部类，其必须实现接口或抽象父类的所有抽象方法（直接对函数式接口进行new ）

public class LambdaDemo {
    public static void main(String[] args) {
    //2.实现匿名内部类，实现接口
        MathOperation addition = new MathOperation() {
            @Override
            public void operation(int a, int b) {
                System.out.println(a + b);
            }
        };
    //3.执行计算
        addition.operation(1,2);
    }
}
    //1.定义一个函数式接口
interface MathOperation{
    void operation(int a, int b);
}

5.Lambda表达式

都已经没有类名了，能否再简化呢？用Lambda试试，因为接口中只有一个方法，方法中只有一块语句，因此可以省略接口和方法，只留下语句实现

public class LambdaDemo {
    public static void main(String[] args) {
        //2.Lambda简化，只有一块语句，省略接口和方法，只留下语句实现
        MathOperation addition = (int a , int b) -> {
            System.out.println(a + b);
        };
        //3.执行计算
        addition.operation(1, 2);
    }
}
        //1.定义一个函数式接口
interface MathOperation{
    void operation(int a, int b);
}

6.Lambda再简化

Lambda 表达式还可以省略参数类型，因为一行语句，因此可以省略花括号

 

public class LambdaDemo {
    public static void main(String[] args) {
        //2.Lambda简化，省略参数类型，代码块只有一句，可以省略花括号
        MathOperation addition = (a , b) -> System.out.println(a + b);
        //3.执行计算
        addition.operation(1,2);
    }
}
        //1.定义一个函数式接口
interface MathOperation{
    void operation(int a, int b);
}

7.idea 匿名内部类的实现

new 函数式接口，自动创建匿名内部类。

生成后的匿名内部类，添加核心逻辑，执行调用方法；

idae自动提示可以替换成lamdba表达式

替换成lamdba表达式后：

三、map中的使用

forEach():

replaceAll():

 

package lambda;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;

/**
 * TODO
 *
 * @author zhaoJs
 * @version 1.0
 * @date 2022/9/16 9:34
 */
@SpringBootTest (classes = LambdaMap.class)
@RunWith(SpringRunner.class)
@Slf4j
public class LambdaMap {
    @Test
    public void contextLoads() {
        System.out.printf("1111");
    }
    
    //   map 遍历 之前代码
    @Test
    public void forEach(){
        HashMap<Integer, String > map = new HashMap<>();
        map.put(1,"one");
        map.put(2,"two");
        map.put(3,"three");
        for(Map.Entry<Integer,String> entry : map.entrySet() ){
            log.info(entry.getKey() + "==" + entry.getValue());
        }
    }
    
    // forEachs map 便利 使用匿名内部类 和 lambda表达式
    @Test
    public  void forEachByLambda(){
        HashMap<Integer, String > map = new HashMap<>();
        map.put(1,"one");
        map.put(2,"two");
        map.put(3,"three");
        map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer k, String v) {
              log.info(k + "==" + v);  
            }
        });

        map.forEach((k, v) -> log.info(k + "==" + v));
    }
    
    //map 替换所有单词为大写
    @Test
    public void replaceAll(){
        HashMap<Integer, String > map = new HashMap<>();
        map.put(1,"one");
        map.put(2,"two");
        map.put(3,"three");
        for(Map.Entry<Integer, String > entry : map.entrySet()){
            entry.setValue(entry.getValue().toUpperCase());
        }
        for (Map.Entry<Integer, String> entry1 : map.entrySet()){
            log.info(entry1.getKey() + "=" + entry1.getValue());
        }
    }
   
    // map 替换所有的单词为大写 通过replaceAll方法，使用匿名内部类和lambda来实现
    @Test
    public void replaceAllByLambda(){
        HashMap<Integer, String > map = new HashMap<>();
        map.put(1,"one");
        map.put(2,"two");
        map.put(3,"three");
/*        map.replaceAll(new BiFunction<Integer, String, String>() {
            @Override
            public String apply(Integer k, String v) {
                return v.toUpperCase(); 
            }
        });*/
        map.replaceAll((k,v) -> v.toUpperCase());
        for (Map.Entry<Integer, String> entry1 : map.entrySet()){
            log.info(entry1.getKey() + "=" + entry1.getValue());
        }
    }
    
    

}

三、Collection中的新方法

1.forEach()

 2.removeIf()

replaceAll()

sort()

 

package lambda;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;

/**
 * lambda语法在Colletcion接口中使用
 *
 * @author zhaoJs
 * @version 1.0
 * @date 2022/9/16 11:01
 */
@SpringBootTest(classes = LambdaMap.class)
@RunWith(SpringRunner.class)
@Slf4j
public class LambdaCollection {
    
    //遍历 arrayList 使用for曾强for循环
    @Test
    public void forEach(){
        //曾强for循环
        ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "LOVE", "YOU", "TOO"));
        for (String str : list){
            log.info(str);
        }
    }
    
    //遍历 arraylist 通过forEach方法 使用匿名内部类 和 lamdb实现
    @Test
    public void forEachByLambda(){
        ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "LOVE", "YOU", "TOO"));
        //匿名内部类实现
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                log.info(s);
            }
        });
        //lambda实现
        list.forEach((s) -> log.info(s));
        
    }
    
    //删除符合条件的arrayList ，通过普通的迭代器
    @Test
    public void removeIf(){
        ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "LOVE", "YOU", "TOO"));
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            if(it.next().length() > 3){
                it.remove();
            }
        }
        list.forEach((s) -> log.info(s));

    }
    //删除符合条件的arrayList ，通过removeIf方法 使用匿名内部类 和 lambda实现
    @Test
    public void removeIfByLambda(){
        ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "LOVE", "YOU", "TOO"));
   /*     list.removeIf(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() > 3;
            }
        });*/
        list.removeIf((s) -> s.length() >3);
        list.forEach((s) -> log.info(s));

    }
    
    //替换 ,代码便利替换
    @Test
    public void replaceAll(){
        ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "LOVE", "YOU", "TOO"));
        for(int i=0; i<list.size(); i++){
            String str = list.get(i);
            if(str.length() > 3){
                list.set(i,str.toLowerCase());    
            }
        }
        list.forEach((s) -> log.info(s));
        

    }
    //替换 ,通过replace方法，使用匿名内部类和lambda表达式实现
    @Test
    public void replaceAllByLambda(){
        ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "LOVE", "YOU", "TOO"));
   /*     list.replaceAll(new UnaryOperator<String>() {
            @Override
            public String apply(String s) {
                return s.toLowerCase();
            }
        });*/
        list.replaceAll((s) -> s.toLowerCase());
        list.forEach((s) -> log.info(s));
        
    }
    
    //比较大小 sort  使用Collecionts工具类中
    @Test
    public void sort(){
        ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "LOVE", "YOU", "TOO"));
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.length() - o1.length();
            }
        });
        list.forEach((s) -> log.info(s));

    }
    
    //比较大小 sort  使用list.sort方法  
    @Test
    public void sortBylambda(){
        ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "LOVE", "YOU", "TOO"));
        list.sort((str1,str2) -> str1.length() - str2.length());
        list.forEach((s) -> log.info(s));
    }
    
}