函数式接口的学习记录

函数式接口:有且仅有一个抽象方法的接口
Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能利地进行推导
如何检测一个接口是不是函数式接口呢?
把 @Functionallnterface  放在接口定义的上方:如果接口是函数式接口，编译通过;如果不是，编译失败
 

---

函数式接口作为方法的参数：
定义一个类(RunnableDemo)，在类中提供两个方法
一个方法是: startThread(Runnable r)方法参数Runnable是一个函数式接口一个方法是主方法，在主方法中调用startThread方法
 

package lambda;

public class RunnableDemo {

	public static void main(String[] args) {
	    //匿名内部类
		startThread(new Runnable() {		
			@Override
			public void run() {
		 System.out.println(Thread.currentThread().getName()+"线程启动了");			
			}
		});
         //lambda
		startThread(()->System.out.println(Thread.currentThread().getName()+"线程启动了"));
		//如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递
	}
	private static void startThread(Runnable r) {
		Thread t=new Thread(r);
		t.start();
	}

}

---

函数式接口作为方法的返回值：

定义一个类(ComparatorDemo)，在类中提供两个方法
一个方法是:Comparator<String> getComparator() 方法返回值Comparator是一个函数式接口      一个方法是主方法，在主方法中调用getComparator方法
类(ComparatorDemo)：

package lambda;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ComparatorDemo {

	public static void main(String[] args) {
		//构造使用场景
		//定义集合存储字符串元素
		ArrayList<String> array =new ArrayList<String>();
		array.add("aaaa");
		array.add("zzz");
		array.add("pp");
		array.add("o");
		System.out.println("排序前："+array);
		Collections.sort(array,getComparator());
		System.out.println("排序后："+array);
	}
    private static Comparator<String> getComparator() {
    	//匿名内部类的方式实现
//    	Comparator<String> com =new Comparator<String>() {
//    		@Override
//    		public int compare(String s1,String s2) { 
//    			return s1.length()-s2.length();
//    		}
//    	};
//    	return com;
    	//lambda表达式
    	//如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回
    	return (s1,s2)->{
    		return s1.length()-s2.length();
    	};
    }
    }

---

Supplier接口：

Supplier<T>:包含一个无参的方法
T get():获得结果
该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用
 

package lambda;

import java.util.function.Supplier;

public class Supplierdemo {
      public static void main(String[] args) {
		String s= getstring(()-> {
			return "许巍"; 				
		});
		System.out.println(s);
		Integer i=getinteger(()->{
			return 40;
		});
		System.out.println(i);
	}
      //定义一个方法，返回一个整型数据
      private static Integer getinteger(Supplier<Integer> sup) {
    	  return sup.get();
      }
      //定义一个方法，返回一个字符串数据
      private static String getstring(Supplier<String> sup) {
    	  return sup.get();
      }
}

Supplier接口练习获取最大值

package lambda;

import java.util.function.Supplier;

public class Supplierdemo1 {

	public static void main(String[] args) {
		int [] a= {11,45,65,23,10};
		int m=getmax(()->{
			int max=a[0];
		for(int i=1;i<a.length;i++) {
			if(a[i]>max)
				max=a[i];
		}
		    return max;
		});
           System.out.println(m);
	}
	 private static Integer getmax(Supplier<Integer> sup) {
   	  return sup.get();
     }
}

---

Consumer接口

Consumer<T>:包含两个方法
void accept(T t):对给定的参数执行此操作
default Consumer<T> andThen(Consumer after):返回一个组合的Consume，依次执行此操作，然后执行after操作
Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定
 

package lambda;

import java.util.function.Consumer;

public class Consumerdemo {

