JAVA-JDK8新特性

第一节 常用函数接口

1.1 函数式接口

函数式接口：有且只有一个抽象方法的接口，称之为函数式接口
当然接口中可以包含其他的方法（默认，静态，私有）

@FunctionalInterface注解
作用：可以检测接口是否是一个函数式接口
是：编译成功
否：编译失败（接口中没有抽象方法，抽象方法的个数多余1个）

@FunctionalInterface
public interface FunctionInterface {
    //定义一个抽象方法
    public abstract void method();
}

public class FunctionInterfaceImpl implements FunctionInterface{
    @Override
    public void method() {
    }
}

/*
函数式接口的使用：一般可以作为方法的参数和返回值类型
 */
public class Use {
    //定义一个方法，参数使用函数式接口
    public static void show(FunctionInterface myInter){
        myInter.method();
    }
    public static void main(String[] args) {
        //调用show方法，方法的参数是一个接口，所以可以传递接口的实现类对象
        show(new FunctionInterfaceImpl());
        //调用show方法，方法的参数是一个接口，所以可以传递接口的匿名内部类
        show(new FunctionInterface() {
            @Override
            public void method() {
                System.out.println("使用匿名内部类重写接口中的抽象方法");
            }
        });
        //调用show方法，方法的参数是一个函数式接口，所以可以传递Lambda表达式
        show(()->{
            System.out.println("使用Lambda表达式重写接口中的抽象方法");
        });
    }
}

1.2 日志案例

/*
日志案例
发现以下代码存在一些性能浪费的问题
调用showLog方法，传递的第二个参数是一个拼接后的字符串
先把字符串拼接好，然后再调用方法
showLog方法中如果传递的日志等级不是1级
那么就不会输出拼接后的字符串
所以感觉字符串就白拼接了，存在了浪费
 */
public class Demo01Logger {
    //定义一个根据日志的级别，显示日志信息的方法
    public static void showLog(int level, String message){
        //对日志的等级进行判断，如果是1级别，那么输出日志信息
        if (level == 1){
            System.out.println(message);
        }
    }
    public static void main(String[] args) {
        //定义三个日志信息
        String msg1 = "小松狮";
        String msg2 = "小松狮1";
        String msg3 = "小松狮2";
        //调用showLog方法，传递日志级别和日志信息
        showLog(1, msg1 + msg2 + msg3);
    }
}

@FunctionalInterface
public interface MessageBuilder {
    public abstract String builderMessage();
}

/*
使用Lambda优化日志案例
Lambda的特点：延迟加载
Lambda的使用前提：必须存在函数式接口
 */
public class Demo02Lambda {
    public static void showLog(int level, MessageBuilder mb){
        if (level == 1){
            System.out.println(mb.builderMessage());
        }
    }

    public static void main(String[] args) {
        //定义三个日志信息
        String msg1 = "小松狮";
        String msg2 = "小松狮1";
        String msg3 = "小松狮2";
        showLog(2,()->msg1 + msg2 + msg3);
    }
    /*
    使用Lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中
    只有满足条件，日志的等级是1级
        才会调用接口中的方法，才会进行字符串的拼接
    如果条件不满足，日志的等级不是1级
        那么接口中的方法也不会执行
        所以拼接字符串的代码也不会执行
     所以不会存在性能的浪费
     */
}

函数式接口作为方法的参数-开启多线程

public class Demo03Runnable {
    public static void startThread(Runnable run){
        //开启多线程
        new Thread(run).start();
    }

    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() + "->线程启动了"));
    }
}

函数式接口作为方法的返回值类型-字符串的排序

import java.util.Arrays;
import java.util.Comparator;

public class Demo04Comparator {
    //定义一个方法，方法的返回值类型使用函数式接口Comparator
    public static Comparator<String> getComparator(){
        //匿名内部类
        /*return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //按照字符串的降序排序
                return o2.length() - o1.length();
            }
        };*/
        //Lambda表达式
        return (o1, o2) -> o2.length() - o1.length();
    }

