Stream流详细教学-一篇足够

已于 2023-07-07 13:54:42 修改
阅读量679 收藏 2
点赞数
文章标签： java
于 2023-06-14 10:31:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46570170/article/details/131202579
版权

Stream流学习

初识Stream

背景要求

image-20230612200244187

  • 传统代码实现

    public class Stream01 {

    @Test
    public void test04() {
        /**
         *  ArrayList<String> list = new ArrayList<>();
         *  把所有的张姓 存储到新集合中
         *  并且要求名字长度为3
         *  打印遍历
         */

        List<String> strings = Arrays.asList("张三芳", "张无忌", "周芷若", "赵敏");

        ArrayList<String> list1 = new ArrayList<>();
        // 首先取出来 名字姓为张的
        for (String name : strings) {
            if (name.startsWith("张")){
                list1.add(name);
            }
        }
        // 再取出来长度为3的
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if (s.length()==3) {
                list2.add(s);
            }
        }
        System.out.println("list2 = " + list2);
    }

    这样太繁琐了,也是很啰嗦 接下来看一下stream .

  • stream流实现

    /**
 * @author ShaoCong Lu
 * @date 2023/6/12 19:46
 */
public class Stream01 {

    @Test
    public void test04() {
        /**
         *  ArrayList<String> list = new ArrayList<>();
         *  把所有的张姓 存储到新集合中
         *  并且要求名字长度为3
         *  打印遍历
         */

        List<String> strings = Arrays.asList("张三芳", "张无忌", "周芷若", "赵敏");
        List<String> list = strings.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("张");

            }
        }).filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() == 3;
            }
        }).collect(Collectors.toList());

        for (String s : list) {
            System.out.println("s = " + s);
        }

        // 或者  这样一行
        System.out.println("======================");
        strings.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);


    }
}

四种获取stream流

image-20230612202412728

  1. 双列集合首先获取keySet 或者entrySet
  2. 数组使用Arrays工具类中的方法
  3. 零散数据 必须是同种类型的数据

使用以上四种方式创建一个stream流

  • 单列集合

    @Test
public void test02() {
    // 使用第一种方法 单列集合
    ArrayList<String> strings = new ArrayList<>();
    Collections.addAll(strings,"路","哈","流","是");

    Stream<String> stream = strings.stream(); // 获取stream
    stream.forEach(s -> System.out.println(s)); // s 代表这条流水线的每一个元素 打印完事 , forEach是终结方法 

}

  • 双列集合 比如map

    @Test
public void test03() {
    // 双列集合
    HashMap<String, Integer> map = new HashMap<>();
    map.put("001",1);
    map.put("002",2);
    map.put("003",3);

    // 获取Set集合
    map.keySet().stream().forEach(s -> System.out.println(s)); // 获取所有的key 并且全部打印出来
    map.values().stream().forEach(System.out::println); // 获取所有的values 并且打印出来
    map.entrySet().stream().forEach(System.out::println); // 获取到所有的entry 键值对 并且都打印出来

}

  • 组数

    @Test
public void test05() {
    // 数组
    int arr[] = {1,2,3,4};

    Arrays.stream(arr).forEach(System.out::println);
}

  • 零散数据

    @Test
public void test06() {
    // 零散数据 必须是同种类型的数据
    Stream<String> stream = Stream.of("a", "k", "p");
    stream.forEach(s -> System.out.println(s));
}

Stream中间方法

image-20230612210117849

filter过滤方法

@Test
public void test07() {
    // filter 方法 过滤 1
    ArrayList<String> list = new ArrayList<>();
    Collections.addAll(list,"张无忌-15","周芷若-14","赵敏-13","张强-20","张三丰-100","张深山-40","张良-35","王二麻子-37");

    // 1. 要求 需要 张
    List<String> list1 = list.stream().filter(s -> s.startsWith("张")).collect(Collectors.toList());

    //2.  要求 需要 张并且名字为三位数
    List<String> list2 = list.stream().filter(s -> s.split("-")[0].length() == 3).collect(Collectors.toList());

    System.out.println("list1 = " + list1);
    System.out.println("list2 = " + list2);
    /**
         * list1 = [张无忌-15, 张强-20, 张三丰-100, 张深山-40, 张良-35]
         * list2 = [张无忌-15, 周芷若-14, 张三丰-100, 张深山-40]
         */
}


