lambda表达式初探

前言

1、lambda写法

1.1、lambda表达式

1、前面一个小括号，不需要任何参数可以直接执行        一些参数 
2、箭头指向后面要做的事情                         一个箭头
3、箭头后面方法体大括号，代表具体要做的事情          一些代码

1.2、参数

1、 如果参数有多个，那么使用逗号分隔，(Person s,Person) ->{一些代码}

Person[] array = {
        new Person("迪丽热巴",13),
        new Person("张宇晋",26),
        new Person("赵春宇",13),
        new Person("刘利",15)
};

Arrays.sort(array, (Person o1,Person o2) ->{
    return o1.getAge()-o2.getAge();
});

2、如果参数没有，则留空

cookTest(() -> System.out.println("测试"));

1.3、lambda省略格式

1、参数的类型可以省略，同时省略所有的参数类想，要么都写，要么都不写

2、如果参数有且仅有一个，那么小括号可以省略

3、如果大括号中的语句有且仅有一个，那么无论有没有返回值，return ,大括号，分号，都可以省略

1.3.1、接口

public interface Calculator {
    int add(int a,int b);
}

1.3.2、方法进行测试

public class Demo02CallbackValue {

    public void sum(Calculator calculator) {
        int result = calculator.add(100, 200);
        System.out.println("结果是" + result);
    }

	@Test
	public void demo() {
	    sum((int a, int b) -> {
	        return b + a;
	    });
	    sum((a, b) -> a + b);
	}
}

1.4、lambd使用前提

1、必须保证只有一个接口，而且其中的抽象方法有且只有一个

public interface Calculator {
    int add(int a,int b);
}
```java
2、必须具有上下文环境（代理所在的环境）<br/>
3、根据局部变量的复制来推到lambda借口<br/>
</font>

## 2、lambda-方法引用符


### 2.1、java8开始，引入了一个全新的运算符 方法引用符 ::

使用前提：

<font color="red">
 如果对象中有一个成员方法，正好就是lambda表示式所唯一希望使用的内容，那么这个时候就可以使用方法引用，<br/>
 
 格式： 对象名称::方法名称
</font>


```java
lambda写法     s-> System.out.println(s+"是好人")
方法引用写法    System.out::println
  

2.1.1、接口

public interface PrinterInterface {
    void print(String str);
}

2.1.2、测试方法

package com.hlj.java8.Lambda;

import com.hlj.java8.Lambda.Demo03MethodRefPack.PrinterInterface;
import org.junit.Test;

/**
 * java8开始，引入了一个全新的运算符 方法引用符 ::
 *      lambda写法 ： s-> System.out.println(s)
 *      方法引用写法：System.out::println
 */
public class Demo03MethodRef {

    @Test
    public void demo() {
        method(s-> System.out.println(s+"是好人"));
        /**
         * 可推导就是可引用，::方法引用符
         */
        method(System.out::println);
    }

    public void method(PrinterInterface printerInterface){
        printerInterface.print("张宇晋");
    }

}

2.2、对象的引用输出

功能：将我们输入的参数改变为大写

对象的引用输出
new MethodRefObject()::printStringUpper

构造器引用
MethodRefObject::new

静态类方法引用
MethodRefObject::staticPrintStringUpper

2.2.1、接口

public interface MyInterfaceObjectRef {

    void printStringUpper(String str);
}

2.2.2、对象引用

package com.hlj.java8.Lambda.Demo04ObjectRefPack;

/**
 * @Desc:
 * @Author HealerJean
 * @Date 2018/9/14  下午4:15.
 */
public class MethodRefObject {


    public MethodRefObject() {
    }

    /**
     * 静态类方法引用
     *
     *   MethodRefObject::staticPrintStringUpper
     *
     * @param string
     */
    public static void staticPrintStringUpper(String string){
        System.out.println("静态类方法引用"+string.toUpperCase());
    }


    /**
     * 非静态的方法引用
     *   new MethodRefObject()::printStringUpper
     *
     * @param s
     */
    public void printStringUpper(String s) {
        System.out.println("非静态的方法引用"+s.toUpperCase());
    }
    
    
		/**
		 * 构造器引用
		 */
		public MethodRefObject(String s) {
		    System.out.println("构造器引用"+s.toUpperCase());
		}


}

2.2.2、测试

package com.hlj.java8.Lambda;

