栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

JDK8新特性之Stream流

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

JDK8新特性之Stream流

一、集合处理数据的弊端

当我们在需要对集合中的元素进行操作的时候,除了必需的添加,删除,获取外,最典型的操作就是集合遍历,看一段代码

public static void main(String[] args) {
    // 定义一个List集合
    List list = Arrays.asList("张三", "张三丰", "成龙", "周星驰");
    // 1.获取所有 姓张的信息
    List list1 = new ArrayList<>();
    for (String s : list) {
        if (s.startsWith("张")) {
            list1.add(s);
        }
    }
    // 2.获取名称长度为3的用户
    List list2 = new ArrayList<>();
    for (String s : list1) {
        if (s.length() == 3) {
            list2.add(s);
        }
    }
    // 3. 输出所有的用户信息
    for (String s : list2) {
        System.out.println(s);
    }
}

上面的代码针对与我们不同的需求总是一次次的循环循环循环.这时我们希望有更加高效的处理方式,这时我们就可以通过JDK8中提供的Stream API来解决这个问题了。

public static void main(String[] args) {
    // 定义一个List集合
    List list = Arrays.asList("张三", "张三丰", "成龙", "周星驰");
    list.stream()
            // 1.获取所有 姓张的信息
            .filter(s -> s.startsWith("张"))
            // 2.获取名称长度为3的用户
            .filter(s -> s.length() == 3)
            // 3. 输出所有的用户信息
            .forEach(System.out::println);
}
二、Steam流式思想概述

Stream和IO流(InputStream/OutputStream)没有任何关系,请暂时忘记对传统IO流的固有印象

Stream流式思想类似于工厂车间的“生产流水线”,Stream流不是一种数据结构,不保存数据,而是对数据进行加工 处理。Stream可以看作是流水线上的一个工序。在流水线上,通过多个工序让一个原材料加工成一个商品。

Stream API能让我们快速完成许多复杂的操作,如筛选、切片、映射、查找、去除重复,统计,匹配和归约。

三、Stream流的获取方式 ①、根据Collection获取

java.util.Collection 接口中加入了default方法 stream,也就是说Collection接口下的所有的实 现都可以通过stream方法来获取Stream流。

public static void main(String[] args) {
    List list = new ArrayList<>();
    list.stream();
    Set set = new HashSet<>();
    set.stream();
    Vector vector = new Vector();
    vector.stream();
}

由于Map接口别没有实现Collection接口,可以根据Map获取对应的key value的集合。

public static void main(String[] args) {
    Map map = new HashMap<>();
    Stream stream = map.keySet().stream(); // key
    Stream stream1 = map.values().stream(); // value
    Stream> stream2 = map.entrySet().stream(); //entry
}
 
②、Stream.of方法 

在实际开发中我们不可避免的还是会操作到数组中的数据,由于数组对象不可能添加默认方法,所有Stream接口中提供了静态方法of,基本数据类型的数组是不行的

public static void main(String[] args) {
    Stream a1 = Stream.of("a1", "a2", "a3");
    String[] arr1 = {"aa","bb","cc"};
    Stream arr11 = Stream.of(arr1);
    Integer[] arr2 = {1,2,3,4};
    Stream arr21 = Stream.of(arr2);
    arr21.forEach(System.out::println);
}
四、Stream常用方法
方法名方法作用返回值类型方法种类
count统计个数long终结
forEach逐一处理void终结
filter过滤Stream函数拼接
limit取用前几个Stream函数拼接
skip跳过前几个Stream函数拼接
map映射Stream函数拼接
concat组合Stream函数拼接

终结方法:返回值类型不再是 Stream 类型的方法,不再支持链式调用。本小节中,终结方法包括 count 和 forEach 方法。

非终结方法:返回值类型仍然是 Stream 类型的方法,支持链式调用。(除了终结方法外,其余方法均为非终结方法。)

注意事项

  • Stream只能操作一次
  • Stream方法返回的是新的流
  • Stream不调用终结方法,中间的操作不会执行
①、forEach

forEach用来遍历流中的数据的

public static void main(String[] args) {
    Stream.of("1", "2", "3").forEach(System.out::println);
}

该方法接受一个Consumer接口(一个输入,没有返回),会将每一个流元素交给函数处理

void forEach(Consumer action)
②、count

Stream流中的count方法用来统计其中的元素个数的

public static void main(String[] args) {
    System.out.println(Stream.of("1", "2", "3").count());
}

该方法返回一个long值,代表元素的个数

long count();
③、filter

filter方法的作用是用来过滤数据的,返回符合条件的数据,也可以通过filter方法将一个流转换成另一个子集流