@Test
public void testMap02() {
    HashMap<Integer, Emp> empHashMap = new HashMap<>();

    empHashMap.put(1,new Emp("路",1,30000.0));
    empHashMap.put(2,new Emp("刘",5,8000.0));
    empHashMap.put(3,new Emp("郑",3,10000.0));
    empHashMap.put(4,new Emp("王",4,18520.0));

    // 要求 输出大于一万八的
    Set<Integer> keySet = empHashMap.keySet();
    for (Integer integer : keySet) {
        if (getEmp(empHashMap, integer).getMoy()>18000) {
            System.out.println("empHashMap = " + getEmp(empHashMap, integer));
        }
    }

    // stream流
    List<Map.Entry<Integer, Emp>> entryList = empHashMap
        .entrySet().stream().filter(entry -> entry.getValue().getMoy() > 18000).collect(Collectors.toList());

    for (Map.Entry<Integer, Emp> entry : entryList) {
        System.out.println("entry = " + entry);
    }

}

private Emp getEmp(HashMap<Integer, Emp> empHashMap, Integer integer) {
    return empHashMap.get(integer);
}

@Data@AllArgsConstructor@NoArgsConstructor
class Emp{
 private String name;
 private int empId;
 private Double moy;
}

limit 获取前几个元素

@Test
public void test08() {
    // limit 获取前几个元素
    ArrayList<String> list = new ArrayList<>();
    Collections.addAll(list,"张无忌-15","周芷若-14","赵敏-13","张强-20","张三丰-100","张深山-40","张良-35","王二麻子-37");

    //       获取前三个元素
    List<String> collect = list.stream().limit(3).collect(Collectors.toList());
    for (String s : collect) {
        System.out.println("s = " + s);
    }
}

skip方法 ,跳过前几个元素

@Test
public void test09() {
    // skit 跳过前几个元素
    ArrayList<String> list = new ArrayList<>();
    Collections.addAll(list,"张无忌-15","周芷若-14","赵敏-13","张强-20","张三丰-100","张深山-40","张良-35","王二麻子-37");

    for (String s : list.stream().skip(5).collect(Collectors.toList())) {
        System.out.println("s = " + s);
    }
}

distinct 去重

@Test
public void test10() {
    // distinct 去重
    ArrayList<String> list = new ArrayList<>();
    Collections.addAll(list,"张无忌-15","周芷若-14","赵敏-13","张强-20","张三丰-100","张深山-40","张良-35","王二麻子-37");

    List<String> collect = list.stream().distinct().collect(Collectors.toList());
}

concat 合并流

@Test
public void test11() {
    // concat 合并流
    ArrayList<String> list = new ArrayList<>();
    Collections.addAll(list,"张无忌-15","周芷若-14","赵敏-13","张强-20","张三丰-100","张深山-40","张良-35","王二麻子-37");

    ArrayList<String> list2 = new ArrayList<>();
    Collections.addAll(list2,"张良-35555","王二麻子-375555");

    Stream.concat(list.stream(),list2.stream()).forEach(System.out::println);
}

map 比较难得一个 转换

@Test
public void test12() {
    // map 转换
    ArrayList<String> list = new ArrayList<>();
    Collections.addAll(list,"张无忌-15","周芷若-14","赵敏-13","张强-20","张三丰-100","张深山-40","张良-35","王二麻子-37");

    // 需求 要求只要年龄 并且年龄大与15岁
    list.stream()
        .map(s -> Integer.parseInt(s.split("-")[1])).filter(integer -> integer >15)
        .forEach(System.out::println);

}

排序 sorted

