Lambd表达式的使用
范例：传统的面向对象开发
interface IMessage2{
void print();
}
public class TestDemo {
public static void main(String[] args) {
IMessage2 message2 = new IMessage2() {//匿名内部类
@Override
public void print() {
System.out.println("MyMessage");
}
};
message2.print();
}
}
对于此类操作有了更简化实现，如果采用函数式编程，则代码如下：
范例：函数式编程
@FunctionalInterface//表明函数式编程
interface IMymessage3{
void print();
}
public class Test16 {
public static void main(String[] args) {
IMymessage3 mymessage3 =()-> System.out.println("MyMessage");
mymessage3.print();
}
}
面向对象语法最大的局限：结构必须非常完整。
要想使用函数式编程有一个前提：接口必须只有一个抽象方法，如果有两个抽象方法，则无法使用函数式编程。如果现在某个接口就是为了函数式编程而生的，最好定义时就让其只能够定义一个抽象方法，所以有了一个新注解@FunctionalInterface注解。
Lambda表达式语法
Lambda表达式语法：(参数) -> {} ;(多行时)，(参数) -> 单行语句.
范例：多行语句
@FunctionalInterface
interface IMessage{
public void print();
}
public class TestDemo{
public static void main(String[] args){
IMessage message = () -> {
System.out.println("hello");
System.out.println("world");
System.out.println("hello world");
};
message.print();
}
}
如果现在你的表达式里只有一行进行数据的返回，那么直接使用语句即可，可以不使用return
范例：直接进行计算
@FunctionalInterface
interface IMath{
int add(int a,int b);
}
public class Test17 {
public static void main(String[] args) {
IMath math = (p1,p2) ->(p1+p2);
System.out.println(math.add(20,30));
}
}
方法引用
引用静态方法：类名称::static 方法名
引用某个对象的方法：实例化对象::方法名
引用某个特定类的方法：类名称::普通方法
引用构造方法：类名称::new
范例：String类的valueOf()方法
/**
* 静态方法的引用
* @author 喵先生
*
* @param <P>
* @param <R>
*/
@FunctionalInterface
interface IMyMessage<P, R> {
R switchPara(P p);
}
public class Test1 {
public static void main(String[] args) {
IMyMessage<Integer, String> message = String::valueOf;// 进行方法引用
String str = message.switchPara(100);// 相当于调用了String.valueOf
System.out.println(str.length());
}
}
范例：引用对象方法
String中的toUpperCase()方法为对象方法
/**
* 引用对象方法：String中的toUpperCase()方法为对象方法
* @author 喵先生
*
* @param <R>
*/
@FunctionalInterface
interface IMyMessage2<R> {
R switchpara();
}
public class Test2 {
public static void main(String[] args) {
IMyMessage2<String> iMyMessage5 = "hello"::toUpperCase;
System.out.println(iMyMessage5.switchpara());
}
}
范例：引用类中普通方法
String类中有一个compareTo方法，此方法为普通方法
/**
* 引用类中普通方法：String类中有一个compareTo方法，此方法为普通方法
* @author 喵先生
*
* @param <R>
* @param <P>
*/
@FunctionalInterface
interface IMyMessage6<R, P> {
R compare(P p1, P p2);
}
public class Test3 {
public static void main(String[] args) {
IMyMessage6<Integer, String> message6 = String::compareTo;
System.out.println(message6.compare("侯", "姚"));
}
}
范例：引用构造方法
public class Student {
String name;
int age;
String area;
public Student() {}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getArea() {
return area;
}
public void setArea(String area) {
this.area = area;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
/**
* 引用构造方法
*
* @author 喵先生
*
* @param <R>
* @param <PN>
* @param <PA>
*/
@FunctionalInterface
interface IMyPerson<R,PN,PA>{
R message(PN name,PA age);
}
public class Test4 {
public static void main(String[] args) {
IMyPerson<Student,String,Integer> myPerson = Student::new;
System.out.println(myPerson.message("Jack",21));
}
}
内建函数式接口
Lambda的核心在于：函数式接口。而函数式接口的核心：只有一个抽象方法
java.util.function实际上函数式编程分为以下四种接口：
功能性函数式接口：public interface Function<R,T> R apply(T t);
供给型函数式接口: public interface Supplier T get();
消费型函数式接口：public interface Consumer void accept(T t);
断言型接口：public interface Predicate boolean test(T t);
功能型接口
功能型指的是你输入一个数据，而后将数据处理后进行输出
实际上所有的函数式接口里面都会有一些小的扩展。
import java.util.function.Function;
/**
* 功能型指的是你输入一个数据，而后将数据处理后进行输出
* 实际上所有的函数式接口里面都会有一些小的扩展
*
* @author 喵先生
*
*/
public class Test1 {
public static void main(String[] args) {
Function<Integer, String> function = String::valueOf;
String str = function.apply(100);
System.out.println(str.length());
}
}
如果现在确定操作的数据是int，则可以使用IntFunction接口
import java.util.function.IntFunction;
/**
* 如果现在确定操作的数据是int，则可以使用IntFunction接口
* @author 喵先生
*
*/
public class Test2 {
public static void main(String[] args) {
// 注意这里的接口名和之前不同
IntFunction<String> function = String::valueOf;
String str = function.apply(111);
System.out.println(str.length());
}
}
供给型接口
import java.util.function.Supplier;
/**
* 供给型接口
* @author 喵先生
*
*/
public class Test3 {
public static void main(String[] args) {
Supplier<String> stringSupplier = "hello"::toUpperCase;
System.out.println( stringSupplier.get() );
}
}
消费型接口
import java.util.function.Consumer;
/**
* 消费型接口
* @author 喵先生
*
*/
public class Test4 {
public static void main(String[] args) {
Consumer<String> consumer = System.out::println;
consumer.accept("hehe");
}
}
断言型接口
import java.util.function.Predicate;
/**
* 断言型接口
* @author 喵先生
*
*/
public class Test5 {
public static void main(String[] args) {
Predicate<String> pre = "###123shdsb"::startsWith;
System.out.println( pre.test("##") );
}
}
