java8 lambda表达式的使用

参考:

Java 8:一文掌握 Lambda 表达式

java8 lambda表达式

Java Lambda 表达式

Java语法—— Lambda表达式

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

  (Collection中的新方法)(Map中的新方法)

lambda表达式操作map

 

Java内部类之匿名内部类 (匿名内部类实现接口)

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

}
lambdaForMap
复制代码

 

 

三、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));
    }
    
}
lambdaForCollections
复制代码

 

 

 

posted @   BBS_自律  阅读(32)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 百万级群聊的设计实践
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战
· 永远不要相信用户的输入:从 SQL 注入攻防看输入验证的重要性
· 全网最简单!3分钟用满血DeepSeek R1开发一款AI智能客服,零代码轻松接入微信、公众号、小程
· .NET 10 首个预览版发布,跨平台开发与性能全面提升
点击右上角即可分享
微信分享提示