@Test
public void TestList04() {
    /**
         * 2 定制排序
         *  sorted(Comparator com)：定制排序，自定义Comparator排序器
         * 3 升序
         * 3.1 自然排序
         * list = list.stream().sorted().collect(Collectors.toList());
         * 3.2 定制排序
         * 根据年龄升序排序。
         * list = list.stream().sorted(Comparator.comparing(Student::getAge)).collect(Collectors.toList());
         * 4 降序
         * 4.1 自然排序
         * 使用Comparator 提供的reverseOrder() 方法
         * list = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
         * 4.2 定制排序
         * 根据年龄降序排序。
         * list = list.stream().sorted(Comparator.comparing(Student::getAge).reversed()).collect(Collectors.toList());
         * 5 多字段排序
         * list = list.sorted(Comparator.comparing(Student::getName).thenComparing(Student::getAge)).collect(Collectors.toList());
         */
    ArrayList<Book> arrayList = new ArrayList<>();

    arrayList.add(new Book("红楼梦",100,"曹雪芹"));
    arrayList.add(new Book("三国志",99,"罗贯中"));
    arrayList.add(new Book("水浒传",101,"施耐庵"));
    arrayList.add(new Book("西游记",1020,"吴承恩"));

    //按照价格排序 降序
    List<Book> list = arrayList.stream().sorted(new Comparator<Book>() {
        @Override
        public int compare(Book o1, Book o2) {

            //  return o1.getPrice() - o2.getPrice(); // 降序
            return o2.getPrice() - o1.getPrice(); //升序

        }
    }).collect(Collectors.toList());

    for (Book book : list) {
        System.out.println("book = " + book);
    }

// 默认是升序
    ArrayList<Integer> arrayList = new ArrayList<>();

    arrayList.add(1);
    arrayList.add(2);
    arrayList.add(5);
    arrayList.add(3);

    arrayList.stream().sorted().forEach(System.out::println);
     arrayList.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println); // 降序


}

Stream终结方法

image-20230613092503552

这种终结方法后面都是返回值 要不然就是一个集合 要不然就是一个数组类型,或者void 中间方法返回的永远是Stream

image-20230613130231640

forEach遍历

@Test
public void test14() {
    // 排序
    ArrayList<Integer> arrayList = new ArrayList<>();

    arrayList.add(1);
    arrayList.add(2);
    arrayList.add(5);
    arrayList.add(3);

    arrayList.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println); // 降序
}

count统计

@Test
public void test15() {
    // 排序
    ArrayList<Integer> arrayList = new ArrayList<>();

    arrayList.add(1);
    arrayList.add(2);
    arrayList.add(5);
    arrayList.add(3);

    System.out.println("arrayList.stream().count() = " + arrayList.stream().count());
}

toArray方法 放到数组中

@Test
public void test16() {
    // 排序
    ArrayList<Integer> arrayList = new ArrayList<>();

    arrayList.add(1);
    arrayList.add(2);
    arrayList.add(5);
    arrayList.add(3);

    // 解释 Integer[] 这个是返回值类型数组,我们需要Integer类型 value是数组中的个数 
    // 返回值new Integer[value]; 直接及时new一个数组 并且个数就是value
    Integer[] toArray = arrayList.stream().toArray(new IntFunction<Integer[]>() {
        @Override
        public Integer[] apply(int value) {
            return new Integer[value];
        }
    });
    
    // 改成拉姆达表达式形式
    Integer[] array = arrayList.stream().toArray(value -> new Integer[value]);
    Integer[] array1 = arrayList.stream().toArray(Integer[]::new);
    
     System.out.println(Arrays.toString(array1));


    ArrayList<String> strings = new ArrayList<>();
    strings.add("p");
    strings.add("u");
    strings.add("o");
    Object[] toArray1 = strings.stream().toArray();
    System.out.println(Arrays.toString(toArray1)); //[p, u, o]
}

三种收集方法

