Stream流 -- java常用API

最新推荐文章于 2023-05-26 10:57:14 发布

hu的小金库

最新推荐文章于 2023-05-26 10:57:14 发布

阅读量185

点赞数

分类专栏： java学习 java API

本文链接：https://blog.csdn.net/weixin_42137874/article/details/115580810

版权

java学习同时被 2 个专栏收录

52 篇文章 0 订阅

订阅专栏

java API

13 篇文章 0 订阅

订阅专栏

Stream流概述

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

/**
    目标： 演示Stream流的强大。

    什么是Stream流？
        在Java 8中，得益于Lambda所带来的函数式编程，
        引入了一个全新的Stream流概念 ，用于解决已有集合/数组类库有的弊端。

    Stream流能解决什么问题?
        可以解决已有集合类库或者数组API的弊端。
        Stream认为集合和数组操作的API很不好用，所以采用了Stream流简化集合和数组的操作！！

    小结：
        Stream流是用来简化集合类库或者数组API的弊端。
        Stream流其实就一根传送带，元素在上面可以被Stream流操作。
 */
public class StreamDemo01 {
    public static void main(String[] args) {
        // 需求：从集合中筛选出所有姓张的人出来。然后再找出姓名长度是3的人。
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        list.stream().filter(s -> s.startsWith("张")).filter( s -> s.length()== 3 )
                .forEach(System.out::println);

//        // a.先找出姓张的人。
//        List<String> zhangLists = new ArrayList<>();
//        for (String s : list) {
//            if(s.startsWith("张")){
//                zhangLists.add(s);
//            }
//        }
//        System.out.println(zhangLists);
//
//        // b.张姓姓名长度为3的人
//        List<String> zhangThreeLists = new ArrayList<>();
//        for (String s : zhangLists){
//            if(s.length() == 3){
//                zhangThreeLists.add(s);
//            }
//        }
//        System.out.println(zhangThreeLists);
    }
}

Stream流的获取

import java.util.*;
import java.util.stream.Stream;

/**
     目标：Stream流的获取

     Stream流式思想的核心：
                 是先得到集合或者数组的Stream流（就是一根传送带）
                 然后就用这个Stream流操作集合或者数组的元素。
                 然后用Stream流简化替代集合操作的API.

     集合获取流的API:
         (1) default Stream<E> stream();

     小结：
         集合获取Stream流用: stream();
         数组：Arrays.stream(数组)   /  Stream.of(数组);
 */
public class StreamDemo01 {
    public static void main(String[] args) {
        /** --------------------Collection集合获取流-------------------------------   */
        // Collection集合如何获取Stream流。
        Collection<String> c = new ArrayList<>();
        Stream<String> ss = c.stream();

        /** --------------------Map集合获取流-------------------------------   */
        Map<String, Integer> map = new HashMap<>();
        // 先获取键的Stream流。
        Stream<String> keyss = map.keySet().stream();
        // 在获取值的Stream流
        Stream<Integer> valuess = map.values().stream();
        // 获取键值对的Stream流（key=value： Map.Entry<String,Integer>）
        Stream<Map.Entry<String,Integer>> keyAndValues = map.entrySet().stream();

        /** ---------------------数组获取流------------------------------   */
        // 数组也有Stream流。
        String[] arrs = new String[]{"Java", "JavaEE" ,"Spring Boot"};
        Stream<String> arrsSS1 = Arrays.stream(arrs);
        Stream<String> arrsSS2 = Stream.of(arrs);

    }
}

Stream流的常用API

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

/**
     目标：Stream流的常用API
     forEach : 逐一处理(遍历)
     count：统计个数
        -- long count();
     filter : 过滤元素
        -- Stream<T> filter(Predicate<? super T> predicate)
     limit : 取前几个元素
     skip : 跳过前几个
     map : 加工方法
     concat : 合并流。
 */
public class StreamDemo01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三丰");

        list.stream().filter( s -> s.length() == 3 ).filter( s -> s.startsWith("张"))
                .forEach( System.out::println);
        // 统计数量
        long count = list.stream().filter( s -> s.length() == 3 )
                .filter( s -> s.startsWith("张")).count();
        System.out.println(count);
        // 取前2个
        list.stream().filter(s -> s.length() == 3).limit(2)
                .forEach( System.out::println);
        // 跳过前2个
        list.stream().filter(s -> s.length() == 3).skip(2)
                .forEach( System.out::println);
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

/**
    目标：Stream流的常用API
            -- Stream<T> filter(Predicate<? super T> predicate)
         forEach : 逐一处理
         count：统计个数
            -- long count();
         filter : 过滤元素
         limit : 取前几个元素
         skip : 跳过前几个
         map （映射）: 加工方法（把原来的元素加工以后，从新放上去）
            -- <R> Stream<R> map(Function<? super T, ? extends R> mapper);
         concat : 合并流
 */
