函数式引用

所谓方法引用，是指如果某个方法签名和接口恰好一致，就可以直接传入方法引用。方法签名只看参数类型和返回类型，不看方法名称，也不看类的继承关系。不论方法是静态方法还是实例方法。
(类::实例) 方法有一个隐含的this参数，String类的compareTo()方法 public int compareTo(String o) 在实际调用的时候，第一个隐含参数总是传入this，相当于静态方法public static int compareTo(this, String o);
(类::构造方法)虽然没有return语句，但它会隐式地返回this实例
(实例::实例)实例变量调用实例方法。

FunctionalInterface允许传入：
接口的实现类（传统写法，代码较繁琐）；
Lambda表达式（只需列出参数名，由编译器推断类型）；
符合方法签名的静态方法；
符合方法签名的实例方法（实例类型被看做第一个参数类型）；
符合方法签名的构造方法（实例类型被看做返回类型）。
FunctionalInterface不强制继承关系，不需要方法名称相同，只要求方法参数（类型和数量）与方法返回类型相同，即认为方法签名相同。

package com.example.test;

import com.sun.istack.internal.NotNull;

import java.util.Arrays;
import java.util.Comparator;

public class TestFunctionalInterface {
    public static void main(String[] args) {
        MyString[] array = new MyString[]{};
        Arrays.sort(array, new MyString()::compare);
        Arrays.sort(array, MyString::compareTo);
        Arrays.sort(array, MyString::compareTo1);
    }

    static class MyString implements Comparator<MyString>  {
        @Override
        public int compare(MyString o1, MyString o2) {
            return 0;
        }

        public static int compareTo(MyString s, MyString anotherString) {
            return 0;
        }

        public int compareTo1( MyString anotherString) {
            return 0;
        }
    }
}

传入

// 定义一个类
public class ActivitiTools<T extends IAuditable>;
// 类方法
public void setAuditStatus(List<T> orderList, Function<T, String> function, IAuditFunction<T> auditFunction);
// 结合泛型消除 non-static method cannot be referenced
// from a static context
@Autowired
private ActivitiTools<GoodsVo> activitiTools;
// 传入函数
activitiTools.setAuditStatus(vos, GoodsVo::getApplyCode,GoodsVo::setAuditStatus);

使用Optional避免空指针

• 对象为空

User user=null;
Optional.ofNullable(user).orElseGet(User::new).getName();

• 为为空的值设置默认值

String aaa = null;
Optional.ofNullable(aaa).orElse("");

• 引用装箱的值参与计算报空指针

   Integer a = null;
   Optional.ofNullable(a).orElse(0);

• 使用filter

 Optional<User> userOption = Optional.of(user);
 User user1 = userOption.filter(e -> e.getName() == null).orElseGet(User::new);

• 使用map

User  user=new User("王五",null);
Integer age = Optional.of(user).map(e -> e.getAge()).orElse(1);

• filter map合起来使用

User user2 = new User("zhaosi", 1);
Optional<String> s = Optional.of(user2).filter(e->e.getAge()==1).map(e -> e.getName());
s.ifPresent(e-> {
	System.out.println();
 	System.out.println("值存在");
    });

• 配合Stream

Optional<YourEntity> result= list.stream() 
                          .filter(a -> "xx".equals(a.getName())) 
                          .findFirst();	
		//获取对象						  
if (result.isPresent()) {
	YourEntity a = result.get();
}
		
		//通过 ifPresent 直接处理结果集
Optional<YourEntity> result2= list.stream() 
                          .filter(a -> "xx".equals(a.getName())) 
                          .findFirst()
                          .ifPresent(a -> {
                              a.setName("yy");
                          })
						  
	    //得到过滤后的集合
List<YourEntity> result3= list.stream() 
                      .filter(a -> "xxx".equals(a.getName())) 
                      .collect(Collectors.toList());
		
		//获取对象中所有id的集合
List<String> ids = list.stream().map(YourEntity::getId).collect(Collectors.toList());
		
		//获取Map
Map<String, YourEntity> mapResult = list.stream()
.filter(a->StringUtil.isNotEmpty(a.getName())).collect(Collectors.toMap(YourEntity::getId, a -> a));

Optional使用例子

// 为空抛出错误
Optional.ofNullable(str).orElseThrow(()->new Exception("blabla"));
  // user.name为空返回""
 String city = Optional.ofNullable(user).map(u-> u.getName()).orElseGet("");
  // 需求
 if(user!=null){
 	if(user.getAddress()!=null){
  		Address address = user.getAddress();
  		if(address.getCity()!=null)
  			return address.getCity();
  	}
 }else{
    throw new Excpetion("取值错误");
 } 
  // 需求表示如下
  Optional.ofNullable(user)
                     .map(u-> u.getAddress())
                     .map(a->a.getCity())
                     .orElseThrow(()->new Exception("取指错误"));
  // 需求
  if(user!=null{dosomething(user)};
  // 表示如下
  Optional.ofNullable(user).ifPresent(u->{dosomething(u);});
  // 需求
  public User getUser(User user) throws Exception{
  	if(user!=null){
  		String name = user.getName();
  		if("zhangsan".equals(name))
  			return user;
  }else{
  	user = new User();
  	user.setName("zhangsan");
  	return user;
  }
  // 表示如下
  public User getUser(User user) {
  	return Optional.ofNullable(user)
  	.filter(u->"zhangsan".equals(u.getName()))
  	.orElseGet(()-> {
  		User user1 = new User();
  		user1.setName("zhangsan");
  		return user1;
  	});
  }