public static void main(String[] args) {
    Stream.of("a1", "a2", "a3", "bb", "cc", "aa", "dd")
        .filter((s) -> s.contains("a"))
        .forEach(System.out::println);
}

该接口接收一个Predicate函数式接口(一个输入,返回boolean)参数作为过滤条件

Stream filter(Predicate predicate);
④、limit

limit方法可以对流进行截取处理,只取前n个数据

public static void main(String[] args) {
    Stream.of("a1", "a2", "a3", "bb", "cc", "aa", "dd")
            .limit(3)
            .forEach(System.out::println);
}

参数是一个long类型的数值,如果集合当前长度大于参数就进行截取,否则不操作

⑤、skip

如果希望跳过前面几个元素,可以使用skip方法获取一个截取之后的新流

public static void main(String[] args) {
    Stream.of("a1", "a2", "a3", "bb", "cc", "aa", "dd")
            .skip(3)
            .forEach(System.out::println);
}
⑥、map

如果我们需要将流中的元素映射到另一个流中,可以使用map方法

public static void main(String[] args) {
    Stream.of("1", "2", "3", "4", "5", "6", "7")
        .map(Integer::parseInt)
        .forEach(System.out::println);
}

该接口需要一个Function函数式接口参数,可以将当前流中的T类型数据转换为另一种R类型的数据

 Stream map(Function mapper);
⑦、sorted

如果需要将数据排序,可以使用sorted方法

public static void main(String[] args) {
    Stream.of("1", "3", "2", "4", "0", "9", "7")
            .map(Integer::parseInt)
            // 根据数据的自然顺序排序
            //.sorted()
            // 根据比较强指定排序规则
            .sorted((o1, o2) -> o2 - o1)
            .forEach(System.out::println);
}
⑧、distinct

如果要去掉重复数据,可以使用distinct方法

public static void main(String[] args) {
    Stream.of(
            new Person("张三", 18)
            , new Person("李四", 22)
            , new Person("张三", 18)
    ).distinct()
            .forEach(System.out::println);
}

Stream流中的distinct方法对于基本数据类型是可以直接出重的,但是对于自定义类型,我们是需要重写hashCode和equals方法来移除重复元素。

⑨、match

如果需要判断数据是否匹配指定的条件,可以使用match相关的方法

public static void main(String[] args) {
    boolean b = Stream.of("1", "3", "3", "4", "5", "1", "7")
        .map(Integer::parseInt)
        // 元素是否都满足条件
        //.allMatch(s -> s > 0)
        // 元素是否有任意一个满足条件
        //.anyMatch(s -> s >4)
        // 元素是否都不满足条件
        .noneMatch(s -> s > 4);
    System.out.println(b);
}
⑩、reduce

如果需要将所有数据归纳得到一个数据,可以使用reduce方法

public static void main(String[] args) {
    Integer sum = Stream.of(4, 5, 3, 9)
            // 第一个参数identity是默认值,第一次的时候会将默认值赋值给x,之后每次会将上一次的操作结果赋值给x y就是每次从数据中获取的元素
            .reduce(0, (x, y) -> {
                System.out.println("x=" + x + ",y=" + y);
                return x + y;
            });
    System.out.println(sum);
    // 获取 最大值
    Integer max = Stream.of(4, 5, 3, 9)
            .reduce(0, (x, y) -> x > y ? x : y);
    System.out.println(max);
}
⑪、concat

如果有两个流,希望合并成为一个流,那么可以使用Stream接口的静态方法concat

public static void main(String[] args) {
    Stream stream1 = Stream.of("a", "b", "c");
    Stream stream2 = Stream.of("x", "y", "z");
    // 通过concat方法将两个流合并为一个新的流
    Stream.concat(stream1, stream2).forEach(System.out::println);
}
⑫、find

如果我们需要找到某些数据,可以使用find方法来实现 ,返回的Optional对象,关于这个对象,后面会提到

Optional findFirst();
Optional findAny();

通过名字,就可以看到,对这个集合的流,做一系列的中间操作后,可以调用findFirst,返回集合的第一个对象,findAny返回这个集合中,取到的任何一个对象

  • 在串行的流中,findAny和findFirst返回的,都是第一个对象
  • 而在并行的流中,findAny返回的是最快处理完的那个线程的数据,所以说,在并行操作中,对数据没有顺序上的要求,那么findAny的效率会比findFirst要快的
public static void main(String[] args) {
    Optional first = Stream.of("1", "3", "3", "4", "5", "1",
            "7").findFirst();
    System.out.println(first.get());
    Optional any = Stream.of("1", "3", "3", "4", "5", "1",
            "7").findAny();
    System.out.println(any.get());
}
⑬、 max和min

