门户网站开发多少钱,wordpress登录密码忘,汽车之家网页版官网找车,台州企业网站建设目录
一.函数式接口Functional Interface
1. Supplier接口 --供给型接口
2. Consumer接口 --消费型接口
3.Function接口 --转换型接口
4. Predicate接口--断言型接口
5. Comparator接口--比较器接口 一.函数式接口Functional Interface
只有一个抽象方法的接口#xff…目录
一.函数式接口Functional Interface
1. Supplier接口 --供给型接口
2. Consumer接口 --消费型接口
3.Function接口 --转换型接口
4. Predicate接口--断言型接口
5. Comparator接口--比较器接口 一.函数式接口Functional Interface
只有一个抽象方法的接口可以定义多个非抽象方法。可以使用FunctionalInterface接口定义强化语义规范。
函数式接口也被称为SAM 接口Single Abstract Method Interfaces:
基于函数式接口可以使用Lambda表达式进行实现实现函数式编程。 FunctionalInterface public interface ComparatorT { int compare(T o1, T o2); } // lambda表达式实现字符串数组排序 Arrays.sort(array, (x1,x2) - { if (x1.length() ! x2.length()) { return x1.length() - x2.length(); } else { return x1.compareTo(x2); } } ); 2迭代 ListString langList Arrays.asList(Basic,QBasic,c,c,PowerBuilder,Visual Basic); langList.forEach((name)-{ System.out.println(name); }); 内置函数式接口来由来
我们知道使用Lambda表达式的前提是需要有函数式接口。而Lambda使用时不关心接口名抽象方法名只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda方便JDK提供了大量常用的函数式接口
求数组的的所有元素和---自定义一个内置函数接口 package com.itheima.demo03functionalinterface; import java.util.List; public class Demo01UserFunctionalInterface { public static void main(String[] args) { // 调用函数式接口中的方法 method((arr) - { int sum 0; for (int n : arr) { sum n; } return sum; }); } // 使用自定义的函数式接口作为方法参数 public static void method(Operator op) { int[] arr {1, 2, 3, 4}; int sum op.getSum(arr); System.out.println(sum sum); } } FunctionalInterface interface Operator { public abstract int getSum(int[] arr); } 1. Supplier接口 --供给型接口
ava.util.function.SupplierT 接口 - 方法没有参数有返回值--供给型接口。
它意味着供给 , 对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。 供给型接口通过Supplier接口中的get方法可以得到一个值无参有返回的接口。 FunctionalInterface public interface SupplierT { public abstract T get(); } 使用 Supplier 接口作为方法参数类型通过Lambda表达式求出int数组中的最大值。提示接口的泛型请使用 java.lang.Integer 类。注意代码的执行顺序 public class Demo02 { public static void main(String[] args) { System.out.println(进入到main方法); //使用lambda表达式表示 SupplierInteger s1 () - { System.out.println(get方法开始); int[] arr {4,23,3,2,12,9303}; int index new Random().nextInt(arr.length); System.out.println(get方法结束); return arr[index]; }; printNumber(s1); System.out.println(main方法结束); } private static void printNumber(SupplierInteger sup) { System.out.println(随机值为为); System.out.println(sup.get()); System.out.println(print结束); } } 2. Consumer接口 --消费型接口
java.util.function.ConsumerT 接口则正好相反 --方法有参数没有返回值它不是生产一个数据而是消费一个数据其数据类型由泛型参数决定。 --消费型接口
Consumer消费型接口可以拿到accept方法参数传递过来的数据进行处理, 有参无返回的接口。 FunctionalInterface public interface ConsumerT { public abstract void accept(T t); } public class Demo03 { // 使用Lambda表达式将一个字符串转成大写的字符串 public static void main(String[] args) { System.out.println(开始啦); printHello((String str) - { System.out.println(str.toUpperCase()); }); } public static void printHello(ConsumerString consumer) { System.out.println(aaa); consumer.accept(Hello World); } } 代码练习2默认方法andThen
如果一个方法的参数和返回值全都是 Consumer 类型那么就可以实现效果消费一个数据的时候首先做一个操 作然后再做一个操作实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。下面是JDK的源代码 default ConsumerT andThen(Consumer? super T after) { Objects.requireNonNull(after); return (T t) - { accept(t); after.accept(t); };//箭头后的为返回Consumer对象中重写的方法体 } //此时需要注意我们返回的是一个Lambda表达式就相当于返回了一个被重写了抽象方法的ConsumerT类对象 // 即该类对象中重写了accept()抽象方法方法体为{ s - System.out.println(s); s - System.out.println(new StringBuilder(s).reverse().toString();} // 即con1.andThen(con2).accept(name);就变为 ConsumerT.accept(name); // ConsumerT调用本身的accept()方法并传入字符串参数 “林青霞 ”所以会输出林青霞霞青林 // 返回的是一个Consumer类型的对象而不是直接去对此对象及性能调用 备注 java.util.Objects 的 requireNonNull 静态方法将会在参数为null时主动抛出
NullPointerException 异常。这省去了重复编写if语句和抛出空指针异常的麻烦。
要想实现组合需要两个或多个Lambda表达式即可而 andThen 的语义正是“一步接一步”操作。例如两个步骤组合的情况
3.Function接口 --转换型接口
java.util.function.FunctionT,R接口用来根据一个类型的数据得到另一个类型的数据前者称为前置条件 后者称为后置条件。有参数有返回值。----- 此方法接收一个参数加工处理成另一种称为转换型接口 Function转换型接口对apply方法传入的T类型数据进行处理返回R类型的结果有参有返回的接口。使用的场景 例如将 String类型转换为 Integer类型。 FunctionalInterface public interface FunctionT, R { public abstract R apply(T t); } public static void main(String[] args) { // 通过lambda表达式方式创建一个Function类型的对象 // 测试1 返回字符串的长度 // FunctionString, Integer f (String str) - { // return str.length(); // }; // 省略写法 FunctionString, Integer f str - str.length(); method(f,abcdef); // 测试2截取字符串的前五个字符。转成数字要求传入的参数类型为数字字符串类型 FunctionString, Integer f1 str - Integer.parseInt(str.substring(0, 2)); method(f1, 121273asheji); } /* * 函数式接口把一个String转换成数字类型 */ public static void method(FunctionString, Integer f, String str) { Integer result f.apply(str); System.out.println(result); } 默认方法 andThen该方法同样用于“先做什么再做什么”的场景和 Consumer 中的 andThen差不多
function中有一个默认方法对应的代码的源码为如下 default V FunctionT, V andThen(Function? super R, ? extends V after) { Objects.requireNonNull(after); return (T t) - after.apply(apply(t)); } 4. Predicate接口--断言型接口
有时候我们需要对某种类型的数据进行判断从而得到一个boolean值结果。这时可以使用
java.util.function.PredicateT 接口。------接收一个参数返回一个boolean类型的值称为判断型接口 FunctionalInterface public interface PredicateT { public abstract boolean test(T t); } Predicate接口用于做判断,返回boolean类型的值 判断某个数字是否是偶数判断某个数字是否大于0 public class Demo07Predicate { public static void main(String[] args) { // 通过lambda的方式创建Predicate类型的对象需要重写test方法 //判断是否是偶数 PredicateInteger p1 (Integer num) - { System.out.println(是否是偶数); return (num 1) 0; }; method(p1, 29); //判断是否100 PredicateInteger p2 (Integer num) - { System.out.println(是否100); return num 100; }; method(p2, 100); } /* * 函数式接口作为方法的参数 判断一个数字 */ public static void method(PredicateInteger p, Integer num) { boolean b p.test(num); System.out.println(b); } } 默认方法 and or
既然是条件判断就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate条件使用“与”逻辑连接起来实 现“并且”的效果时可以使用default方法 and 。其JDK源码为 default PredicateT and(Predicate? super T other) { Objects.requireNonNull(other); return (t) - test(t) other.test(t); } //与 and 的“与”类似默认方法 or实现逻辑关系中的“或”。JDK源码为 default PredicateT or(Predicate? super T other) { Objects.requireNonNull(other); return (t) - test(t) || other.test(t); } 5. Comparator接口--比较器接口
比较器接口用于比较指定元素值的大小。Java8版本中添加了多个新的default方法用于比较器合并、反转等操作。 // 案例数据 ListString langList Arrays.asList(Basic, QBasic,HTML, c, c, PowerBuilder, go, Visual Basic, c#,java); // 按照ASCII码比较 ComparatorString comparator1 (s1, s2) - { return s1.compareTo(s2); }; // 按照长度比较 ComparatorString comparator2 (s1, s2) - { return s1.length() - s2.length(); }; // 先比较长度再比较ASCII码 ComparatorString comparator3 comparator2.thenComparing(comparator1); // 在comparator3的基础上反转条件 ComparatorString comparator4 comparator2.reversed(); // 按照指定Comparator进行排序 langList.sort(comparator2);
