RADIUS 集成ldap lambda 集成器

1. lambda表达式

1. 为什么使用Lambda表达式？

Lambda表达式是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升

2. lambda表达式格式：

- 中间：箭头操作符->
- 左边: lambda形参列表（其实就是接口中的抽象方法的形参列表）
- 右边：lambda体（其实就是重写的抽象方法的方法体）

3. lambda表达式的本质：

作为函数式接口的实例

• 函数式接口：如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口（我们可以在一个接口上使用@FunctionalInterface注解来检查一个接口是否为函数式接口）

4. lambda表达式使用（6种情况）：

概述：
左边: lambda形参列表的参数类型可以省略(类型推断)；如果lambda形参列表只有一个参数，
          其一对()也可省略
右边：lambda体应使用一对{}包裹；如果lambda体只有一条执行语句(可能是return语句)，
           可以省略略这一对{}和return（省略大括号return必须也省略）

• 语法格式一：无参无返回值

package Java8;

import org.junit.Test;

import java.util.Comparator;

/**
 * lambda表达式语法格式一: 无参无返回值
 */
public class LambdaTest1 {

    // 无参无返回值
    @Test
    public void test1() {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("这是未使用Lambda表达式的");
            }
        };
        r1.run();
        System.out.println("------这是优美的分割线------");
        Runnable r2 = () -> System.out.println("这是使用了lambda表达式");
        r2.run();
    }

}

运行结果

• 语法格式二：一个参数，无返回值
• 语法格式三：类型推断，数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

package Java8;

import org.junit.Test;

import java.util.function.Consumer;

/**
 * 语法格式二: 有一个参数，无返回值
 * 语法格式三: 类型推断
 */
public class LambdaTest2 {

    @Test
    public void test1() {
        Consumer<String> con1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con1.accept("这是未使用lambda表达式");
        System.out.println("------优美的分割线------");
        Consumer<String> con2 = (String s) -> System.out.println(s);
        con2.accept("这是使用了lambda表达式");
        System.out.println("------优美的分割线------");
        // 类型推断，数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
        Consumer<String> con3 = (s) -> System.out.println(s);
        con3.accept("类型推断");
        System.out.println("------优美的分割线------");
        Consumer<String> con4 = System.out::println;
        con4.accept("方法引用");
    }


}

运行结果

• 语法格式四：只需要一个参数时，参数小括号可以省略

package Java8;

import org.junit.Test;

import java.util.function.Consumer;

/**
 * 语法格式四: 只需要一个参数时，参数的小括号可以省略
 */
public class LambdaTest3 {

    @Test
    public void test1() {
        Consumer<String> con1 = s -> System.out.println(s);
        con1.accept("只有一个参数时, 可省略小括号");
    }
}

运行结果

• 语法格式五：两个及以上参数，多条执行语句，且有返回值

package Java8;

import org.junit.Test;

import java.util.Comparator;

/**
 * 语法格式五: 两个及以上参数, 多条执行语句，并且可有返回值
 */
public class LambdaTest4 {

    @Test
    public void test1() {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        int compare1 = com1.compare(12, 21);
        System.out.println("未使用lambda表达式:" + compare1);
        System.out.println("------优美的分隔符------");
        Comparator<Integer> com2 = (o1, o2) -> {
            System.out.println("语句1");
            System.out.println("语句2");
            return o1.compareTo(o2);
        };
        int compare2 = com2.compare(12, 21);
        System.out.println("使用lambda表达式:" + compare2);
    }
}

运行结果

• 语法格式六：lambda体只有一条语句时，return与大括号都可省略

package Java8;

import org.junit.Test;

import java.util.Comparator;

/**
 * 语法格式六：lambda体只有一条语句时，return和大括号都可省略
 */
public class LambdaTest5 {

    @Test
    public void test() {
        Comparator<Integer> com1 = (o1, o2) -> {
            return o1.compareTo(o2);
        };
        System.out.println("未使用省略:" + com1.compare(12, 21));
        System.out.println("------优美的分隔符------");
        Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2);
        System.out.println("使用省略:" + com2.compare(12, 21));
    }
}

---

2. 函数式接口

1. 什么是函数式接口？

只包含一个抽象方法的接口称为函数式接口（可使用@FunctionalInterface注解检验）

2. Java内置四大核心函数式接口

java.util.function包下定义了Java8丰富的函数式接口

函数式接口	参数类型	返回类型	用途
Consumer< T > 消费型接口	T	void	对类型为T的对象应用操作，包含方法：void accept(T t)
Supplier< T >供给型接口	无	T	返回类型为T的对象，包含方法：T get()
Function<T, R>函数型接口	T	R	对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t)
Predicate< T >断定型接口	T	boolean	确定类型为T的对象是否满足某约束，并返回Boolean值。包含方法：boolean test(T t)

3. 代码示例

package Java8;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * 函数式接口
 */
public class LambdaTest6 {

    @Test
    public void test1() {
        happyTime(500, money -> System.out.println("去happy，花费: " + money));
    }

    public void happyTime(double money, Consumer<Double> con) {
        con.accept(money);
    }


    @Test
    public void test2() {
        List<String> list = Arrays.asList("东京", "西京", "南京", "北京", "天津", "上海");
        List<String> filterStrs = filterString(list, str -> str.contains("京"));
        System.out.println(filterStrs);
    }