	public static void main(String[] args) {
		opstring("郑钧",(String name) ->{
		System.out.println(name);
		});
		opstring("崔健",(String name)->{
			System.out.println(name);},(String name)->{System.out.println(new StringBuilder(name).reverse().toString());
		});
	}
	//定义一个方法，用不同方式消费同一个字符串数据
    private static void opstring(String name,Consumer<String> con1,Consumer<String> con2) {
//    	con1.accept(name);
//    	con2.accept(name);
    	con1.andThen(con2).accept(name);
    }
	//定义一个方法，消费一个字符串数据
    private static void opstring(String name,Consumer<String> con) {
    	con.accept(name);
    }
}

 练习
String[] strArray = {"林青霞,30","张曼玉,35","王祖贤,33"};
字符串数组中有多条信息，请按照格式:“姓名:XX,年龄:XX"的格式将信息打印出来

要求:
把打印姓名的动作作为第一个Consumer接口的Lambda实例

把打印年龄的动作作为第二个Consumer接口的Lambda实例

将两个Consumer接口按照顺序组合到一起使用

package lambda;

import java.util.function.Consumer;

public class Consumerdemo1 {

	public static void main(String[] args) {
		String[] str= {"窦唯,40","谢天笑,50","彭磊,35"};
		p(str,(String s)->{
		String name=s.split(",")[0];
		System.out.print("姓名："+name);
		},(String s)-> {
			int age=Integer.parseInt(s.split(",")[1]);
			System.out.println(",年龄："+age);
		});

	}
    private static void p(String[] str,Consumer<String> con1,Consumer<String> con2) {
    	for(String s:str) {
    		con1.andThen(con2).accept(s);
    	}
    }
}

---

Predicate接口

Predicate<T>:常用的四个方法

1.boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值

2.default Predicate<T> negate():返回一个逻辑的否定，对应逻辑非

3.default Predicate<T> and(Predicate other):返回一个组合判断，对应短路与

4.default Predicate<T> or(Predicate other):返回一个组合判断，对应短路或

Predicate<T>接口通常用于判断参数是否满足指定的条件
 

package lambda;

import java.util.function.Predicate;

/*
 * Predicate<T>:常用方法
	
	1.boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
	
	2.default Predicate<T> negate():返回一个逻辑的否定，对应逻辑非

	Predicate<T>接口通常用于判断参数是否满足指定的条件
 */
public class Predicatedemo1 {

	public static void main(String[] args) {
	boolean b1=checking("hello",(String s) ->{
	return s.length()>8;
	});
       System.out.println(b1);
       boolean b2=checking("hellojava",(String s) ->{
    		return s.length()>8;
    		});
    	       System.out.println(b2);
	}
	//判断给定字符串是否满足条件
	//boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
     public static boolean checking(String s,Predicate<String> pre) {
//    	 return pre.test(s);
   	 return pre.negate().test(s);//default Predicate<T> negate():返回一个逻辑的否定，对应逻辑非
     }
}

package lambda;

import java.util.function.Predicate;

/*
 * Predicate<T>:常用方法

  default Predicate<T> and(Predicate other):返回一个组合判断，对应短路与

  default Predicate<T> or(Predicate other):返回一个组合判断，对应短路或

  Predicate<T>接口通常用于判断参数是否满足指定的条件

 */
public class Predicatedemo2 {

	public static void main(String[] args) {
		boolean a=checking("hello",(String s) ->{
		return s.length()>8;},(String s)->{
			return s.length()<15;
		});
        System.out.println(a);
	}
	//判断给定字符串是否满足条件
		//boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
	     public static boolean checking(String s,Predicate<String> pre1,Predicate<String> pre2) {
//	    	 boolean b1 = pre1.test(s);
//	    	 boolean b2=pre2.test(s);
//	    	 boolean b=b1&&b2;
//	    	 return b;
	  //default Predicate<T> and(Predicate other):返回一个组合判断，对应短路与
	    	// return pre1.and(pre2).test(s);
	  //----------------------------------------------------------------  	 
// 	    	 boolean b1 = pre1.test(s);
//	    	 boolean b2=pre2.test(s);
//	    	 boolean b=b1||b2;
//	    	 return b;
	   //  default Predicate<T> or(Predicate other):返回一个组合判断，对应短路或
	    	 return pre1.or(pre2).test(s);
	     }
}

