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);
}



}

代码下载