如果我们想要获取最大值和最小值,那么可以使用max和min方法,返回的对象同样是Optional

Optional min(Comparator comparator);
Optional max(Comparator comparator);

使用

public static void main(String[] args) {
    Optional max = Stream.of("1", "3", "3", "4", "5", "1", "7")
            .map(Integer::parseInt)
            .max(Comparator.comparingInt(o -> o));
    System.out.println(max.get());
    Optional min = Stream.of("1", "3", "3", "4", "5", "1", "7")
            .map(Integer::parseInt)
            .min(Comparator.comparingInt(o -> o));
    System.out.println(min.get());
}
⑭、mapToInt

如果需要将Stream中的Integer类型转换成int类型,可以使用mapToInt方法来实现

public static void main(String[] args) {
    // Integer占用的内存比int多很多,在Stream流操作中会自动装修和拆箱操作
    Integer[] arr = {1, 2, 3, 5, 6, 8};
    Stream.of(arr)
            .filter(i -> i > 0)
            .forEach(System.out::println);
    System.out.println("---------");
    // 为了提高程序代码的效率,我们可以先将流中Integer数据转换为int数据,然后再操作
    IntStream intStream = Stream.of(arr)
            .mapToInt(Integer::intValue);
    intStream.filter(i -> i > 3)
            .forEach(System.out::println);
}
⑮、map和reduce的组合

在实际开发中我们经常会将map和reduce一块来使用

public static void main(String[] args) {
    // 1.求出所有年龄的总和
    Integer sumAge = Stream.of(new Person("张三", 18)
            , new Person("李四", 22)
            , new Person("张三", 13)
            , new Person("王五", 15)
            , new Person("张三", 19))
            // 实现数据类型的转换
            .map(Person::getAge)
            .reduce(0, Integer::sum);
    System.out.println(sumAge);
    // 2.求出所有年龄中的最大值
    Integer maxAge = Stream.of(new Person("张三", 18)
            , new Person("李四", 22)
            , new Person("张三", 13)
            , new Person("王五", 15)
            , new Person("张三", 19))
            // 实现数据类型的转换,符合reduce对数据的要求
            .map(Person::getAge)
            // reduce实现数据的处理
            .reduce(0, Math::max);
    System.out.println(maxAge);
    // 3.统计 字符 a 出现的次数
    Integer count = Stream.of("a", "b", "c", "d", "a", "c", "a")
            .map(ch -> "a".equals(ch) ? 1 : 0)
            .reduce(0, Integer::sum);
    System.out.println(count);
}
⑯、综合案例

定义两个集合,然后在集合中存储多个用户名称。然后完成如下的操作:

  • 第一个队伍只保留姓名长度为3的成员
  • 第一个队伍筛选之后只要前3个人
  • 第二个队伍只要姓张的成员
  • 第二个队伍筛选之后不要前两个人
  • 将两个队伍合并为一个队伍
  • 根据姓名创建Person对象
  • 打印整个队伍的Person信息
public static void main(String[] args) {
    List list1 = Arrays.asList("迪丽热巴", "宋远桥", "苏星河", "老子",
                                       "庄子", "孙子", "洪七 公");
    List list2 = Arrays.asList("古力娜扎", "张无忌", "张三丰", "赵丽颖",
                                       "张二狗", "张天爱", "张三");
    // 1. 第一个队伍只保留姓名长度为3的成员
    // 2. 第一个队伍筛选之后只要前3个人
    Stream stream1 = list1.stream().filter(s -> s.length() ==
                                                   3).limit(3);
    // 3. 第二个队伍只要姓张的成员
    // 4. 第二个队伍筛选之后不要前两个人
    Stream stream2 = list2.stream().filter(s ->
                                                   s.startsWith("张")).skip(2);
    // 5. 将两个队伍合并为一个队伍
    // 6. 根据姓名创建Person对象
    // 7. 打印整个队伍的Person信息
    Stream.concat(stream1, stream2)
        .map(Person::new)
        .forEach(System.out::println);
}
五、Stream结果收集 ①、结果收集到集合中
public static void main(String[] args) {
    List list = Stream.of("aa", "bb", "cc", "aa")
        .collect(Collectors.toList());
    System.out.println(list);
    // 收集到 Set集合中
    Set set = Stream.of("aa", "bb", "cc", "aa")
        .collect(Collectors.toSet());
    System.out.println(set);
    // 如果需要获取的类型为具体的实现,比如:ArrayList HashSet
    ArrayList arrayList = Stream.of("aa", "bb", "cc", "aa")
        .collect(Collectors.toCollection(ArrayList::new));
    System.out.println(arrayList);
    HashSet hashSet = Stream.of("aa", "bb", "cc", "aa")
        .collect(Collectors.toCollection(HashSet::new));
    System.out.println(hashSet);
}
②、结果收集到数组中

