Java基础之Stream API（1.8新特性）_list.stream()api-CSDN博客

本文链接：https://blog.csdn.net/wanglulu12138/article/details/84774296

Stream API（1.8新特性）

Stream API：

是Java1.8以后出现的新特性，是为了使程序员能更加方便的编程，通常结合lambda使用。

把数据以一种流的方式，给流内的数据提供各种接口和方法，根据不同的需求，自己组合使用接口和方法。

Stream API中由一个重要思想，流水线思想（Pipeline）就是流中的数据是一个接一个的进行处理的，而且原始数据不会改变，还会保留。在流的执行过程中，lambda是懒惰式的，就是不执行终结方法，不会戳发lambda是执行，只有在进行了比如min，collect等方法才会执行。

重要的接口：

1.Predicate(断言接口)

对应的lambda表达式：一个参数返回结果是boolean
（a）-> { return true|| false}

2.Function(函数接口)

对应的lambda表达式：一个参数一个返回结果（参数和返回结果的类型可以不一样）
（a）-> (根据参数a返回一个结果)

3.BiPredicate(双参数断言接口)

对应的lambda表达式：两个参数返回结果是boolean
（a，b）-> { return true|| false}

4.BiFunction(双参数函数接口)

对应的lambda表达式：两个参数一个返回结果
（a，b）-> (根据a，b参数返回一个结果)

5.Consumer（消费接口）

对应的lambda表达式：一个参数没有结果
（a）-> { 不需要返回值}

6.BiConsumer（双参数消费接口）

对应的lambda表达式：两个参数没有结果
（a，b）-> { 不需要返回值}

7.Suppiler（生产者接口）

对应的lambda表达式：没有参数返回一个结果
（）-> {返回一个结果}

Stream API：

1.filter（进行过滤）
会把lambda表达式中返回值为true的留下，把返回值为false的过滤掉。
由其特性可知结合返回值为boolean类型的接口使用。
public class Demo1 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        List<Integer> list1 = list.stream().filter((i) -> i % 2 == 0).collect(Collectors.toList());
        System.out.println(list1);
    }
}
2.map （映射）
把lambda原有的参数转化成另外一个参数（一一映射的改变，元素的个数不会改变，参数类型可以改变）
由其特性可知结合有参数，有返回值的接口使用。
public class Demo2 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        List<Integer> list1 = list.stream().map(i->i*2).collect(Collectors.toList());
        System.out.println(list1);
    }
}
3.flatMap（扁平化映射）
把逻辑上二维数据类型的容器转化为一维的数据类型的容器
public class Demo3 {
    public static void main(String[] args) {
        ArrayList<String[]> arrayList = new ArrayList();
        arrayList.add(new String[]{"Mr.Wang","Mr.Lu"});
        arrayList.add(new String[]{"Mrs.Yang","Mrs.Niu"});
        List<String> list = arrayList.stream().flatMap(string -> Arrays.stream(string)).collect(Collectors.toList());
        System.out.println(list);
    }
}
4.forEach（遍历流）
遍历容器中的数据，一维二维的一样方便。
由其特性可知结合有参数，没有返回值的接口使用。
public class Demo4 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        list.stream().forEach( i-> System.out.println(i));
        HashMap<String, String> map = new HashMap<>();
        map.put("a","wang");
        map.put("b","lu");
        map.put("c","yang");
        map.forEach((key,vlaue)-> System.out.println(key+"---"+vlaue));
    }
}
5.count（计数）
计算容器中数据的个数。
public class Demo5 {
    public static void main(String[] args) {
         List<Integer> list = Arrays.asList(1,2,3,4,5);
        System.out.println(list.stream().count());
    }
}
6.distinct（去除重复）
去除容器中重复的数据
public class Demo6 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,6,5,3,4,5,8,7,4,2,1);
        System.out.println(list.stream().distinct().collect(Collectors.toList()));
    }
}
7.max min（求最大值最小值）
可求字符类型的大小，根据ASIIC码计算
public class Demo7 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList();
        arrayList.add("c");
        arrayList.add("b");
        arrayList.add( "a");
        arrayList.add("d");
        System.out.println(arrayList.stream().min((a,b)->a.compareTo(b)));
        System.out.println(arrayList.stream().max((a,b)->a.compareTo(b)));
    }
}
8.数字流的特有方法 min max sum average
求数字流的最小值，最大值，平均数，求和
public class Demo8 {
    public static void main(String[] args) {
        System.out.println(IntStream.of(1,2,3,4,5).min());
        System.out.println(IntStream.of(1,2,3,4,5).max());
        System.out.println(IntStream.of(1,2,3,4,5).sum());
        System.out.println(IntStream.of(1,2,3,4,5).average());
    }
}
9.collect（收集）
把流数据收集起来可选参数作为不同的用法
collect（collectors.toLIst()）把流中的数据收集起来并且转化为List集合。根据不同的序曲to不同的数据类型
collect（collectors.groupingby()）把流中的数据收集起来并且根据groupingby()中的接口分成不同的组
public class Demo9 {
    public static void main(String[] args) {
        List<Person> list = Arrays.asList(
                new Person("男","wang",21),
                new Person("女","yang",20),
                new Person("男","li",20)
        );
        System.out.println(list.stream().collect(Collectors.groupingBy(s->s.getSex())));
    }
}
10.limit (限制)
限制流输出的数据个数
public class Demo10 {
    public static void main(String[] args) {
        Random random = new Random(100);
        Stream.generate(()-> random.nextInt(100)).limit(5).forEach(i-> System.out.println(i));
    }
}

流的生成

1.用集合生成：List.Stream()

2.由数字生成：intStream.of(int类型的数字)

3.由数组生成：Arrays.Stream(数组)

4.把文件中的每行数据读出来作为流元素
Files.lines.(paths.get(”文件路径“).forEach(x->System.out.println(x)))
public class DemoB {
    public static void main(String[] args) throws IOException {
        Files.lines(Paths.get("a.txt")).forEach(i-> System.out.println(i));
    }
}
5.使用生产者接口：

Stream.generate(()-> r.nextInt().forEach(System.out.println(x))