import com.hlj.java8.Lambda.Demo04ObjectRefPack.MethodRefObject;
import com.hlj.java8.Lambda.Demo04ObjectRefPack.MyInterfaceObjectRef;
import org.junit.Test;


/**
 * @Desc: 对象的引用输出
 * @Author HealerJean
 * @Date 2018/9/14  上午11:48.
 */
public class Demo04ObjectRef {

@Test
public void demo(){

    //lombdb 常规:表达式写法
    method(s->{
        System.out.println(s.toUpperCase());
    });

	//原样输出
	method(System.out::println);

	//对象的引用输出
	method(new MethodRefObject()::printStringUpper);
	//常规输出
	method(s->{
	    new MethodRefObject().printStringUpper(s);
	});


	//静态类方法引用
	method(MethodRefObject::staticPrintStringUpper);
	method(s->{
	    MethodRefObject.staticPrintStringUpper(s);
	});


//构造器引用
method(MethodRefObject::new);
method((s)->{
    new MethodRefObject(s);
});



    public void method(MyInterfaceObjectRef myInterfaceObjectRef){
        myInterfaceObjectRef.printStringUpper("张宇晋");
    }

}

2.2、数组构造器的引用

int[]::new

2.2.1、接口

package com.hlj.java8.Lambda.Demo05ArraytRefPack;

public interface ArrayBuilerInterface {

    int[] build(int length);
}

2.2.2、测试

package com.hlj.java8.Lambda;

import com.hlj.java8.Lambda.Demo05ArraytRefPack.ArrayBuilerInterface;
import org.junit.Test;


/**
 * @Desc: 数组的构造器 引用
 * @Author HealerJean
 * @Date 2018/9/14  上午11:48.
 */
public class Demo05ArraytRef {


    /**
     * 目的只是为了得到一个数组，其实很浮夸了
     */
    @Test
    public void demo(){
        method(int[]::new);

        //和下面这个一样
        method(s-> new int[s]);


    }

    public void method(ArrayBuilerInterface builerInterface){
      int [] n = builerInterface.build(10);
    }


}

3、lombda延迟加载（这样有事可以解决资源浪费的一些问题）

3.1、资源浪费

package com.hlj.java8.Lambda;

import com.hlj.java8.Lambda.Demo06DelayPack.MsgBuiler;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

public class Demo06Delay {

    @Test
    public void demo(){

        String msgA ="Hello" ;
        String msgB = "你好";

        /**
         * 当然只是测试， 如果level等于2的时候， 使用这种方法就白白拼接了，因为最终结果中也没有打印
         */
        logger(2,msgA+msgB);
    }
 
    /**
     * 日志级别为1的时候，打印信息
     * @param level
     * @param msg
     */
    private void logger(int level ,String msg){
        if(level==1){
            System.out.println(msg);
        }
    }
}

3.2、lombda延迟加载

3.2.1、接口

package com.hlj.java8.Lambda.Demo06DelayPack;

/**
 * @Desc:
 * @Author HealerJean
 * @Date 2018/9/14  下午5:30.
 */
public interface MsgBuiler {

    String buildMsg();
}

package com.hlj.java8.Lambda;

import com.hlj.java8.Lambda.Demo06DelayPack.MsgBuiler;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @Desc: lambda延迟执行
 * @Author HealerJean
 * @Date 2018/9/14  上午11:48.
 */
public class Demo06Delay {

    @Test
    public void demo(){

        String msgA ="Hello" ;
        String msgB = "你好";

        /**
         * 使用这种方式可以不浪费资源,下面的 msgA+msgB 不会立刻拼接到一起
         */
        MsgBuiler msgBuiler = () -> {
            System.out.println("执行"); //测试发现不会打印的
            return msgA+msgB;
        };
        loggerLambda(2, msgBuiler);

    }


    private void loggerLambda(int level, MsgBuiler msgBuiler){
        if(level==1){
            System.out.println( msgBuiler.buildMsg());
        }
    }
}

4、lombda作为方法:返回结果,以及作为参数

package com.hlj.java8.Lambda;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

/**
 * @Desc:
 * @Author HealerJean
 * @Date 2018/9/14  上午11:48.
 */
public class Demo08AsCallbackValue {