Stream中提供了toArray方法来将结果放到一个数组中,返回值类型是Object[],如果我们要指定返回的类型,那么可以使用另一个重载的toArray(IntFunction f)方法

public static void main(String[] args) {
    Object[] objects = Stream.of("aa", "bb", "cc", "aa")
            // 返回的数组中的元素是 Object类型
            .toArray();
    System.out.println(Arrays.toString(objects));
    // 如果我们需要指定返回的数组中的元素类型
    String[] strings = Stream.of("aa", "bb", "cc", "aa")
            .toArray(String[]::new);
    System.out.println(Arrays.toString(strings));
}
③、对流中的数据做聚合计算

我们使用Stream流处理数据后,可以像数据库的聚合函数一样对某个字段进行操作,比如获得最大值,最小值,求和,平均值,统计数量。

public static void main(String[] args) {
    // 获取年龄的最大值
    Optional maxAge = Stream.of(
            new Person("张三", 18)
            , new Person("李四", 22)
            , new Person("张三", 13)
            , new Person("王五", 15)
            , new Person("张三", 19)
    ).max(Comparator.comparingInt(Person::getAge));
    System.out.println("最大年龄:" + maxAge.get());
    // 获取年龄的最小值
    Optional minAge = Stream.of(
            new Person("张三", 18)
            , new Person("李四", 22)
            , new Person("张三", 13)
            , new Person("王五", 15)
            , new Person("张三", 19)
    ).min(Comparator.comparingInt(Person::getAge));
    System.out.println("最新年龄:" + minAge.get());
    // 求所有人的年龄之和
    int sumAge = Stream.of(
            new Person("张三", 18)
            , new Person("李四", 22)
            , new Person("张三", 13)
            , new Person("王五", 15)
            , new Person("张三", 19)
    ).mapToInt(Person::getAge).sum();
    System.out.println("年龄总和:" + sumAge);
    // 年龄的平均值
    Double avgAge = Stream.of(
            new Person("张三", 18)
            , new Person("李四", 22)
            , new Person("张三", 13)
            , new Person("王五", 15)
            , new Person("张三", 19)
    ).collect(Collectors.averagingInt(Person::getAge));
    System.out.println("年龄的平均值:" + avgAge);
    // 统计数量
    long count = Stream.of(
            new Person("张三", 18)
            , new Person("李四", 22)
            , new Person("张三", 13)
            , new Person("王五", 15)
            , new Person("张三", 19)
    ).filter(p -> p.getAge() > 18).count();
    System.out.println("满足条件的记录数:" + count);
}
④、对流中数据做分组操作
public static void main(String[] args) {
    // 根据账号对数据进行分组
    Map> map1 = Stream.of(
            new Person("张三", 18, 175)
            , new Person("李四", 22, 177)
            , new Person("张三", 14, 165)
            , new Person("李四", 15, 166)
            , new Person("张三", 19, 182)
    ).collect(Collectors.groupingBy(Person::getName));
    map1.forEach((k, v) -> System.out.println("k=" + k + "t" + "v=" + v));
    System.out.println("-----------");
    // 根据年龄分组 如果大于等于18 成年否则未成年
    Map> map2 = Stream.of(
            new Person("张三", 18, 175)
            , new Person("李四", 22, 177)
            , new Person("张三", 14, 165)
            , new Person("李四", 15, 166)
            , new Person("张三", 19, 182)
    ).collect(Collectors.groupingBy(p -> p.getAge() >= 18 ? "成年" : "未成年"));
    map2.forEach((k, v) -> System.out.println("k=" + k + "t" + "v=" + v));
}

多级分组: 先根据name分组然后根据年龄分组

public static void main(String[] args) {
    // 先根据name分组,然后根据age(成年和未成年)分组
    Map>> map = Stream.of(
            new Person("张三", 18, 175)
            , new Person("李四", 22, 177)
            , new Person("张三", 14, 165)
            , new Person("李四", 15, 166)
            , new Person("张三", 19, 182)
    ).collect(Collectors.groupingBy(Person::getName, Collectors.groupingBy(p -> p.getAge() >= 18 ? "成年" : "未成年")));
    map.forEach((k, v) -> {
        System.out.println(k);
        v.forEach((k1, v1) -> {
            System.out.println("t" + k1 + "=" + v1);
        });
    });
}
⑤、对流中的数据做分区操作