    public static void main(String[] args) {
        String[] arr = {"aaaa","vvvvvvvv","eeeeeeeeee"};
        //输出排序前的数组
        System.out.println(Arrays.toString(arr));
        //调用Arrays中的sort方法，对字符串数组进行排序
        Arrays.sort(arr,getComparator());
        //输出排序后的数组
        System.out.println(Arrays.toString(arr));
    }
}

1.3 Supplier接口

java.util.function.Supplier接口仅包含一个无参的方法：
T get()用来获取一个泛型参数指定类型的对象数据
Supplier接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据

public class Demo05Supplier {
    //定义一个方法，方法的参数传递Supplier<T>接口，泛型指定String，get方法就会返回一个String
    public static String getString(Supplier<String> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        String s = getString(() -> "小松狮");
        System.out.println(s);
    }
}

1.4 练习1

/*
练习：求数组元素最大值
使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值
 */
public class Demo05Test {
    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        int[] arr = {123,542,21,57,342,324,734,-321};
        int maxValue = getMax(() -> {
            int max = arr[0];
            for (int i : arr) {
                if (i > max) {
                    max = i;
                }
            }
            return max;
        });
        System.out.println(maxValue);
    }
}

1.5 Consumer接口

java.util.function.Consumer接口则正好与Supplier接口相反
它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定
Consumer接口中包含抽象方法void accept(T t),意为消费一个指定泛型的数据
Consumer接口是一个消费型接口，泛型执行什么类型，就可以使用accept方法消费什么类型的数据
至于具体怎么消费（使用），需要自定义（输出，计算…）

public class Demo06Consumer {
    /*
    定义一个方法
    方法的参数传递一个字符串的姓名
    方法的参数传递Consumer接口，泛型使用String
    可以使用Consumer接口消费字符串的姓名
     */
    public static void method(String name, Consumer<String> con){
        con.accept(name);
    }

    public static void main(String[] args) {
        method("小松狮",(String name)->{
            //对传递的字符串进行消费
            //消费方式：直接输出字符串
            System.out.println(name);
            //消费方式：把字符串进行反转输出
            String reName = new StringBuilder(name).reverse().toString();
            System.out.println(reName);
        });
    }
}

Consumer接口的默认方法andThen
作用：需要两个Consumer接口，可以把两个Consumer接口组合到一起，再对数据进行消费

例如：
Consumer con1
Consumer con2
String s = ”hello“;
con1.accept(s);
con2.accept(s);
连接两个Consumer接口 再进行消费
con1.andThen(con2).accept(s);谁写前边谁先消费

public class AndThen {
    //定义一个方法，方法的参数传递一个字符串和两个Consumer接口，Consumer接口的泛型使用字符串
    public static void method(String s, Consumer<String> con1, Consumer<String> con2){
        //con1.accept(s);
        //con2.accept(s);
        //使用andThen方法，把两个Consumer接口连接到一起，再消费数据
        con1.andThen(con2).accept(s);
    }

    public static void main(String[] args) {
        //调用method方法，传递一个字符串，两个Lambda表达式
        method("Hello",
                (t)->{
                    //消费方式：把字符串转换为大写输出
                    System.out.println(t.toUpperCase());
                },
                (t)->{
                    //消费方式：把字符串转换为小写输出
                    System.out.println(t.toLowerCase());
                });
    }
}

1.6 练习2

练习：
字符串数组当中存有多条信息，请按照格式“姓名：XX，性别：XX。”的格式将信息打印出来
要求将打印姓名的动作作为第一个Consumer接口的Lambda实例
将打印性别的动作作为第二个Consumer接口的Lambda实例
将两个Consumer接口按照顺序“拼接”到一起

public class AndThenTest {
    //定义一个方法，参数传递String类型的数组和两个Consumer接口，泛型使用String
    public static void print(String[] arr, Consumer<String> con1, Consumer<String> con2){
        //遍历字符串数组
        for (String message : arr) {
            con1.andThen(con2).accept(message);
        }
    }

    public static void main(String[] args) {
        String[] arr = {"小松狮，女","小锦鲤，男"};
        print(arr,(message)->{
            String name = message.split("，")[0];
            System.out.print("姓名：" + name);
        },(message)->{
            String age = message.split("，")[1];
            System.out.println("，性别：" + age + "。");
        });
    }
}

1.7 Predicate接口