    // 根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
    public List<String> filterString(List<String> list, Predicate<String> pre) {
        ArrayList<String> filterList = new ArrayList<>();
        for (String s : list) {
            if (pre.test(s)) {
                filterList.add(s);
            }
        }
        return filterList;
    }

}

运行结果

---

3. 方法引用

1. 概述

• 当要传递给lambda体的操作已经有实现的方法了，可以使用方法引用
• 方法引用可以看作是lambda表达式深层次的表达。换句话说，方法引用就是lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是lambda表达式的一个语法糖

2. 要求

实现接口的抽象方法的参数列表和返回值类型，必须和方法引用的方法的参数列表和返回值类型保持一致（适用于情况一、情况二）

3. 格式

使用操作符 "::"将类（或对象）与方法名分隔开来

4. 主要使用情况

• 情况一：对象 :: 实例方法名
• 情况二：类 :: 静态方法名
• 情况三：类 :: 实例方法名

5. 代码示例

package Java8;

import org.junit.Test;

import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class MethodRefTest {

    /**
     * 情况一:对象::实例方法
     * Consumer中的void accept(T t)
     * printStream中的void println(T t)
     */
    @Test
    public void test1() {
        Consumer<String> con1 = str -> System.out.println("未使用方法引用:" + str);
        con1.accept("北京");
        System.out.println("------优美的分割线------");
        Consumer<String> con2 = System.out::println;
        con2.accept("使用方法引用");
    }

    // Supplier中的T get()
    // Employee中的String getName()
    @Test
    public void test2() {
        Employee employee = new Employee(1001, "zhangsan", 23, 5600);
        Supplier<String> supplier1 = () -> employee.getName();
        System.out.println(supplier1.get());
        System.out.println("------优美的分割线------");
        Supplier<String> supplier2 = employee::getName;
        System.out.println(supplier2.get());
    }

    // 情况二：类::静态方法
    // Comparator中的int compare(T t1, T t2)
    // Integer中的int compare(T t1, T t2)
    @Test
    public void test3() {
        Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
        System.out.println(com1.compare(12, 21));
        System.out.println("------优美的分割线------");
        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(21, 12));
    }

    @Test
    public void test4() {
        Function<Double, Long> function1 = d -> Math.round(d);
        System.out.println(function1.apply(3.1));
        System.out.println("------优美的分割线------");
        Function<Double, Long> function2 = Math::round;
        System.out.println(function2.apply(3.5));
    }

    // 情况三: 类::实例方法
    // Comparator中的int compare(T t1, T t2)
    // String中的int t1.compareTo(t2)
    @Test
    public void test5() {
        Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc", "abd"));
        System.out.println("------优美的分割线------");
        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("abc", "abc"));
    }

    // BiPredicate中的boolean test(T t1, T t2);
    // String中的boolean t1.equals(t2)
    @Test
    public void test6() {
        BiPredicate<String, String> predicate1 = (s1, s2) -> s1.equals(s2);
        System.out.println(predicate1.test("abc", "abc"));
        System.out.println("------优美的分割线------");
        BiPredicate<String, String> predicate2 = String::equals;
        System.out.println(predicate2.test("abc", "abd"));
    }

    // Function中的R apply(T t)
    // Employee中的String getName()
    @Test
    public void test7() {
        Employee employee = new Employee(1001, "Jerry", 23, 6000);
        Function<Employee, String> function1 = e -> e.getName();
        System.out.println(function1.apply(employee));
        System.out.println("------优美的分隔符------");
        Function<Employee, String> function2 = Employee::getName;
        System.out.println(function2.apply(employee));
    }
}

运行结果

---

4. 构造器引用

1. 概述

构造器引用和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型

2. 代码示例

/**
     * 构造器引用
     * 和方法引用类似，函数式接口的抽象方法的参数列表和构造器的形参列表一致
     * 抽象方法的返回值类型即为构造器所属的类的类型
     */
    @Test
    public void test8() {
        Supplier<Employee> supplier1 = () -> new Employee();
        System.out.println(supplier1.get());
        System.out.println("------优美的分割线------");
        Supplier<Employee> supplier2 = Employee::new;
        System.out.println(supplier2.get());
    }

    // Function中的R apply(T t)
    @Test
    public void test9(){
        Function<Integer, Employee> function1 = id ->new Employee(id);
        Employee employee1 = function1.apply(1001);
        System.out.println(employee1);
        System.out.println("------优美的分割线------");
        Function<Integer, Employee> function2 = Employee::new;
        Employee employee2 = function2.apply(1002);
        System.out.println(employee2);
    }

运行结果

5. 数组引用

1. 概述

可以把数组看作是一个特殊的类，则写法与构造器引用一致

2. 代码示例

// 数组引用: 把数组看作是一个特殊的类，则写法就与构造器引用一致
    // Function中的R apply(T t)
    @Test
    public void test10() {
        Function<Integer, String[]> function1 = Length -> new String[Length];
        String[] arr1 = function1.apply(5);
        System.out.println(Arrays.toString(arr1));
        System.out.println("------优美的分割线------");
        Function<Integer, String[]> function2 = String[]::new;
        String[] arr2 = function2.apply(6);
        System.out.println(Arrays.toString(arr2));
    }

运行结果