Stream流，方法引用

线性循环只能过滤一次，如果要再次循环需要用另一个循环重新开始。使用Lambda衍生的Stream流的方式，可以更简单的遍历集合。
-Stream是一个来自数据源的元素队列
-元素是特定类型的对象，形成一个队列。java中的Stream并不会存储元素，而是按需计算
-数据源 流的来源，可以是集合，数组等
-Stream流是一个集合元素的函数模型，并不是集合，也不是数据结构，其本身并不存储任何元素或地址值

import java.util.ArrayList;
import java.util.List;

public class Stream {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
     list.add("张无忌");
     list.add("张三");
     list.add("张三丰");
     list.add("周芷若");
     list.add("赵敏");
        list.stream()
                .filter(name->name.startsWith("张"))
                .filter(name->name.length()==3)
                .forEach(name->System.out.println(name));
    }
}

Stream流是管道流，只能被消费一次，常用方法如下：
-映射：map，将一个流中的元素映射到另一个流中

import java.util.stream.Stream;
public class StreamMap {

    private static String stream;

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

-统计个数：count，统计元素个数

import java.util.ArrayList;
import java.util.stream.Stream;

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

-取用前几个：limit

import java.util.stream.Stream;
public class StreamLimit {
    public static void main(String[] args) {
        String[]arr = {"1","2","3","4"};
        Stream<String>stream = Stream.of(arr);
        Stream<String>stream2 = stream.limit(3);
        stream2.forEach(num-> System.out.println(num));

    }
}

-跳过前几个：skip

import java.util.stream.Stream;
public class StreamSkip {
    public static void main(String[] args) {
        String[]arr = {"1","2","3","4"};
        Stream<String>stream = Stream.of(arr);
        Stream<String> stream2 = stream.skip(2);
        stream2.forEach(num-> System.out.println(num));

    }
}

-组合：concat两个流合并成一个流

import java.util.stream.Stream;
public class StreamConcat {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("一","二","三");
        String[]arr = {"1","2","3",};
        Stream<String> stream2 = Stream.of(arr);
        Stream<String> concat = Stream.concat(stream1, stream2);
        concat.forEach(num-> System.out.println(num));
    }
}

方法引用
如果lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号“::”来引用该方法作为Lambda的代替者

-通过对象名来引用成员方法
-通过类名引用静态成员方法
-通过super引用父类的成员方法
-通过this引用本类的成员方法
-通过引用类的构造器（构造方法）引用
-引用数组的构造器引用