@Test
public void test17() {

    ArrayList<String> arrayList = new ArrayList<>();
    Collections.addAll(arrayList,"张无忌-男-15","周芷若-女-14","赵敏-女-13","张强-男-20",
                       "张三丰-男-109","张翠山-男-40","张良-男-35","王二麻子-男-37","谢广坤-男-41");

    // 要求 把所有的男性， 收集

    // 1. 收集为list

    List<String> list = arrayList.stream().filter(s -> "男".equals(s.split("-")[1]))
        .collect(Collectors.toList());

    System.out.println("list = " + list);

    // 2. 收集为set

    Set<String> set = arrayList.stream().filter(s -> "男".equals(s.split("-")[1]))
        .collect(Collectors.toSet());
    System.out.println("set = " + set); // 可以去除重复的

    // 3. 收集为map 键 为姓名 值 为年龄  "张无忌-男-15"

    Map<String, Integer> map = arrayList.stream().filter(s -> "男".equals(s.split("-")[1]))
        .collect(Collectors.toMap(
            s -> s.split("-")[0], // 规定键
            s -> Integer.parseInt(s.split("-")[2]) // 规定
        ));
    System.out.println("map = " + map);
}
哈哈之王
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Stream流的学习
weixin_61407147的博客
07-03 497
Stream流
Java-IO流/Stream流总结
07-12
Java-IO流/Stream流总结，内容一针见血，没有废话，言简意赅 内容：IO流及其分类、分类比较、转换流、缓存流、IO流异常处理、Stream流、Properties教程等。 适合人群：有编程基础及Java基础伙伴 适用场景：Java中的...
stream-learn:stream-learn 是一个用于困难数据流分析的开源 Python 库
05-29
stream-learn模块是一组使用scikit-learn估计器处理数据流所必需的工具。 这里使用批处理方法，其中数据集以更小的连续子集传递给分类器，称为chunks 。 该模块包含五个子模块： - 包含一个数据流生成器，它允许...
Stream-Video-Downloader-9.2.12.rar
09-01
Stream-Video-Downloader-9.2.12
Stream-Video-Downloader-10.0.2.crx 下载
09-01
Stream-Video-Downloader-10.0.2.crx
Stream-Video-Downloader-9.2.3.crx
09-01
Stream-Video-Downloader-9.2.3
Stream流学习
weixin_44863780的博客
10-30 327
Stream是什么 Stream呢，很多地方说到它是处理集合的关键抽象概念，这样子说实在是太抽象了。这个Stream并不是我们以前认识的IO流，而是一个数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。集合专注的是数据，流专注的是计算。 有什么用 它可以让你对集合执行非常复杂的查找、过滤和映射数据等操作。通过使用Stream API对集合数据进行操作，就类似于使用 SQL 执行的数据库查询，也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处
学习Stream流
m0_54083247的博客
03-21 111
Stream流的使用
Stream流简单学习
qq_53759832的博客
04-18 125
public static void main(String[] args) { //获取到stream流的每一个元素 Stream.of("xiaotian", "xiaohu", "ming", "gala") .forEach(name-> System.out.println(name));//xiaotian xiaohu ming gala System.out.println("--------------.
javaStream流学习
堂堂百星王者
10-25 581
Stream流 Java8 API添加了一个新的抽象称为流 Stream ，可以让 你以一种声明的方式处理数据。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直 观方式来提供一种对 Java 集合运算和表达的高阶抽 象。Stream API可以极大提高Java程序员的生产力，让 程序员写出高效率、干净、简洁的代码。这种风格将要 处理的元素集合看作一种流， 流在管道中传输， 并且可 以在管道的节点上进行处理， 比如筛选， 排序，聚合 等。 元素流在管道中经过中间操作（intermediate
《Stream流的学习与使用》
x-dragon8899的博客
10-18 611
Java8新特性-Stream流
stream流的学习笔记
qq_40905441的博客
12-01 337
创建stream流对象 使用stream中的静态方法of（将数组转成stream） public static<T> Stream<T> of(T... values) collection接口中的stream方法 default Stream<E> stream() stream中的的方法 延迟方法 总结方法 ...
jdk 1.8 新特性之——stream流的学习
xdkb159的博客
02-08 490
1、流的特点 流只能遍历一次，流中的元素向流水线一样经过一个或多个中间操作，最后执行终端操作，完成流的遍历。 流采用内部迭代。 2.流的操作 类型 中间操作—— 返回一个stream，同一个stream可以进行多个中间操作。 filter：过滤操作，filter函数接收一个Lambda表达式作为参数，该表达式返回boolean； map：转换操作，map函数将stream的元素转换成另一种类型输出； ...
stream流详细介绍
最新发布
07-21
可以使用Java 8中的Stream流来对BigDecimal进行求和操作。具体步骤如下： 1. 将BigDecimal对象存储在一个List集合中。 2. 使用Stream流的map方法将BigDecimal对象转换为double类型。 3. 使用Stream流的reduce方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值