java.util.function.Predicate接口
作用：对某种数据类型的数据进行判断，结果返回一个boolean值
Predicate接口中包含一个抽象方法：
boolean test(T t):用来对指定数据类型数据进行判断的方法
结果：
符合条件：返回true
不符合条件：返回false

class demo01Predicate {
    public static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }

    public static void main(String[] args) {
        String s = "abcde";
        boolean b = checkString(s, (String str) -> {
            return str.length() > 5;
        });
        System.out.println(b);
    }
}

/*
逻辑表达式：可以连接多个判断的条件
需求：判断一个字符串，有两个判断的条件
1、判断字符串的长度是否大于5
2、判断字符串中是否包含a
两个条件必须同时满足，可以使用&&运算符连接两个条件
Predicate接口中有一个方法and，表示并且关系，也可以用于连接两个判断条件
 */
public class And {
    public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
        //return pre1.test(s) && pre2.test(s);
        return pre1.and(pre2).test(s);
    }

    public static void main(String[] args) {
        String s ="abcdef";
        boolean b = checkString(s,(String str)->{
            return str.length() > 5;
        },(String str)->{
            return str.contains("a");
        });
        System.out.println(b);
    }
}

/*
需求：判断一个字符串，有两个判断的条件
1、判断字符串的长度是否大于5
2、判断字符串中是否包含a
满足一个条件即可，可以使用||运算符连接两个条件
Predicate接口中有一个方法or，表示或者关系，也可以用于连接两个判断条件
 */
public class Or {
    public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
        //return pre1.test(s) || pre2.test(s);
        return pre1.or(pre2).test(s);
    }

    public static void main(String[] args) {
        String s ="bcdefhd";
        boolean b = checkString(s,(String str)->{
            return str.length() > 5;
        },(String str)->{
            return str.contains("a");
        });
        System.out.println(b);
    }
}

/*
需求：判断一个字符串长度是否大于5
如果字符串的长度大于5，那么返回false
如果字符串的长度不大于5，那么返回true
所以我们可以使用取反符号！对判断的结果进行取反
Predicate接口中有一个方法Negate，表示取反的意思
 */
public class Negate {
    public static boolean checkString(String s, Predicate<String> pre){
        //return !pre.test(s);
        return pre.negate().test(s);
    }

    public static void main(String[] args) {
        String s = "dfasadfw";
        boolean b = checkString(s,(String str)->{
            return str.length() > 5;
        });
        System.out.println(b);
    }
}

1.8 练习3

/*
练习：集合信息筛选
数组当中有多条“姓名+性别”的信息
请通过Predicate接口的拼装符合要求的字符串筛选到集合ArrayList中，
需要同时满足两个条件：
1、必须是女生
2、姓名为三个字
分析：
1、有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
2、必须同时满足两个条件，所以可以使用and方法连接两个判断条件
 */
public class PredicateTest {
    public static ArrayList<String> filter(String[] arr, Predicate<String> pre1, Predicate<String> pre2){
        ArrayList<String> list = new ArrayList<>();
        for (String s : arr) {
            //使用Predicate接口中的方法test对获取到的字符串进行判断
            boolean b = pre1.and(pre2).test(s);
            if (b){
                //条件成立，把信息存储到集合中
                list.add(s);
            }
        }
        return list;
    }

    public static void main(String[] args) {
        String[] arr = {"小松狮，女","小锦鲤，男","小松狮小锦鲤，女","小锦鲤小松狮，男"};
        ArrayList<String> list = filter(arr,(String s)->{
            return s.split("，")[1].equals("女");
        },(String s)->{
            return s.split("，")[0].length() == 3;
        });
        for (String s : list) {
            System.out.println(s);
        }
    }
}

1.9 Function接口

java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据
前者称为前置条件，后者称为后置条件
Function接口中最主要的抽象方法为：R apply（T t），根据类型T的参数获取类型R的结果
使用的场景例如：将String类型转换为Integer类型

public class FunctionApply {
    /*
    定义一个方法
    方法的参数传递一个字符串类型的整数
    方法的参数传递一个Function接口，泛型使用<String,Integer>
    使用Function接口中的方法apply，把字符串类型的整数，转换为Integer类型的整数
     */
    public static void change(String s, Function<String, Integer> fun){
        Integer in = fun.apply(s);
        System.out.println(in);
    }

