【数据结构】Lambda

Love The Way You Lie 2024-04-23 20:31 2阅读 0赞

> ⭐ 作者：小胡\_不糊涂  
> 🌱 作者主页：[小胡\_不糊涂的个人主页][Link 1]  
> 📀 收录专栏：[浅谈数据结构][Link 2]  
> 💖 持续更文，关注博主少走弯路，谢谢大家支持 💖

#### Lambda表达式 ####

*  1. 背景
 *   *  1.1 语法
     *  1.2 函数式接口
 *  2. 基本使用
 *  3. 变量捕获
 *   *  3.1 匿名内部类
     *  3.2 匿名内部类的变量捕获
     *  3.3 Lambda的变量捕获
 *  4. Lambda在集合当中的使用
 *   *  4.2 Collection接口
     *  4.2 List接口
     *  4.3 Map接口

![在这里插入图片描述][d5156aedb0f44153a632d7bdee9a8e11.gif_pic_center]

## 1. 背景 ##

lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样，它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。Lambda 表达式（Lambda expression），基于数学中的λ演算得名，也可称为闭包（Closure）。

### 1.1 语法 ###

**基本语法：** `(parameters) -> expression 或 (parameters) ->{ statements; }`

*  paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明，也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
 *  \->：可理解为“被用于”的意思
 *  方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不返回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不返回。

// 1. 不需要参数,返回值为 2
    () -> 2
    // 2. 接收一个参数(数字类型),返回其2倍的值
    x -> 2 * x
    // 3. 接受2个参数(数字),并返回他们的和
    (x, y) -> x + y
    // 4. 接收2个int型整数,返回他们的乘积
    (int x, int y) -> x * y
    // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
    (String s) -> System.out.print(s)

### 1.2 函数式接口 ###

> 函数式接口定义：一个接口有且只有一个抽象方法
> 
> 1.  如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
> 2.  如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。

**定义方式：**

@FunctionalInterface
    interface NoParameterNoReturn {
        
    	//注意：只能有一个方法
    	void test();
    }

@FunctionalInterface
    interface NoParameterNoReturn {
        
    	void test();
    	default void test2() {
        
    		System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");
    	}
    }

## 2. 基本使用 ##

Lambda可以理解为：Lambda就是匿名内部类的简化，实际上是创建了一个类，实现了接口，重写了接口的方法。

先实现几个接口：

//无返回值无参数
    @FunctionalInterface
    interface NoParameterNoReturn {
        
    	void test();
    }
    //无返回值一个参数
    @FunctionalInterface
    interface OneParameterNoReturn {
        
    	void test(int a);
    }
    //无返回值多个参数
    @FunctionalInterface
    interface MoreParameterNoReturn {
        
    	void test(int a,int b);
    }
    //有返回值无参数
    @FunctionalInterface
    interface NoParameterReturn {
        
    	int test();
    }
    //有返回值一个参数
    @FunctionalInterface
    interface OneParameterReturn {
        
    	int test(int a);
    }
    //有返回值多参数
    @FunctionalInterface
    interface MoreParameterReturn {
        
    	int test(int a,int b);
    }

**Lambda的具体使用实例：**

public class TestDemo1 {
        
        public static void main(String[] args) {
        
            NoParameterNoReturn noParameterNoReturn = ()->{
        
                System.out.println("无参数无返回值");
            };
            noParameterNoReturn.test();
    
            OneParameterNoReturn oneParameterNoReturn = (int a)->{
        
                System.out.println("一个参数无返回值："+ a);
            };
            oneParameterNoReturn.test(10);
    
            MoreParameterNoReturn moreParameterNoReturn = (int a,int b)->{
        
                System.out.println("多个参数无返回值："+a+" "+b);
            };
            moreParameterNoReturn.test(20,30);
    
            NoParameterReturn noParameterReturn = ()->{
        
                System.out.println("有返回值无参数！");
                return 40;
            };
    //接收函数的返回值
            int ret = noParameterReturn.test();
            System.out.println(ret);
            OneParameterReturn oneParameterReturn = (int a)->{
        
                System.out.println("有返回值有一个参数！");
                return a;
            };
            ret = oneParameterReturn.test(50);
            System.out.println(ret);
    
            MoreParameterReturn moreParameterReturn = (int a,int b)->{
        
                System.out.println("有返回值多个参数！");
                return a+b;
            };
            ret = moreParameterReturn.test(60,70);
            System.out.println(ret);
        }
    }

![在这里插入图片描述][fdedee194f0c4fb39c8508b91937c30f.png]

## 3. 变量捕获 ##

### 3.1 匿名内部类 ###

匿名内部类就是没有名字的内部类。在Java的匿名类中，会存在变量捕获。

> 匿名内部类不能定义任何静态成员、方法。  
> 匿名内部类中的方法不能是抽象的.  
> 匿名内部类必须实现接口或抽象父类的所有抽象方法.  
> 匿名内部类访问的外部类成员变量或成员方法必须用static修饰.

匿名内部类的使用示例：

class Test{
        
    	public void func(){
        
    		System.out.println("func()");
    	}
    }
    
    public class TestDemo {
        
    	public static void main(String[] args) {
        
    		new Test(){
        
    			@Override
    			public void func() {
        
    				System.out.println("我是内部类，且重写了func这个方法！");
    			}
    		};
    	}
    }

### 3.2 匿名内部类的变量捕获 ###

class Test {
        
    	public void func(){
        
    		System.out.println("func()");
    	}
    }
    
    public class TestDemo {
        
    	public static void main(String[] args) {
        
    		int a = 100;
    		new Test(){
        
    			@Override
    			public void func() {
        
    				System.out.println("我是内部类，且重写了func这个方法！");
    				System.out.println("我是捕获到变量 a == "+a
    +" 我是一个常量，或者是一个没有改变过值的变量！");
    			}
    		};
    	}
    }

