54-函数式接口

Supplier.get(): 获取一个泛型指定类型的数据
Consumer.accept(T t): 消费一个泛型指定类型的数据t，只要给accept方法添加方法体{} 
 Function<T, R>接口功能: 把T类型的数据转换成R类型
        抽象方法:  public abstract R apply(T t): 根据方法参数T类型的t,获取R类型的数据
        转换前: T类型  转换后: R类型
### Supplier接口的get方法练习求数组最大值
public class Demo05SupplierTest {
    public static void main(String[] args) {
        int[] arr = {10,50,30,20,40};
        //1.匿名内部类的方式
        fun(new Supplier<Integer>() {
            @Override
            public Integer get() {
                //int数组最大值
                int max = arr[0];
                for(int i = 1;i<arr.length;i++) {
                    if(arr[i]>max) {
                        max = arr[i];
                    }
                }
                return max;
            }
        });
        //2.使用lambda表达式的标准格式
        fun(()->{
            //int数组的和
            int sum = 0;
            for (int i = 0; i < arr.length; i++) {
                sum += arr[i];
            }
            return sum;
        });
        //3.使用lambda表达式的简化格式    和标准格式一样
    }
    /*
        定义方法,使用函数式接口Supplier作为参数
     */
    public static void fun(Supplier<Integer> supplier){
        //调用抽象方法get,获取int数字value
        //至于value的内容是什么以及如何获取,这里说不清楚
        int value = supplier.get();
        System.out.println(value);
    }
}
练习:  给你一个字符串,请按照大写的方式进行消费

```js
public class Demo06Consumer {
    public static void main(String[] args) {
        String s = "hello World";

        //1.匿名内部类的方式
        fun(s, new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s.toUpperCase());//按照大写处理
            }
        });

        //2.使用lambda表达式的标准格式
        fun(s,(String str)->{
            System.out.println(str.toLowerCase());//按照小写处理
        });

        //3.使用lambda表达式的简化格式
        fun(s,str-> System.out.println(s+"的长度: "+str.length()));//打印长度
    }
    /*
        定义方法,使用函数式接口Consumer作为参数
     */
    public static void fun(String ss,Consumer<String> consumer) {
        //调用抽象方法accept,处理字符串ss
        //如何处理字符串ss,说不清
        consumer.accept(ss);
    }
}
 练习:       给你一个String的数字,你给我转成一个int数字
            转换前: String类型   <---T  转换后: Integer类型  <---R
  public class Demo07Function {
    public static void main(String[] args) {
        String str = "1235";
        //1.匿名内部类的方式
        fun(str, new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(str);
            }
        });

        //2.使用lambda表达式的标准格式
        fun(str,(String strNum)->{
            //return strNum.length();//返回的int数字代表的是字符串的长度
            return Integer.parseInt(strNum);//把String数字,解析成int
        });  
    }
    /*
        定义方法,使用函数式接口Function作为参数
     */
    public static void fun(String strNum,Function<String,Integer> f){
        //根据方法参数String类型的strNum
        //获取int数字num,至于如何根据String类型的strNum获取int数字num说不清
        int num = f.apply(strNum);
        System.out.println(num+100);
    } 
}          
        java.util.function.Predicate<T>根据T类型的数据获取boolean类型的结果
        抽象方法: boolean test(T t): 根据方法参数T类型的数据t,返回一个boolean类型的结果

    练习:
        //1.练习:判断字符串长度是否大于5 2.练习:判断字符串是否包含"H"
 */
public class Demo08Predicate {
    public static void main(String[] args) {
        String s = "itheima";

        //1.匿名内部类的方式
        fun(s, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                //return s.length()>5;
                return s.contains("H");//判断是否包含H
            }
        });

        //2.使用lambda表达式的标准格式
        fun(s,(String str)->{return str.length()>5;}); 
    /*
        定义方法,使用函数式接口Predicate作为参数
     */
    public static void fun(String ss,Predicate<String> p) {
        //调用抽象方法test,根据字符串ss,获取boolean结果
        //至于根据字符串ss,如何获取boolean结果,说不清
        boolean result = p.test(ss);
        System.out.println(result);
    }
}