Java8函数式接口

一、功能型（Function）接口

• 特性： 只有一个参数，并且带有 返回值
• Java8: Interface Function<T,R>
• 实现的原理如下：

/**  *  * 函数式接口 有一个参数，并且有返回值  * @author Administrator  *  */

@FunctionalInterface
interface FunctionDemo<T,R>{
	public R apply(T t);
}
public class FTest {
	public static void main(String[] args) {
		FunctionDemo<String,Integer> fd = Integer::valueOf;
		int res = fd.apply("12321312");
		System.out.println(res);
		
		//等价于 lamda 		FunctionDemo<String,Integer> fd2 = (String t)->{
			return Integer.valueOf(t);
		};
		int res2 = fd.apply("12321312");
		System.out.println(res2);
		
		FunctionDemo<String,Integer> fd3 = new FunctionDemo<String,Integer>(){
			public Integer apply(String s) {
				return Integer.valueOf(s);
			}
		};
		int res3 = fd.apply("12321312");
		System.out.println(res3);
		
}

二、工厂型（Supplier）函数接口

• 特性： 只有返回值，没有参数
• Java8: Interface Supplier<T>
• 实现的原理如下：

/*  * 工厂型函数接口 只返回值 没有参数  * */

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

class Parent {
	private String name;
	private int age;
	public Parent() {
		this("凡高文化艺术工作室", 12);
	}
	
	public Parent(String n,int a) {
		name = n;
		age = a;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}

public class FTest {
	public static void main(String[] args) {
		
		SupplierDemo<Parent> sd = Parent::new ;
		Parent p = sd.get();
		System.out.println(p);
		
		//等价于 		 
		SupplierDemo<Parent> sd1 = ()->{
			return  new Parent();
		} ;
		Parent p1 = sd1.get();
		System.out.println(p1);
		
		//等价于 		
		SupplierDemo<Parent> sd2 = new SupplierDemo<Parent>(){

			@Override
			public Parent get() {
				// TODO Auto-generated method stub 				return new Parent();
			}
			
		} ;
		Parent p2 = sd1.get();
		System.out.println(p2);
		
		
}

三、消费型(Consumer)函数接口

• 特性： 只有返回值，没有参数
• Java8: Interface Supplier<T>
• 实现的原理如下：

/**  * 消费型函数接口 ，没有返回值  * @author 凡高文化艺术工作室  * @param <T>  */
@FunctionalInterface 
interface ConsumerDemo<T> {
	public void accept(T t);
}
/**  *  * 消费型函数接口  * @author Administrator  *  */
public class FTest {
	public static void main(String[] args) {

                //方法引用 		ConsumerDemo<String> d = System.out::println;
		d.accept("账号");

                //等价于 lamda 		ConsumerDemo<String> d2 = (t)->System.out.println(t);
		d2.accept("lamda");
                
                //等价于 匿名内部类的 		ConsumerDemo<String> d3 = new ConsumerDemo<String>(){
			public void accept(String t) {
				System.out.println(t);
			}
		};
		d3.accept("这才是真正的");
	}
}

四、断言型(Predicate)函数接口

• 特性： 只有一个参数，返回值 为 布尔(Boolean) 类型
• Java8: Interface Predicate<T>
• 实现的原理如下：

/**  *  *  * 断言型函数接口 返回Boolean布尔类型  */

@FunctionalInterface 
interface PredicateDemo<T,R> {
	public Boolean test(T t,R r);
}
public class FTest {
	public static void main(String[] args) {

		//方法引用 		PredicateDemo<String,String> str = String::equals;
		Boolean b  = str.test("ceshi","ceshi");
		System.out.println(b);


		//等价于 lamda 		PredicateDemo<String,String> str2 = (s1,s2)->s1.equals(s2);
		Boolean b1  = str2.test("ceshi","ceshi");
		System.out.println(b1);

		//等价于 匿名内部类 		PredicateDemo<String,String> str3 = new PredicateDemo<String,String>(){
			public Boolean test(String s1,String s2) {
				return s1.equals(s2);
			}
		};
		Boolean b2  = str3.test("ceshi","ceshi");
		System.out.println(b2);

	}
}