练习

String[] strArray= {"林青霞,30","柳岩,34","张曼玉,35","貂蝉,31","王祖贤,33"};

字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合同时满足如下要求:姓名长度大于2;年龄大于33

分析

有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断

package lambda;

import java.util.ArrayList;
import java.util.function.Predicate;

public class Predicatedemo3 {
   public static void main(String[] args) {
	   String[] strArray= {"林青霞,30","柳岩,34","张曼玉,35","貂蝉,31","王祖贤,33"};
	   ArrayList<String> array =mya(strArray, s->s.split(",")[0].length()>2,
			  s->Integer.parseInt(s.split(",")[1])>33);
	   for(String s:array) {
		   System.out.println(s);
	   }  	
}
   public static ArrayList<String> mya(String[] a,Predicate<String> pre1,Predicate<String> pre2){
	   //定义一个集合
	   ArrayList<String> a1=new ArrayList<String>();
	   //遍历数组
	   for(String str:a) {
		   if(pre1.and(pre2).test(str)) {
			 //把符合条件的添加到集合
			   a1.add(str);
		   }
	   }
		return a1;   
   }
}
 

---

Function接口
Function<T,R>:常用的两个方法
1.R apply(T t):将此函数应用于给定的参数
2.default <V> Function andThen(Function after):返回一个组合函数，首先将该函镂
应用于输入，然后将after函数应用于结果

Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)
然后返回一个新的值

package lambda;

import java.util.function.Function;

/*
 * Function<T,R>:常用的两个方法
	R apply(T t):将此函数应用于给定的参数
	default <V> Function andThen(Function after):返回一个组合函数，首先将该函镂
	应用于输入，然后将after函数应用于结果
	Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)然后返回一个新的值
 */
public class Functiondemo1 {
    public static void main(String[] args) {
		c1("100",s-> Integer.parseInt(s));
		c2(555,i->String.valueOf(i+666));
		c3("100",s->Integer.parseInt(s),i->String.valueOf(i+666));
	}
  //定义一个方法，把一个字符串转换int类型，在控制台输出
    public static void c1(String s,Function<String,Integer> fun) {
    	Integer i=fun.apply(s);
    	System.out.println(i);   	
    }
  //定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
    public static void c2(int i,Function<Integer,String> fun) {
    	String s=fun.apply(i);
    	System.out.println(s);
    }
  //定义一个方法，把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出
    public static void c3(String s,Function<String,Integer> fun1,Function<Integer,String> fun2) {
  //  	Integer i=fun1.apply(s);
  //  	String ss=fun2.apply(i);
  //  	System.out.println(ss);
    	String ss=fun1.andThen(fun2).apply(s);
    	System.out.println(ss);
    }
}

练习
String s = "林青霞,30";
1:将字符串截取得到数字年龄部分
2:将上一步的年龄字符串转换成为int类型的数据
3:将上一步的int数据加70，得到一个int结果，在控制台输出
请通过Function接口来实现函数拼接
 

package lambda;

import java.util.function.Function;

/*
 * 练习
	String s = "林青霞,30";
	1:将字符串截取得到数字年龄部分
	2:将上一步的年龄字符串转换成为int类型的数据
	3:将上一步的int数据加70，得到一个int结果，在控制台输出
	请通过Function接口来实现函数拼接
 */
public class Functiondemo2 {

	public static void main(String[] args) {
		String s = "林青霞,30";
		c1(s,(String ss)->{
			return s.split(",")[1];
		},(String ss)->{
		  return Integer.parseInt(ss);
		},(Integer i)->{ 
			return i+70;
		});
	}
     public static void c1(String s,Function<String,String> fun1,Function<String,Integer> fun2,Function<Integer,Integer> fun3) {
		int i=fun1.andThen(fun2).andThen(fun3).apply(s);
		System.out.println(i);
	}
}