1.函数式接口
JDK1.8版本以上有效
- @FunctionalInterface语法要求当前接口只有一个尚未完成的省缺属性为public abstract修饰方法。
- 函数式接口里允许定义默认方法和静态方法
- 函数式接口一般用于方法增强，直接作为方法的参数，实现插件式编程。
格式
@FunctionalInterface interface test{ void test(); }
用途
lambda表达式和方法引用
2.lambda表达式
基本格式
(联想参数变量) -> {执行任务代码块}
lambda表达式关注的是接口中的方法的返回值和参数。方法名不重要
2.1无参数无返回值
设计接口
函数式接口，当作下面方法的参数
@FunctionalInterface interface A{ void 方法名(); }
设计方法
将上面的接口当作参数
public static void testLambda(A a){ a.方法名; }
代码实现
/* 匿名内部类方式 */ testLambda(new A(){ @Override public void 方法名(){ System,out.println("匿名内部类对象方法实现"); } }); /* lambda表达式实现 */ testLambda(() -> { System.out.println("lambda表达式"); }) /* lambda表达式优化 */ testLambda(() -> System.out.println("lambda表达式优化")); /* 方法引用 */ testLambda(当前类的类名::test); /*方法引用调用的方法*/ public static void test(){ System.out.println("方法引用"); }
2.2 无参数有返回值
生产者接口
设计接口
@FunctionalInterface interface Supplier<T>{ T get(); }
设计方法
/** *返回一个字符串数据内容 * *@params s 生产者 *@return */ public static String testLambda(Supp;ier<String> s){ return s.get(); }
代码实现
/* 匿名内部类形式 */ String s = testLambda(new Supplier<String>){ @Override public String get(){ return "一个字符串"; } }); System.out.println(s); /* lambda表达式 */ String s1 = testlambda(() -> { return "也是一个字符串“; }) Sysout.out.println(s1); /* lambda优化 */ String s2 = testLambda(() -> "还是一个字符串"); System.out.println(s2); /* lambda使用方法局部变量 */ String str = "依旧&还是一个字符串"; String s3 = testLambda((str) ->{ Sttring[] split = str.split(&); return split[0]; }) System.out.prinln(s3); /* 方法引用 */ String s4 = testLambda(目标方法所处类的类名::方法名); System.out.println(s4); //方法引用所使用的方法 public static String 方法名{ return "被引用的方法"; }
2.3有参数无返回值
消费者接口
接口设计
@Functionalface public interface Consumer<T>{ void accept(T t); }
方法设计
consumer可以传入实现类对象和lambda表达式
public static void testLambda(String str , Consumer<String> handle){ //需要方法外部针对传入的字符串参数有处理能力 //通过Consumer接口传入 handle.accept(str); }/* 匿名内部类方式 */ testLambda("字符串"，Consumer<String>(){ @Override public void accept(String t){ System.out.println(t); } }); /* lambda表达式 */ testLambda("一个字符串",(s) ->{ System.out.println(Arrays.toString(s.toCharArray()))); }); /* lambda优化 */ testLambda("一个字符串",s -> System.out.println(Arrays.toString(s.toCharArray()))); //方法引用 testLambda("还是一个字符串",System.out::println); testLambda("依旧是一个字符串",方法所属类的类名::方法名); /* 被引用的方法 */ public static void test(Stirng str){ System.out.println(str); }
2.4有参数有返回值
比较器接口
接口设计
@Functionalinterface interface Comparator<T>{ int compare(T o1,T o2); }
比较器案例
/*生成数据*/ Person[] array = new Person[5]; for(int i = 0; i < array.length;i++){ int age = (int) Math.random() * 50; array[i] = new new Person(i + 1, "张三" + i, age,false); } /* lambda表达式 */ Preson[] temp = filterPredicate(array,p -> p.getAge() > 10); for(Person person : temp){ System.out.println(person); } /** *利用predicate过滤器接口限制数组内容 *@param array Person *@param filter Predicate @return temp 过滤后的心数组 */ public static Person[] filterPredicate(Person[] array,Predicate<Person> filter){ Person[] temp = new Person[array.length]; int count = 0; for(int i = 0; i < array.length;i++){ //判断当前Person对象是否满足要求，如果满足，存储到temp中 if(filter.test(array[i])){ temp[count++] = array[i]; } } return temp; }
过滤器接口
接口设计
@FunctionalInterface interface Predicate<T>{ boolean test(T t); }
类型转换接口
接口设计
@FunctionalInterface interface Function<T, R>{ R apply(T,t); }
代码实现
String str = "坠落吧，落吧，想你的雪花放肆在心里落下"; int i = testLambda(str,s -> s.length()); System.out.println(i); public static int testLambda(String str,Function<String,Integer> fun){ return fun.apply(str); }
3.stream流
利用流水线思想怼集合，数组数据就行处理和操作。
例如;排序，筛选，类型转换
案例
ArrayList<String> list = new ArrayList<>();
/**添加数据**/
//处理数据
list.stream()//stream流
.skip(2)//跳过两个元素
.limit(8)//保留八个元素
.filter(s -> s.length() > 4)//过滤长度大于4的元素
.sorted(Comparator.comparing(String::length))//指定排序规则，按照长度排序
.forEach(System.out::println);//遍历输出
conllect
// Stream 流数据内容转 List 集合
List<String> list1 = list.stream().distinct().collect(Collectors.toList());
// Stream 流数据内容转 Set 集合
Set<String> set = list.stream().skip(2).limit(20).collect(Collectors.toSet());
