JAVA 学习 面试（九）Lambda表达式与泛型

Lambda表达式

// 使用 Lambda 表达式计算两个数的和
MathOperation addition = (a, b) -> a + b;
// 调用 Lambda 表达式
int result = addition.operation(5, 3);
// MathOperation 是一个函数式接口，它包含一个抽象方法 operation，Lambda 表达式 (a, b) -> a + b 实现了这个抽象方法，表示对两个参数进行相加操作。
// 在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

Lambda表达式与匿名内部类：

• 内部类编译之后将会产生两个 class 文件（编译器自动命名Test$1.class），lambda编译后只会产生一个文件 （LambdaTest.class），即 Lambda 表达式不会产生新的类
• Lambda 表达式中使用 this 关键字时，其指向的是外部类的引用（因为其不会创建匿名内部类）

函数式接口

函数式接口是为使现有的函数友好地支持Lambda表达式而提出的概念

@FunctionalInterface // Java 8为函数式接口引入了一个新注解@FunctionalInterface，主要用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错。
interface GreetingService {
  void sayMessage(String message);
}
GreetingService greetService1 = message -> System.out.println("Hello " + message);

• 函数式接口只定义了唯一的抽象方法的接口（除了隐含的Object对象的公共方法），若增加新的方法，就非函数式接口，编译会失败

• 函数式接口里还允许定义 java.lang.Object 里的 public 方法，因为任何一个函数式接口的实现，默认都继承了 Object 类，包含了来自 java.lang.Object 里对这些抽象方法的实现

• 可以在接口中添加默认方法与静态方法，无论几个

@FunctionalInterface
public interface XttblogService{
    void sayMessage(String message);
  
    default void doSomeMoreWork1(){//增加默认方法（default），static和default不能同时使用
    }
    static void printHello(){  //增加静态方法（static）
      System.out.println("Hello");
    }
    @Override //Object类中的public方法
    String toString();
}

// 典型的函数式接口：
java.lang.Runnable
java.util.concurrent.Callable
java.util.Comparator

方法引用

可以直接引用已有Java类或对象的方法或构造器。方法引用与lambda表达式结合使用，可以进一步简化代码。

new Random().ints(10)
        .map(i->Math.abs(i))
        .forEach(i -> System.out.println(i));
//其中 i -> Math.abs(i)代理了如下代码：
new IntUnaryOperator() {
    @Override
    public int applyAsInt(int operand) {
        return Math.abs(operand);
    }
}
// 通过方法引用进一步简化：
new Random().ints(10)
        .map(Math::abs)
        .forEach(System.out::println);

四种方法引用:

种类	语法	例子
静态方法引用	ContainingClass::staticMethodName	Math::abs
特定对象的实例方法引用	containingObject::instanceMethodName	this::equals
实例方法的任意一个特定类型的对象引用	ContainingClass::staticMethodName	String::concat
构造器引用	ClassName::new	HashSet::new

@FunctionalInterface // 上表中的3
interface TestInterface<T> {
    String handleString(T a, String b);
}
class TestClass {
    String oneString;
    public String concatString(String a) {
        return this.oneString + a;
    }
    public String startHandleString(TestInterface<TestClass> testInterface, String str) {
        String result = testInterface.handleString(this, str);
        return result;
    }
}

public class Test {
    public static void main(String[] args) {
        TestClass testClass = new TestClass();
        testClass.oneString = "abc";
        String result = testClass.startHandleString(TestClass::concatString, "123");
        System.out.println(result);

        //相当于以下效果
        TestClass testClass2 = new TestClass();
        testClass2.oneString = "abc";
        TestInterface theOne2 = (a, b) -> testClass2.concatString(b);
        String result2 = theOne2.handleString(theOne2, "123");
        System.out.println(result2);

    }
}

泛型ref

E - Element (在集合中使用，因为集合中存放的是元素)
 T - Type（Java 类）
 K - Key（键）
 V - Value（值）
 N - Number（数值类型）

**泛型类：**通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

T可以随便写为任意标识，常见的如T、E、K、V等形式的参数

//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{
    //在类中声明的泛型整个类里面都可以用，除了静态部分，因为泛型是实例化时声明的。
    //静态区域的代码在编译时就已经确定，只与类相关
    class A <E>{
        T t;
    }
    //类里面的方法或类中再次声明同名泛型是允许的，并且该泛型会覆盖掉父类的同名泛型T
    class B <T>{
        T t;
    }
    //静态内部类也可以使用泛型，实例化时赋予泛型实际类型
    static class C <T> {
        T t;
    }
    public static void main(String[] args) {
        //报错，不能使用T泛型，因为泛型T属于实例不属于类
        T t = null;
    }
    public static <T> void show(T t){
 
    }
    //key这个成员变量的类型为T,T的类型由外部指定
    private T key;
 
    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }
 
    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}

泛型类，是在实例化类的时候指明泛型的具体类型；

public class Generic<T> {
    private T key;
    public Generic(T key) {
        this.key = key;
    }
    public T getKey(){
        return key;
    }
}
// 当创建一个 Generic< T > 类对象时，会向尖括号 <> 中传入具体的数据类型。
@Test
public void test() {
    Generic<String> generic = new Generic<>();// 传入 String 类型
    // <> 中什么都不传入，等价于 Generic