    public static void main(String[] args) {
        String s = "12345";
        change(s,(String str)->{
            return Integer.parseInt(str);
        });
    }
}

import java.util.function.Function;

/*
Function接口中的默认方法andThen：用来进行组合操作
需求：
把String类型的“123”，转换为Integer类型，把转换后的结果+10
把增加之后的Integer类型的数据，转换为String类型
分析：
转换了两次
第一次是把String类型转换为Integer类型
所以我们可以使用Function<String,Integer> fun1
    Integer i = fun1.apply("123") + 10;
第二次是把Integer类型转换为String类型
所以我们可以使用Function<Integer,String> fun2
    String s = fun2.apply(i);
我们可以使用andThen方法，把两次转换组合在一起使用
    String s = fun1.andThen(fun2).apply("123");
    fun1先调用apply方法，把字符串转换为Integer
    fun2再调用apply方法，把Integer转换为字符串
 */
public class AndThen {
    public static void change(String s, Function<String,Integer> fun1, Function<Integer,String> fun2){
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }
    public static void main(String[] args) {
        String s = "123";
        change(s,(String str)->{
           return Integer.parseInt(str) + 10;
        },(Integer i)->{
            return i + "";
        });
    }
}

1.10 练习

import java.util.function.Function;

/*
练习：自定义函数模型拼接
题目：
请使用Function进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
1、将字符串截取数字年龄部分，得到字符串
    Function<String,String> "小松狮，20"->"20"
2、将上一步的字符串转换成为int类型的数字
    Function<String,Integer> "20"->20
3、将上一步的int数字累加100，得到结果int数字
    Function<Integer,Integer> 20->120
 */
public class FunctionTest {
    public static int change(String s, Function<String,String> fun1,
                             Function<String,Integer> fun2, Function<Integer,Integer> fun3){
        return fun1.andThen(fun2).andThen(fun3).apply(s);
    }

    public static void main(String[] args) {
        String s = "小松狮，20";
        int num = change(s,(String str)->{
            return str.split("，")[1];
        },(String str)->{
            return Integer.parseInt(str);
        },(Integer in)->{
            return in + 100;
        });
        System.out.println(num);
    }
}

第二节 Stream流思想

/*
使用Stream流的方式，遍历集合，对集合中的数据进行过滤
 */
public class StreamFilter {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("小松狮");
        list.add("小锦鲤");
        list.add("小松狮小锦鲤");
        list.add("小锦鲤小松狮");
        list.add("啦啦啦");
        //对list集合中的元素进行过滤，只要以小开头的元素，只要长度为3的元素，遍历集合
        list.stream().filter(name -> name.startsWith("小"))
                .filter(name -> name.length() == 3)
                .forEach(name -> System.out.println(name));
    }
}

第三节 获取Stream流

java.util.stream.Stream是java8新加入的最常用的流接口（这并不是一个函数式接口）
获取一个流非常简单，有以下几种常用的方式：
1、所有的Collection集合都可以通过Stream默认方法获取流
2、Stream接口的静态方法of可以获取数组对应的流
static Stream of (T…values)
参数是一个可变参数，那么我们就可以传递一个数组

public class GetStream {
    public static void main(String[] args) {
        //把集合转换为Stream流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();
        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();
        Map<String, String> map = new HashMap<>();
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream5 = entries.stream();
        //把数组转换为Stream流
        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
        //可变参数可以传递数组
        Integer[] arr1 = {1, 2, 3, 4};
        Stream<Integer> stream7 = Stream.of(arr1);
        String[] arr2 = {"1","2","3"};
        Stream<String> stream8 = Stream.of(arr2);
    }
}

3.1 forEach方法

Stream流中的常用方法forEach
void forEach(Consumer<? super T> action);
该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理
Consumer接口是一个消费型的函数式接口，可以传递Lambda表达式，消费数据

/*
简单记：
forEach方法，用来遍历流中的数据
是一个终结方法，遍历之后就不能继续调用Stream流中的其他方法
 */