public class StreamDemo02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三丰");

        // 需求：把名称都加上“黑马的:+xxx”
        list.stream().map(a -> "黑马的："+a).forEach(System.out::println);

        // 需求：把名称都加工厂学生对象放上去!!
        // list.stream().map(name -> new Student(name)).forEach(System.out::println);

        list.stream().map(Student::new).forEach(System.out::println);
    }
}

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

/**
    目标：Stream流的常用API
            -- Stream<T> filter(Predicate<? super T> predicate)
         forEach : 逐一处理
         count：统计个数
            -- long count();
         filter : 过滤元素
         limit : 取前几个元素
         skip : 跳过前几个
         map : 加工方法（把原来的元素加工以后，从新放上去）
         concat : 合并流
            -- public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
 */
public class StreamDemo03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三丰");

        // 数组流
        Stream<Integer> s1 = Stream.of(10, 20 ,30 ,40);
        // 集合流
        Stream<String> s2 = list.stream();
        // 合并流
        Stream<Object> s3 = Stream.concat(s1,s2);
        s3.forEach(System.out::println);
    }
}

public class Student {
    private String name ;

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

    public String getName() {
        return name;
    }

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

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

Stream流的综合应用

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

/**
    目标：综合案例
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("老子");
        one.add("庄子");
        one.add("孙子");
        one.add("洪七公");

        List<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("张三丰");
        two.add("赵丽颖");
        two.add("张二狗");
        two.add("张天爱");
        two.add("张三");

        /**
         * 1. 第一个队伍只要名字为3个字的成员姓名；
         * 2. 第一个队伍筛选之后只要前3个人；
         */
        Stream<String> oneStream =
                one.stream().filter(s -> s.length() == 3).limit(3);

        /**
         * 3. 第二个队伍只要姓张的成员姓名；
         * 4. 第二个队伍筛选之后不要前2个人；
         * 5. 将两个队伍合并为一个队伍；
         */
        Stream<String> twoStream =
                two.stream().filter(s -> s.startsWith("张")).skip(2);
        Stream<String> allStream = Stream.concat(oneStream , twoStream);

        /**
         * 6. 根据姓名创建`Student`对象； (加工)
         * 7. 打印整个队伍的Student对象信息。
         */
        //allStream.map(s -> new Student(s)).forEach(System.out::println);
        allStream.map(Student::new).forEach(System.out::println);
    }
}

public class Student {
    private String name ;

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

    public String getName() {
        return name;
    }

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

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

终结与非终结方法

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

/**
    目标：终结与非终结方法。

    终结方法：一旦Stream调用了终结方法，流的操作就全部终结了，不能继续使用，
        只能创建新的Stream操作。
        终结方法： foreach , count。

    非终结方法：每次调用完成以后返回一个新的流对象,
        可以继续使用，支持链式编程！
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三丰");

        // foreach终结方法
        list.stream().filter(s -> s.startsWith("张"))
                .filter(s -> s.length() == 3).forEach(System.out::println);

        long count =  list.stream().filter(s -> s.startsWith("张"))
                .filter(s -> s.length() == 3).count();
        System.out.println(count);
    }
}

收集Stream流:把Stream流的数据转回成集合

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
    目标：收集Stream流:把Stream流的数据转回成集合。

    引入：
        Stream的作用是：把集合转换成一根传送带，借用Stream流的强大功能进行的操作。
        但是实际开发中数据最终的形式还是应该是集合，最终Stream流操作完毕以后还是要转换成集合。
        这就是收集Stream流。

    收集Stream流的含义：就是把Stream流的数据转回到集合中去。

    Stream流：手段。
    集合：才是目的。

    小结：
        收集Stream流的含义：就是把Stream流的数据转回到集合中去。

    熟练函数式编程，如Lambda表达式简化函数式接口的匿名内部类形式，
    以及四种方法引用简化Lambda表达式，以及流式编程思想如Stream简化集合或者数组的操作。
 */
public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三丰");

        Stream<String> zhangLists = list.stream().filter(s -> s.startsWith("张"));
        // 把stream流转换成Set集合。
        Set<String> sets = zhangLists.collect(Collectors.toSet());
        System.out.println(sets);

        // 把stream流转换成List集合。
        Stream<String> zhangLists1 = list.stream().filter(s -> s.startsWith("张"));
        List<String> lists= zhangLists1.collect(Collectors.toList());
        System.out.println(lists);

        // 把stream流转换成数组。
        Stream<String> zhangLists2 = list.stream().filter(s -> s.startsWith("张"));
        Object[] arrs = zhangLists2.toArray();
        // 可以借用构造器引用申明转换成的数组类型！！！
        String[] arrs1 = zhangLists2.toArray(String[]::new);
    }
}

hu的小金库

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Stream流 -- java常用API

Stream流概述import java.util.ArrayList;import java.util.List;/** 目标：演示Stream流的强大。什么是Stream流？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream流概念，用于解决已有集合/数组类库有的弊端。 Stream流能解决什么问题? 可以解决已有集合类库或者数组API的弊端。 Stream认为集
复制链接

扫一扫