在上述代码当中的变量a就是，捕获的变量。这个变量要么是被final修饰，如果不是被final修饰的，你要保证在使用之前，没有修改。

如下代码就是错误的代码：

public class TestDemo {
        
    	public static void main(String[] args) {
        
    		int a = 100;
    		new Test(){
        
    			@Override
    			public void func() {
        
    				a = 99;
    				System.out.println("我是内部类，且重写了func这个方法！");
    				System.out.println("我是捕获到变量 a == "+a
    +" 我是一个常量，或者是一个没有改变过值的变量！");
    			}
    		};
    	}
    }
    //该代码会直接编译报错

### 3.3 Lambda的变量捕获 ###

@FunctionalInterface
    interface NoParameterNoReturn {
        
    	void test();
    }
    
    public static void main(String[] args) {
        
    	int a = 10;
    	NoParameterNoReturn noParameterNoReturn = ()->{
        
    		// a = 99; error
    		System.out.println("捕获变量："+a);//也不允许修改
    	};
    	noParameterNoReturn.test();
    }

## 4. Lambda在集合当中的使用 ##

为了能够让Lambda和Java的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与Lambda表达式对接。

<table> 
 <thead> 
  <tr> 
   <th>对应的接口</th> 
   <th>新增的方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Collection</td> 
   <td>removeIf() spliterator() stream() parallelStream() forEach()</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>replaceAll() sort()</td> 
  </tr> 
  <tr> 
   <td>Map</td> 
   <td>getOrDefault() forEach() replaceAll() putIfAbsent() remove() replace() computeIfAbsent()computeIfPresent() compute() merge()</td> 
  </tr> 
 </tbody> 
</table>

### 4.2 Collection接口 ###

**forEach() 方法演示**  
该方法在接口 Iterable 当中，原型如下：

default void forEach(Consumer<? super T> action) {
        
    	Objects.requireNonNull(action);
    	for (T t : this) {
        
    		action.accept(t);
    	}
    }

该方法表示：对容器中的每个元素执行action指定的动作 。  
示例：

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            list.add("Hello");
            list.add("world");
            list.add("hello");
            list.add("lambda");
            list.forEach(new Consumer<String>(){
        
                @Override
                public void accept(String str){
        
                //简单遍历集合中的元素。
                    System.out.print(str+" ");//Hello world hello lambda
                }
            });
        }

修改为Lambda表达式如下：

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            list.add("Hello");
            list.add("world");
            list.add("hello");
            list.add("lambda");
    		//表示调用一个，不带有参数的方法，其执行花括号内的语句，为原来的函数体内容。
            list.forEach(s -> {
        
                System.out.println(s);//Hello world hello lambda
            });
        }

### 4.2 List接口 ###

**sort()方法的演示**  
sort方法源码：该方法根据c指定的比较规则对容器元素进行排序。

public void sort(Comparator<? super E> c) {
        
    	final int expectedModCount = modCount;
    	Arrays.sort((E[]) elementData, 0, size, c);
    	if (modCount != expectedModCount) {
        
    		throw new ConcurrentModificationException();
    	}
    	modCount++;
    }

使用示例：

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            list.add("Hello");
            list.add("world");
            list.add("hello");
            list.add("lambda");
            list.sort(new Comparator<String>() {
        
                @Override
                public int compare(String str1, String str2){
        
    				//这里比较长度
                    return str1.length()-str2.length();
                }
            });
            System.out.println(list);//[Hello, world,hello,lambda]
        }

修改为Lambda表达式如下：

public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
            list.add("Hello");
            list.add("world");
            list.add("hello");
            list.add("lambda");
            //调用带有2个参数的方法，且返回长度的差值
            list.sort((str1,str2)-> str1.length()-str2.length());
            System.out.println(list);//[Hello, world,hello,lambda]
        }

### 4.3 Map接口 ###

**HashMap 的 forEach()**  
该方法原型如下：

default void forEach(BiConsumer<? super K, ? super V> action) {
        
    	Objects.requireNonNull(action);
    	for (Map.Entry<K, V> entry : entrySet()) {
        
    		K k;
    		V v;
    		try {
        
    			k = entry.getKey();
    			v = entry.getValue();
    		} catch(IllegalStateException ise) {
        
    			// this usually means the entry is no longer in the map.
    			throw new ConcurrentModificationException(ise);
    		}
    		action.accept(k, v);
    	}
    }

作用是对Map中的每个映射执行action指定的操作。  
代码示例：

public static void main(String[] args) {
        
            HashMap<Integer, String> map = new HashMap<>();
            map.put(1, "hello");
            map.put(2, "world");
            map.put(3, "hello");
            map.put(4, "lambda");
            map.forEach(new BiConsumer<Integer, String>(){
        
                @Override
                public void accept(Integer k, String v){
        
                    System.out.println(k + "=" + v);
                }
            });
        }
    //1=hello
    //2=world
    //3=hello
    //4=lambda

修改为Lambda表达式：

public static void main(String[] args) {
        
            HashMap<Integer, String> map = new HashMap<>();
            map.put(1, "hello");
            map.put(2, "bit");
            map.put(3, "hello");
            map.put(4, "lambda");
            map.forEach((k,v)-> System.out.println(k + "=" + v));
        }

[Link 1]: https://blog.csdn.net/iLoyo_
[Link 2]: http://t.csdnimg.cn/pu3jy
[d5156aedb0f44153a632d7bdee9a8e11.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/21e0ee160705491dab2e14f63cb283fe.gif
[fdedee194f0c4fb39c8508b91937c30f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/964f65ec55d34a75b8bdf0baf62397ab.png