学习笔记——函数式编程（Lambda表达式、方法引用）

Lambda表达式

从jdk1.8开始，利用lambda可以实现函数式编程，避免掉面向对象编程的一些繁琐问题。

例子：观察传统开发问题

interface Message {    //定义接口
publicabstract  void send(String x); //抽象方法
   }
public class N {
public static void main(String[] args) {
    Message a=new Message(){   //匿名内部接口实现
	public void send(String x){
		System.out.println("消息发送："+x); //幸福安康
    	}
	};
a.send("幸福安康");
	}
}

此代码中核心语句只有一行，但是为了实现该语句，需要按照面向对象结构进行编写。
例子：使用Lambda

interface Message {  
public void send(String x);
    }
public class N {
public static void main(String[] args) {
    Message a=(x)->{
		System.out.println("消息发送："+x); //幸福安康
	};
a.send("幸福安康");
	}
}

利用这种结构避免了面向对象的复杂处理结构。Lambda若要进行使用，就必须要有一个重要的实现要求：SAM(Single Abstract Method),只有一个抽象方法。
如果一个接口中只提供一个方抽象法，除此之外没有其他任何抽象方法，这样的接口就称为函数式接口。而只有函数式接口才可以被Lambda表达式所使用。在其接口前添加如下代码表示为函数式接口：@FunctionalInterface //函数式接口
对于Lambda表达式，提供如下几种格式：
1·方法没有参数：（）->{ }
2·方法有参数：（参数，参数）->{ }
3·如果现在只有一行语句返回：（参数，参数）->语句
例子：定义没有参数的方法

@FunctionalInterface //函数式接口
interface Message {  
public void send();
public default void end(){}
  }
public class N {
public static void main(String[] args) {
   Message a=( )->{
		System.out.println("消息发送：幸福安康"); //幸福安康
	};
a.send();
	}
}

例子：定义有参数处理过程

@FunctionalInterface //函数式接口
interface Message {  
public int add(int x,int y);
  }
public class N {
public static void main(String[] args) {
   Message a=(t1,t2)->{  //注意此处仍用参数
		return t2+t1;
	};
System.out.println(a.add(10,20));//30
	}
}

例子：一行简化(适用于只有一个抽象方法，并且该方法具有返回值的接口)

@FunctionalInterface //函数式接口
interface Message {  
public int add(int x,int y);
    }
public class N {
public static void main(String[] args) {
   Message a=(t1,t2)->t2+t1;
System.out.println(a.add(10,20));//30
	}
}

---

方法引用

利用方法引用可以为一个方法定义多个方法名字，但是要求必须是函数式接口（SAM标准）。
引用数据类型最大的特点是可以进行内存的指向处理，传统的开发之中一直所使用的只是对象的引用操作。从jdk1.8开始提供有方法的引用。即不同的方法名称可以描述同一个方法。如果要进行方法的引用，Java提供以下四种形式：

例子：引用静态方法
·在String类中提供的String.valueOf()方法属于静态方法；
——方法定义：public static String vaueOf(int i)；该方法有参数，有返回值。

@FunctionalInterface //函数式接口
//p描述的是参数，R描述的是返回值
interface IMessage<P,R> {  
public R change(P p);
    }
public class N {
public static void main(String[] args) {
  IMessage<Integer,String> fun = String :: valueOf;
  String a=fun.change(100000);
  System.out.println(a.length()); //6
	}
}

例子：引用实例化对象方法
·在String里面有一个转大写的方法；
——方法定义：public String toUpperCase( );这个方法必须在有实例化对象情况下才可以调用。

@FunctionalInterface //函数式接口
interface IMessage<R> {  
	public R upper( );
}
public class N {
public static void main(String[] args) {
  IMessage<String> fun = "为人民谋幸福" :: toUpperCase;
  System.out.println(fun.upper()); //
	}
}

例子：引用特定类中的操作方法
·String类中提供比较大小关系的方法；
——方法定义：public int compareTo(String anotherString);这是一个普通方法，如果要引用普通方法，则往往要进行对象实例化，但是不想给出实例化对象，只想对该方法进行引用，就可以使用特定类来进行处理。

@FunctionalInterface //函数式接口
interface IMessage<P> {  
 public int compare(P p1,P p2);
    }
public class N {
public static void main(String[] args) {
  IMessage<String> fun = String :: compareTo;
  System.out.println(fun.compare("12","13")); //-1
    }
}

例子：构造方法引用

class Person{
private String name;
private int age;
public Person(String name,int age){
	this.name=name;
    this.age=age;
	}
public String toString(){
return "姓名："+this.name+"、年龄："+this.age;
	}
}
@FunctionalInterface //函数式接口
interface IMessage<R> {  
public R create(String x,int y);
}
public class N {
public static void main(String[] args) {
  IMessage<Person> fun = Person :: new ;
  System.out.println(fun.create("苏沐橙",19)); //苏沐橙、19
	}
}

总结：
引用静态方法：有参数，有返回值；
引用对象的方法：必须要有实例化对象才可以调用；
引用特定类方法：避免实例化对象，只对该方法进行引用；

---

内建函数式接口

系统中提供大量函数式接口，可以直接引用。在系统中提供有一个java.util.function开发包，里面可以直接使用函数式接口，如下：
1·功能型函数式接口：
·在String类中有一个方法判断是否以指定的字符串开头：
public boolean startsWith(String str);

接口定义

@FunctionalInterface
public interface Function<T,R>{
public R apply(T t);
}	

接口使用

import java.util.function.*;
public class N {
public static void main(String[] args) {
  Function<String,Boolean> fun = "123456" :: startsWith ;
  System.out.println(fun.apply("12")); 
    }
}

运行结果 true
2·消费式函数接口：只能进行数据处理操作，而没有任何返回；
·在进行系统数据输出时候使用：System.out.println();
接口定义

@FunctionalInterface
public interface Consumer<T>{
public void accept(T t);
}	

接口使用

import java.util.function.*;
public class N {
public static void main(String[] args) {
  Consumer<String> fun = System.out :: println;
 fun.accept("1234567"); 
	}
}

运行结果 123456
3·供给型函数式接口：
·在String类中提供有转小写方法，这个方法没有接收参数，但是有返回值：
public String toLowerCase();
接口定义

@FunctionalInterface
public interface Supplier<T>{
public T get();
}	

接口使用

import java.util.function.*;
public class N {
public static void main(String[] args) {
  Supplier<String> fun = "aAbBcC" :: toLowerCase;
  System.out.println(fun.get());
	}
}

运行结果 aabbcc

4·断言型函数式接口：
·进行判断处理:String有一个方法：equalsIgnoreCase()
接口定义

@FunctionalInterface
public interface Predicate<T>{
public boolean test(T t);
}	

接口使用

import java.util.function.*;
public class N {
public static void main(String[] args) {
   Predicate<String> fun = "aAbBcC" :: equalsIgnoreCase;
  System.out.println(fun.test("waeg"));
	}
}

运行结果 false