public class ForEach {
    public static void main(String[] args) {
        //获取一个Stream流
        Stream<String> stream = Stream.of("1", "2", "3");
        //使用流中的forEach方法对数据进行遍历
        stream.forEach((String num)->{
            System.out.println(num);
        });
    }
}

3.2 filter方法

Stream流中的常用方法filter：用于对Stream流中的数据进行过滤
Stream filter(Predicate<? super T> predicate);

public class Filter {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("11", "21", "31", "14");
        Stream<String> stream1 = stream.filter((String num) -> {
            return num.startsWith("1");
        });
        stream1.forEach((String num)->{
            System.out.println(num);
        });
    }
}

Stream流属于管道流，只能被消费（使用）一次

3.3 map方法

如果需要将流中的元素映射到另一个流中，可以使用map方法
Stream map(Function<? super T, ? extends R> mapper);

public class DemoMap {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        Stream<Integer> stream1 = stream.map((String str) -> {
            return Integer.parseInt(str);
        });
        stream1.forEach((Integer i)->{
            System.out.println(i);
        });
    }
}

3.4 count方法

Stream流中的常用方法count：用于统计Stream流中元素的个数
Long count();
count方法是一个终结方法，返回值是一个long类型的整数

public class Count {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}

3.5 limit方法

Stream流中的常用方法limit：用于截取流中的元素
limit方法可以对流进行截取，只取前n个
Stream limit(long maxSize);
limit方法是一个延迟方法，只是对流中元素进行截取，返回一个新的流，所以可以继续使用Stream流中的其他方法

public class Limit {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("喜羊羊", "美羊羊", "懒羊羊", "灰太狼");
        Stream<String> stream1 = stream.limit(3);
        stream1.forEach(name->
            System.out.println(name)
        );
    }
}

3.6 skip方法

Stream流中的常用方法skip：用于跳过元素
如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流
Stream skip(long n);
如果流的当前长度大于n，则跳过前n个，否则将会得到一个长度为0的空流

public class Skip {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("喜羊羊", "美羊羊", "懒羊羊", "灰太狼");
        Stream<String> stream1 = stream.skip(3);
        stream1.forEach(name-> System.out.println(name));
    }
}

3.7 concat方法

Stream流中的常用方法concat：用于把两个流组合在一起
如果有两个流，希望合并为一个流，那么可以使用Stream接口的静态方法concat
static Stream concat(Stream<? extends T> a, Stream<? extends T> b)

public class Concat {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("喜羊羊", "美羊羊", "懒羊羊", "灰太狼");
        Stream<String> stream2 = Stream.of("1", "2", "3", "4");
        Stream<String> concat = Stream.concat(stream1, stream2);
        concat.forEach(str-> System.out.println(str));
    }
}

3.8 练习

/*
练习：集合元素处理（传统方式）
现在有两个ArrayList集合存储队伍当中的多个成员姓名，使用传统for循环（增强for循环）进行以下步骤：
1、第一个队伍只要名字为3个字的成员姓名，存储到一个新集合中
2、第一个队伍筛选之后只要前2个人，存储到一个新集合中
3、第二个队伍只要姓小的成员姓名，存储到一个新集合中
4、第二个队伍筛选之后不要前2个人，存储到一个新集合中
5、将两个队伍合并为一个队伍，存储到一个新集合中
6、根据姓名创建Person对象，存储到一个新集合中
7、打印整个队伍的Person对象信息
 */
public class Test {
    public static void main(String[] args) {
        //第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("小松狮");
        one.add("小锦鲤");
        one.add("松狮呀");
        one.add("锦鲤啊");
        one.add("松狮哈哈");
        ArrayList<String> one1 = new ArrayList<>();
        for (String name : one) {
            if (name.length() == 3){
                one1.add(name);
            }
        }
        ArrayList<String> one2 = new ArrayList<>();
        for (int i = 0; i < 2; i++) {
            one2.add(one1.get(i));
        }
        //第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("松狮");
        two.add("锦鲤");
        two.add("小锦鲤哈哈");
        two.add("小松狮哈哈");
        two.add("小松狮");
        two.add("小锦鲤");
        two.add("松狮");
        two.add("锦鲤");
        two.add("松狮哈哈");
        ArrayList<String> two1 = new ArrayList<>();
        for (String name : two) {
            if (name.startsWith("小")){
                two1.add(name);
            }
        }
        ArrayList<String> two2 = new ArrayList<>();
        for (int i = 2; i < two1.size(); i++) {
            two2.add(two1.get(i));
        }
        ArrayList<String> all = new ArrayList<>();
        all.addAll(one2);
        all.addAll(two2);
        ArrayList<Person> person = new ArrayList<>();
        for (String name : all) {
            person.add(new Person(name));
        }
        for (Person name : person) {
            System.out.println(name);
        }
    }
}