Collectors.partitioningBy会根据值是否为true,把集合中的数据分割为两个列表,一个true列表,一个 false列表

public static void main(String[] args) {
    Map> map = Stream.of(
            new Person("张三", 18, 175)
            , new Person("李四", 22, 177)
            , new Person("张三", 14, 165)
            , new Person("李四", 15, 166)
            , new Person("张三", 19, 182)
    ).collect(Collectors.partitioningBy(p -> p.getAge() > 18));
    map.forEach((k, v) -> System.out.println(k + "t" + v));
}
⑥、对流中的数据做拼接

Collectors.joining会根据指定的连接符,将所有的元素连接成一个字符串

public static void main(String[] args) {
    String s1 = Stream.of(
            new Person("张三", 18, 175)
            , new Person("李四", 22, 177)
            , new Person("张三", 14, 165)
            , new Person("李四", 15, 166)
            , new Person("张三", 19, 182)
    ).map(Person::getName).collect(Collectors.joining());
    // 张三李四张三李四张三
    System.out.println(s1);
    String s2 = Stream.of(
            new Person("张三", 18, 175)
            , new Person("李四", 22, 177)
            , new Person("张三", 14, 165)
            , new Person("李四", 15, 166)
            , new Person("张三", 19, 182)
    ).map(Person::getName).collect(Collectors.joining("_"));
    // 张三_李四_张三_李四_张三
    System.out.println(s2);
    String s3 = Stream.of(
            new Person("张三", 18, 175)
            , new Person("李四", 22, 177)
            , new Person("张三", 14, 165)
            , new Person("李四", 15, 166)
            , new Person("张三", 19, 182)
    ).map(Person::getName).collect(Collectors.joining("_", "###", "$$$"));
    // ###张三_李四_张三_李四_张三$$$
    System.out.println(s3);
}
六、并行的Stream流 ①、串行的Stream流

介绍并行Stream流之前先介绍一下串行的Stream流,我们前面使用的Stream流都是串行,也就是在一个线程上面执行

public static void main(String[] args) {
    System.out.println(Stream.of(5, 6, 8, 3, 1, 6)
            .filter(s -> {
                System.out.println(Thread.currentThread() + "" + s);
                return s > 3;
            }).count());
}
②、并行流

parallelStream其实就是一个并行执行的流,它通过默认的ForkJoinPool,可以提高多线程任务的速 度。

Ⅰ、获取并行流

我们可以通过两种方式来获取并行流

  • 通过集合接口中的parallelStream方法来获取
  • 通过已有的串行流转换为并行流(parallel)
Ⅱ、并行流操作
public static void main(String[] args) {
    System.out.println(Stream.of(1, 4, 2, 6, 1, 5, 9)
                       // 将流转换为并发流,Stream处理的时候就会通过多线程处理
                       .parallel()
                       .filter(s -> {
                           System.out.println(Thread.currentThread() + " s=" + s);
                           return s > 2;
                       }).count());
}
Ⅲ、并行流和串行流对比

Stream并行处理的过程会分而治之,也就是将一个大的任务切分成了多个小任务,这表示每个任务都是 一个线程操作。

Ⅳ、线程安全问题
public static void main(String[] args) {
    List list = new ArrayList<>();
    for (int i = 0; i < 1000; i++) {
        list.add(i);
    }
    System.out.println(list.size());
    List listNew = new ArrayList<>();
    // 使用并行流来向集合中添加数据
    list.parallelStream()
            .forEach(listNew::add);
    System.out.println(listNew.size());
}

观察上述代码,可能会导致listNew长度小于1000或直接报ArrayIndexOutOfBoundsException,解决办法有三种:

  • 加同步锁
public static void main(String[] args) {
    List listNew = new ArrayList<>();
    Object obj = new Object();
    IntStream.rangeClosed(1, 1000)
            .parallel()
            .forEach(i -> {
                synchronized (obj) {
                    listNew.add(i);
                }
            });
    System.out.println(listNew.size());
}
  • 使用线程安全的容器
public static void main(String[] args) {
    List listNew = new ArrayList<>();
    Object obj = new Object();
    IntStream.rangeClosed(1, 1000)
            .parallel()
            .forEach(i -> {
                synchronized (obj) {
                    listNew.add(i);
                }
            });
    System.out.println(listNew.size());
}
  • 使用Stream.toArray或者collect方法操作
public static void main(String[] args) {
    List listNew = new ArrayList<>();
    Object obj = new Object();
    List list = IntStream.rangeClosed(1, 1000)
            .parallel()
            .boxed()
            .collect(Collectors.toList());
    System.out.println(list.size());
}
转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号