    @Test
    public void demo(){

        String[] array = {"abc","a","aaa","b"};
        
        
       Arrays.sort(array, new Comparator<String>() {
		    @Override
		    public int compare(String o1, String o2) {
		        return 0;
		    }
		  });


        /**
         * lambdz作为返回值
         */
        Arrays.sort(array,getComparatorOne());

        System.out.println(Arrays.toString(array));
    }


    private static Comparator<String> getComparatorOne(){
        Comparator<String> comparator = (o1,o2) -> o1.length()-o2.length();
        return comparator ;
    }

    private static Comparator<String> getComparatorTwo(){
        return (o1,o2) -> o1.length()-o2.length() ;
    }
}

5、Cousumer ：消费掉我们传入的参数

function.accept(“hello”) 、 andThen

Consumer在 stream中相当于是 ForEach()中执行，

package com.hlj.java8.Lambda;

import org.junit.Test;

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

/**
 *  Consumer在 stream中相当于是 ForEach()中执行
 * @Desc:  Consumer 是我们进行消费掉传入的参数
 *
 * accept andThen
 */
public class Demo09Cousumer {

    @Test
    public void demo(){
        method(s->System.out.println(s));
    }

    /**
     *
     * @param function
     */
    public void method(Consumer<String> function){
        function.accept("hello");
    }


    /**
     * 第一个打印大写字母，第二个打印小写
     */
    @Test
    public void demo2(){
        method2(s->System.out.println(s.toUpperCase()),s2-> System.out.println(s2.toLowerCase()));
    }
    public void method2(Consumer<String> one,Consumer<String> two){
        //下面这个表示先执行one，再执行two
        one.andThen(two).accept("hellow");
    }

}

6、Supplier：我们给提供参数，它产生结果

#### supplier.get()

package com.hlj.java8.Lambda;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Supplier;

/**
 * @Desc:
 * 为了更好的支持函数式编程，
 * 一般放在 java.util.funtion中
 * Supplier是我们给提供，结果
 *
 * get
 *
 *
 * @Author HealerJean
 * @Date 2018/9/14  上午11:48.
 */
public class Demo10Supplier {

    @Test
    public void demo(){
        method(()->"hello");

    }

    /**
     *
     * 1、接触 Supplier
     * @param supplier
     */
    public void method(Supplier<String> supplier){
        String str = supplier.get();
        System.out.println(str);
    }

}

7、Predicate ：断言

#### stream中相当于是 filter()中执行 #### test、 and、 or、 negate

package com.hlj.java8.Lambda;

import org.junit.Test;

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

/**
 *  Predicate stream中相当于是 filter()中执行
 * @Desc: Predicate 对指定类型的对象进行操作，得到的是一个boolean的结果
 *
 * test and or negate
 * @Author HealerJean
 * @Date 2018/9/14  上午11:48.
 */
public class Demo11Predicate {

    @Test
    public void demo(){
        method(s->s.length()>3);
    }


    public void method(Predicate<String> predicate){
      boolean vertlong =    predicate.test("hello");
        System.out.println("长不长"+vertlong);
    }

    /**
     * Predicate 拼接  and两个同时成立 ，or不写
     */
    @Test
    public void demo2(){
        method2(one->one.length()>3,two->two.startsWith("h"));
    }
    public void method2(Predicate<String> one,Predicate<String> two){
        boolean vertlong  =  one.and(two).test("hello");
        System.out.println("长不长"+vertlong);

    }

    /**
     * negate 取反  如果是true，返回取反就是false
     */
    @Test
    public void demo3(){
        method3(s-> s.length()>3);
    }
    public void method3(Predicate<String> predicate){
        boolean vertlong =   predicate.negate().test("hello");
        System.out.println("长不长"+vertlong);
    }

}

8、function ：传入参数返回结果，Cousumer没有返回结果。

Function 相当于stram中的map

function.apply(“20”);

package com.hlj.java8.Lambda;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

/**
 * @Desc: Function 相当于stram中的map
 * @Author HealerJean
 * @Date 2018/9/14  上午11:48.
 */
public class Demo12Function {

    @Test
    public void demo(){
        method(s -> Integer.parseInt(s));

        method( Integer::parseInt);
    }

    /**
     * apply Integer是表示出的结果
     * @param function
     */
    public void method(Function<String ,Integer> function){
      int num =    function.apply("20");
      num += 100;
        System.out.println("结果是"+num);
    }



}

代码下载