//使用Stream流
public class TestStream {
    public static void main(String[] args) {
        //第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("小松狮");
        one.add("小锦鲤");
        one.add("松狮呀");
        one.add("锦鲤啊");
        one.add("松狮哈哈");
        Stream<String> oneStream = one.stream().filter(name -> name.length() == 3).limit(2);
        //第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("松狮");
        two.add("锦鲤");
        two.add("小锦鲤哈哈");
        two.add("小松狮哈哈");
        two.add("小松狮");
        two.add("小锦鲤");
        two.add("松狮");
        two.add("锦鲤");
        two.add("松狮哈哈");
        Stream<String> twoStream = two.stream().filter(name -> name.startsWith("小")).skip(2);
        Stream.concat(oneStream, twoStream).map(name -> new Person(name)).forEach(name -> System.out.println(name));
    }
}

第四节 方法引用

4.1 基本介绍

//定义一个打印的函数式接口
@FunctionalInterface
public interface Printable {
    //定义字符串的抽象方法
    public abstract void print(String s);
}

public class Demo01Printable {
    //定义一个方法，参数传递Printable接口，对字符串进行打印
    public static void printString(Printable p){
        p.print("helloworld");
    }

    public static void main(String[] args) {
        printString((s)->{
            System.out.println(s);
        });
        /*
        分析：
        Lambda表达式的目的，打印参数传递的字符串
        把参数s，传递给了System.out对象，调用out对象中的方法println对字符串进行了输出
        注意：
            1、System.out对象是已经存在的
            2、println方法也是已经存在的
        所以我们使用方法引用来优化Lambda表达式
        可以使用System.out方法直接引用（调用）println方法
     */
        printString(System.out::println);
    }
}

4.2 通过对象名引用成员方法

public class MethodRerObject {
    //定义一个成员方法，传递字符串，把字符串按照大写输出
    public void printUpperCaseString(String str){
        System.out.println(str.toUpperCase());
    }
}

/*
通过对象名引用成员方法
使用前提是对象名是已经存在的，成员方法也是已经存在
就可以使用对象名来引用成员方法
 */
public class Demo01ObjectMethod {
    public static void printString(Printable p){
        p.print("hello");
    }

    public static void main(String[] args) {
        printString((s)->{
            //创建MethodRerObject对象
            MethodRerObject obj = new MethodRerObject();
            obj.printUpperCaseString(s);
        });
        //使用方法引用来优化Lambda
        //对象已经存在，成员方法已经存在
        MethodRerObject obj = new MethodRerObject();
        printString(obj::printUpperCaseString);
    }
}

4.3 通过类名引用静态方法

@FunctionalInterface
public interface Calcable {
    //定义一个抽象方法，传递一个整数，对整数进行绝对值计算并返回
    int calAbs(int number);
}

/*
通过类名引用静态成员方法
类已经存在，静态成员方法也已经存在
就可以通过类名直接引用静态成员方法
 */
public class Demo02StaticMethodReference {
    //定义一个方法，方法的参数传递要计算绝对值的整数和函数式接口Calcable
    public static int method(int number, Calcable c){
        return c.calAbs(number);
    }

    public static void main(String[] args) {
        //调用method方法，传递计算绝对值的整数和Lambda表达式
        int num = method(-52, (n) -> {
            return Math.abs(n);
        });
        System.out.println(num);
        //使用方法引用优化Lambda表达式
        //Math类是存在的，abs计算绝对值的静态方法以及存在
        //所以我们可以直接通过类名引用静态成员方法
        int number = method(-46, Math :: abs);
        System.out.println(number);
    }
}

