java笔记之JDK8新特性

一、常用函数式接口

1.1概念：在Java中是指有且仅有一个抽象方法的接口（当然，接口中可以包含其他方法）。
@FunctionalInterface 注解此接口为函数式接口
Lambda的特点：延迟加载
Lambda使用前提：必须存在函数式接口
1.2常用函数式接口
①Suppiler接口：（用来获取一个泛型参数指定类型的对象数据。Supplier接口被称之为生产型接口，指定接口泛型是什么类型，那么接口中的get()方法就会产生什么类型的数据。）
get()方法
②Consumer接口： （消费一个指定泛型的数据。）
抽象方法：accept()方法
默认方法：andThen()方法：连接两个Consumer接口，在进行消费。

public class Demo03Test {
    public static void printInfo(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 = {"迪丽热巴，女","胡歌，男","光头强，男","美羊羊，女"};
        printInfo(arr,(message)->{
            //消费方式：对message进行切割，获取姓名，按指定格式输出
            String name = message.split("，")[0];
            System.out.print("姓名："+name+"\t\t");
        },(message)->{
            //消费方式：对message进行切割，获取性别，按指定格式输出
            String sex = message.split("，")[1];
            System.out.println("性别："+sex);
        });
    }
}

③Predicate接口 （对某种数据类型进行判断，得到一个布尔值）
抽象方法：text() 用于条件判断。
默认方法：and() 相当于“&&”与；or() 或；negate() 非。
④Function接口 （用来根据一个类型的数据的到另一个类型的数据，前者称为前置条件，后者称为后置条件。）
抽象方法：R apply(T t) 根据类型T的参数获取类型R的结果。
默认方法：andThen() 用来进行组合操作。

二、Stream流

特点：stream流属于管道流，只能被消费（使用一次），第一个stream流调用完毕方法，数据就会流转到下一个stream流上，而这时第一个stream流已经使用完毕就会关闭，所以第一个stream流不能再调用方法了。

public class Demo01GetStream {
    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集合中
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();
        //获取值，存储到connection集合中
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();
        //获取键值对（键与值的映射关系 entrySet()）
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream5 = entries.stream();

        /*
        把数组转为Stream流
         */
        Integer[] arr = {1,2,3,4,5};
        Stream<Integer> stream7 = Stream.of(arr);

        String[] str = {"a","b","c"};
        Stream<String> stream8 = Stream.of(str);
    }
}

2.1常用方法
延迟方法：返回值类型仍是stream接口自身类型的方法，因此支持链式调用。（除终结方法外其余方法均为延迟方法。）
终结方法：返回值类型不再是stream接口自身类型的方法，因此不支持链式调用（包括count和forEach方法）
①void forEach(Consumer<? super T>action); 接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。就是用来遍历流中的数据。
②Stream filter(Predicate<? super T> predicate); 对数据进行过滤。
③ Stream map(Function<? super T, ? extends R> mapper); 将流中的元素映射到另一个流中（类型转换）。
④long count(); 统计个数
⑤Stream limit(long maxSize); 对流进行截取，只取用前几个。
⑥Stream skip(long n); 跳过前n个元素获得一个新流（若流的当前长度小于n会得到一个长度为0的空流）。
⑦static Stream concat(Stream<? extends T> a,Stream<? extends T> b); 将两个流合并成一个流。

public class Demo02_Test {
    public static void main(String[] args) {
        //第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("张三丰");
        one.add("张无忌");
        one.add("熊大");
        one.add("熊二");
        one.add("喜羊羊");
        one.add("灰太狼");
        Stream<String> stream1 = one.stream().filter(s -> s.length() == 3).limit(3);

        //第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("张丹峰");
        two.add("张靓颖");
        two.add("哈哈");
        two.add("光头强");
        two.add("孙悟空");
        two.add("张三丰");
        two.add("唐僧");
        two.add("张无忌");
        Stream<String> stream2 = two.stream().filter(s -> s.startsWith("张")).skip(2);

        Stream.concat(stream1, stream2).map(s->new Person(s)).forEach(p-> System.out.println(p));
    }

三、方法引用

3.1方法引用符：双冒号::为引用运算符，而他所在的表达式被称为方法引用。若Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可用双冒号来引用该方法作为Lambda的替代者。
①通过对象名引用成员方法

/*
通过对象名引用成员方法
 */
public class Demo01ObjectMethodReference {
    public static void printString(Printable p){
        p.print("hello");
    }

    public static void main(String[] args) {
        printString((s)->{
            new MethodRerObject().method(s);
        });
        printString(new MethodRerObject()::method);
    }
}

②通过类名引用静态成员方法

/*
通过类名引用静态成员方法
 */
public class Demo01StaticMethodReference {
    //定义一个方法
    public static int method(int i,Calcabe cal){

        return cal.calcable(i);
    }

    public static void main(String[] args) {
        int method = method(-10, (n) -> {
            //对参数进行绝对值计算并返回
            return Math.abs(n);
        });
        System.out.println(method);


        /*
        使用方法引用优化Lambda表达式
         */
        int method1 = method(-110, Math::abs);
        System.out.println(method1);
    }

③通过super引用成员方法

public class Man extends Person{
    @Override
    public void sayHello(){
        System.out.println("Hello,我是Man");
    }

    public void method(Greetable g){
        g.greet();
    }

    public void show(){
       /* method(()->{
            Person p = new Person();
            p.sayHello();
        });*/
     /*  method(()->super.sayHello());*/
        method(super::sayHello);
    }

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

④通过this引用成员方法
⑤类的构造器引用
printName(“光头强”,name->new Person(name));
printName(“光头强”,Person::new)；
⑥数组的构造器引用

public class Test {
    public static int[] createArray(int length,ArrayBuilder ab){
        return ab.builderArray(length);
    }

    public static void main(String[] args) {
        //int[] array = createArray(10, length -> new int[10]);
        int[] array = createArray(10, int[]::new);
        Stream<int[]> array1 = Stream.of(array);
        array1.forEach(s-> System.out.println(Arrays.toString(s)));
    }
}