Java基础语法-Lambda表达式

1.Lambda表达式主要用于简写接口的操作等出现匿名内部类的地方，如下：我这里先定义一个Swim接口，以及它所定义的swim()方法

interface Swim{
        void swim();
}

2.定义一个类Person操作这个接口：

class Person implements Swim{

    @Override
    public void swim() {
        System.out.println("人会游泳");
    }
}

3.在我的主类TestLambda中测试该接口：

public class TestLambda {private  static void show(Swim swim){        swim.swim();    }

    public static void main(String[] args) {

      //  简单的对接口的操作
    show(new Person());
    show(new Swim() {
        @Override
        public void swim() {
            System.out.println("不知道是谁会游泳");
        }
    });
    show(()-> System.out.println("不知道是谁，也不知道它（他）会干什么");//当然我们通过Lambda看不出来操作了那个接口，但编译程序是知道的

相同原理的里一个例子（对应上面例子的三种方法）:

String[] s = {"Justin","Monic","Irene"};
//第一种方法：构建操作接口的类
        class MyComparator implements Comparator<String>{
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        }
 Comparator<String> comparator3 = new MyComparator();//创建类操作接口并实例化该类
Arrays.sort(s,comparator2);
//第二种方法：匿名化接口的操作
 Arrays.sort(s, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.length()-o2.length();
        }
    });
//第三种方法：lambda
Arrays.sort(s,(o1, o2) ->{return o1.length()-o2.length();});//只有一条语句时{}可省略并且return也可省略。Lambda表达式中，当没有参数传入时,()时不可以省略的，只有一个参数传入时，()可以省略，两个两个以上的参数传入时,()不可以省略

Lambda中的方法参考：

1.还是先以Swim接口的操作为例：

首先我们在TestLambda类中写入一下方法

static void classSwim(){
        System.out.println("不知道是谁，也不知道它（他）会干什么"); }

在mian()方法中操作接口：

 show(()->TestLambda.classSwim());//等同于show(TestLambda::classSwim);

2.以Arrays.sort()方法为例：

首先我们在TestLambda类中写入一下方法：

static int bylength(String o1,String o2){
        return o1.length()-o2.length();
    }

在mian()方法中操作接口：

 Arrays.sort(s,(o1, o2) -> TestLambda.bylength(o1,o2));
    Arrays.sort(s, TestLambda::bylength);//参考TextLambda，bylength方法

另外，如果参考方法的方法体中，只是调用了传入参数的类型的类类的某个方法，可写作：

//TestLambda类中的一个静态方法
static int byLength(String o1,String o2){
        return o1.compareTo(o2);//该静态方法只是调用了String的compareTo()方法
    }//mian()方法中：
//Lambda本来可写为一下：
 Arrays.sort(s, TestLambda::byLength);
//也可写作：
Arrays.sort(s,String::compareTo);

方法参考总结：当一个静态方法与操作接口的方法具有相同的参数类型参数个数以及返回值时，可以使用该静态方法代替操作接口的方法

特定对象的方法参考：

先以Swim接口为例：

//TestLambad中写入如下方法
void clasSwim2(){
        System.out.println("我是classSwim2，我被classSwim调用");
//main()方法中：
show(()->new TestLambda().clasSwim2());//等同于
    TestLambda testLambda = new TestLambda();
     show(testLambda::clasSwim2);

然后再看List类的forEach()方法

//out是printStream实例
//s接上面例子
List<String> list = Arrays.asList(s);
          list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);//调用out实例的println()方法
            }
        });

//等同于
        list.forEach(System.out::println);

关于接口：

default修饰接口中的方法表示，操作该接口的类可以选择不操作default修饰的方法。

（1）. 如果父接口中有个默认方法，子接口中再度声明与父接口默认方法相同的方法命名，但没有写default也就是没有方法操作，那么子接口中该方法直接重新定义了父类中的默认方法操作为抽象方法。 （2）. 如果两个接口都定义了相同方法命名的默认方法，而新的接口同时继承这两个接口，那么会引发冲突，当新的接口没有重新定义方法时，就会发生变异错误，解决途径就是明确重新定义方法或者可使用接口.super.方法的方式指定继承的那个接口的方法。（3）如果类操作两个接口拥有相同的父接口，其中一个重新定义了父接口的默认方法而另一个没有，那么操作类将采用重新定义的版本。（4）如果子类继承父类同时操作了某接口，而父类中的方法与接口中的默认方法具有相同的方法命名，则采用父类的方法定义。

另外JDK8除了让接口可以定义默认方法以外，也开始允许在接口中定义静态方法，此方法要写方法体，调用和类中的静态方法调用相似。