4.4 通过super引用父类成员方法

//定义见面的函数式接口
@FunctionalInterface
public interface Greetable {
    void greet();
}

//定义父类
public class Human {
    //定义一个sayHello的方法
    public void sayHello(){
        System.out.println("hello,我是小松狮");
    }
}

//定义子类
public class Man extends Human{
    //子类重写父类sayHello方法

    @Override
    public void sayHello() {
        System.out.println("hello,我是小锦鲤");
    }
    //定义一个方法参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }
    public void show(){
        //调用method方法，方法的参数是一个函数式接口，可以传递Lambda表达式
        method(()->{
            //创建父类对象
            Human human = new Human();
            human.sayHello();
        });
        //因为有子父类关系，所以存在一个关键字super，代表父类，所以我们可以直接使用super调用父类的成员方法
        method(()->{
            super.sayHello();
        });
        //使用super引用父类的成员方法
        //super以及存在，父类的成员也存在
        //可以直接使用super引用父类的成员方法
        method(super::sayHello);
    }

    public static void main(String[] args) {
        new Man().show();
    }
}

4.5 通过this引用本类成员方法

//定义一个富有的函数式接口
@FunctionalInterface
public interface Richable {
    //定义一个想买什么就买什么的方法
    void buy();
}

/*
通过this引用本类的成员方法
 */
public class Husband {
    //定义一个买房子的方法
    public void buyHouse(){
        System.out.println("北京二环内买一套四合院");
    }
    //定义一个结婚的方法，参数传递Richable接口
    public void marry(Richable r){
        r.buy();
    }
    //定义一个非常高兴的方法
    public void soHappy(){
        //调用结婚的方法
        marry(()->{
            //使用this.成员方法调用本类买房子的方法
                this.buyHouse();
        });
        //使用方法引用优化Lambda表达式
        //this存在，本类成员方法buyHouse存在
        marry(this::buyHouse);
    }

    public static void main(String[] args) {
        new Husband().soHappy();
    }
}

4.6 类的构造器（构造方法）引用

/*
定义一个创建Person对象的函数式接口
 */
@FunctionalInterface
public interface PersonBuilder {
    Person builderPerson(String name);
}

public class Person {
    private String name;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Person(String name) {
        this.name = name;
    }

    public Person() {
    }
}

/*
类的构造器（构造方法）引用
 */
public class Demo {
    //定义一个方法，参数传递姓名和PersonBuilder接口，方法中通过姓名创建Person对象
    public static void printName(String name,PersonBuilder pb){
        Person person = pb.builderPerson(name);
        System.out.println(person.getName());
    }

    public static void main(String[] args) {
        //调用printName方法
        printName("小松狮", (String name)->{
            return new Person(name);
        });
        //使用方法引用优化Lambda
        //构造方法new Person(String name)已知
        //创建对象已知new
        //可以使用Person引用new创建对象
        printName("小锦鲤",Person :: new);
    }
}

4.7 数组的构造器引用

/*
定义一个创建数组的函数式接口
 */
@FunctionalInterface
public interface ArrayBuilder {
    //定义一个创建int类型数组的方法，参数传递数组的长度，返回创建好的int类型数组
    int[] builderArray(int length);
}

/*
数组的构造器引用
 */
public class Demo {
    //定义一个方法，方法的参数传递创建数组的长度和ArrayBuilder接口
    //方法内部根据传递的长度使用ArrayBuilder中的方法创建数组并返回
    public static int[] creatArray(int length, ArrayBuilder ab){
        return ab.builderArray(length);
    }

    public static void main(String[] args) {
        //调用creatArray方法，传递数组的长度和Lambda表达式
        int[] arr1 = creatArray(10, (len) -> {
            return new int[len];
        });
        System.out.println(arr1.length);
        //使用方法引用优化Lambda表达式
        //已知创建的就是int类型数组，数组的长度已知
        //int[]引用new，根据参数传递的长度来创建数组
        int[] arr2 = creatArray(20, int[]::new);
        System.out.println(Arrays.toString(arr2));
        System.out.println(arr2.length);
    }
}