Stream流使用

UUID.

已于 2024-08-21 11:30:51 修改

阅读量310

点赞数

分类专栏： Stram 文章标签： stream

于 2020-12-06 17:15:05 首次发布

本文链接：https://blog.csdn.net/orange_yoo/article/details/110747706

版权

Stram 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文深入探讨了Java Stream API的使用，包括如何创建流、中间操作和终端操作的实践，以及并行流和收集器的应用，旨在提升代码的简洁性和效率。

摘要由CSDN通过智能技术生成

package com.cy.test;

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

public class StreamTest2 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张就是吊");
        list.add("就是吊");
        list.add("吊");
        list.add("张就吊");
        list.add("是吊");

        list.stream().forEach(System.out::println);
        System.out.println("--------------------------------");

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

        long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count);
        System.out.println("--------------------------------");
        //前三个元素
        list.stream().limit(2).forEach(System.out::println);
        System.out.println("--------------------------------");

        //跳过前两个元素
        list.stream().skip(2).forEach(System.out::println);
        System.out.println("--------------------------------");

        //跳过前两个元素 输出剩下的前一个
        list.stream().skip(2).limit(2).forEach(System.out::println);

        System.out.println("--------------------------------");

        Stream<String> l2 = list.stream().limit(2);
        Stream<String> s2 = list.stream().skip(1);

        //合并
        //Stream.concat(l2,s2).forEach(System.out::println);
        System.out.println("--------------------------------");

        //合并不能重复
        Stream.concat(l2,s2).distinct().forEach(System.out::println);
        System.out.println("--------------------------------");


        List<String> list2=new ArrayList<>();
        list2.add("zzasdvd");
        list2.add("Asfdds");
        list2.add("sdafgc");
        list2.add("bsadfs");
        list2.add("wefc");
        list2.add("asdfb");

        //按照自然顺序排序
        list2.stream().sorted().forEach(System.out::println);
        System.out.println("--------------------------------");

        //按照字符串长度
        list2.stream().sorted((str1,str2)->str1.length()-str2.length()).forEach(System.out::println);

        System.out.println("--------------------------------");

        //按照字符串长度 并且按照自然顺序
        list2.stream().sorted((str1,str2)->{
            int num=str1.length()-str2.length();
            int num2=num==0?str1.compareTo(str2):num;
            return num2;
        }).forEach(System.out::println);
        System.out.println("--------------------------------");


        List<String> list3=new ArrayList<>();
        list3.add("111");
        list3.add("555");
        list3.add("777");
        list3.add("88");
        list3.add("66");


        list3.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        list3.stream().map(Integer::parseInt).forEach(System.out::println);
        System.out.println("--------------------------------");


        list3.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        System.out.println("--------------------------------");


        int sum = list3.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);
        System.out.println("--------------------------------");

        //名字为三个字的 转换为另一个集合
        Stream<String> stringStream = list.stream().filter(s -> s.length() == 3);
        stringStream.collect(Collectors.toList()).forEach(System.out::println);
        System.out.println("--------------------------------");

        //数字大于并转换为另一个集合
        Set<String> set=new HashSet<>();
        set.add("111");
        set.add("555");
        set.add("777");
        set.add("88");
        set.add("66");

        set.stream().map(s -> Integer.parseInt(s)).filter(i -> i>100).collect(Collectors.toSet()).forEach(System.out::println);
        System.out.println("--------------------------------");



        String[] strings={"大宝,20","真宝,50","中宝,50","老宝,80","小宝,10"};
        //字符串中大于的数转为集合
        //先把字符串数组转为流
        Stream<String> age = Stream.of(strings).filter(s -> Integer.parseInt(s.split(",")[1]) > 48);

        //符合条件的流 把流转为map集合
        Map<String, Integer> map = age.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
    }
}


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

/**
 * stream流测试
 * collection 集合生成stream流
 * map  间接生成sream流 使用set   map.values()
 * 数组 使用stream的静态方法来调用
 * 转为 lsit  tolist
 * 转为map  tomap 
 * 
 */
public class StreamTest {
  public static void main(String[] args) {

List<Integer> list=new ArrayList<>();
        Stream<Integer> stream = list.stream();

        Set<Integer> set=new HashSet<>();
        Stream<Integer> stream1 = set.stream();

        Map<String ,Integer>map=new HashMap<>();
        //键对应的流
        Stream<String> KeyStream = map.keySet().stream();
        //值对应的流
        Stream<Integer> ValueStream = map.values().stream();
        //键值对 对象对应的流
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

        //数组可以通过stream接口的静态方法of 生成流
         int[] arr={4,56416,541,321,31,5};
         String[] str={"hello","world"};
         
        Stream<int[]> arr1 = Stream.of(arr);

        Stream<String> str1 = Stream.of(str);





    List<String> strings = new ArrayList<>();
    Stream<String> stream = strings.stream();

    Set<String> strings1 = new HashSet<>();
    Stream<String> stream1 = strings1.stream();

    Map<String, Integer> map = new HashMap<>();
    Set<String> set = map.keySet();
    //第一种
    Stream<String> stream2 = set.stream();
    //第二种
    Stream<Integer> stream3 = map.values().stream();
    //第三种
    Stream<Map.Entry<String, Integer>> stream4 = map.entrySet().stream();

    String[] strArr = {"sdfsd", "sdfsd", "sdfsd", "sdfsd", "sdfsd", "sdfsd"};
    //静态方法
    Stream<String> strArr1 = Stream.of(strArr);


    ArrayList<String> list = new ArrayList<>();
    list.add("演出");
    list.add("俄国");
    list.add("黄瓜");
    list.add("饿了他");
    list.add("破肚皮");
    list.add("破皮");
    list.add("破皮");
    list.add("破肚皮到时候");
    list.add("破皮阿");

    ArrayList<String> test = new ArrayList<>();

    for (String s : list) {
      if (s.startsWith("饿")) {
        test.add(s);
      }
    }
    System.out.println(test);
    System.out.println("---------");
    //stream流来简化输出
    list.stream().filter((String s) -> {
      return s.startsWith("破");
    }).filter((String s) -> {
      return s.length() == 3;
    }).forEach((String s) -> {
      System.out.println(s);
    });

    //stream流的使用
    //指定开头数据输出
    list.stream().filter((String s) -> {
      return s.startsWith("破");
    }).forEach(System.out::println);
    System.out.println("-----------------------");

    //指定长度输出
    list.stream().filter((String s) -> {
      return s.length() > 3;
    }).forEach(System.out::println);
    System.out.println("-----------------------");

    //指定开头 长度输出
    list.stream().filter((String s) -> {
      return s.startsWith("破");
    }).filter((String s) -> {
      return s.length() == 3;
    }).forEach(System.out::println);
    System.out.println("-----------------------");

    //取指定长度数据输出  前几
    list.stream().limit(3).forEach(System.out::println);
    System.out.println("-----------------------");

    //跳过指定个数 输出剩下元素
    list.stream().skip(3).forEach(System.out::println);
    System.out.println("-----------------------");

    //跳过指定个数 输出前几元素
    list.stream().skip(3).limit(2).forEach(System.out::println);
    System.out.println("-----------------------");

    Stream<String> limit = list.stream().limit(2);
    Stream<String> skip = list.stream().skip(4);

    //合并流
//    Stream.concat(limit, skip).forEach(System.out::println);
    //去除相同元素
    Stream.concat(limit, skip).distinct().forEach(System.out::println);
    System.out.println("-----------------------");

    //排序
    list.stream().sorted().forEach(System.out::println);
    System.out.println("-----------------------");
    //比较器
//    list.stream().sorted((s1, s2) -> {
//      return s2.length() - s1.length();
//    }).forEach(System.out::println);
    list.stream().sorted((s1, s2) -> {
      int num = s1.length() - s2.length();
      int num2 = num == 0 ? s1.compareTo(s2) : num;
      return num2;
    }).forEach(System.out::println);
    System.out.println("-----------------------");

    List<String> list1 = new ArrayList<>();
    list1.add("12");
    list1.add("87");
    list1.add("878875");
    list1.add("57546");
    list1.add("87878");
    list1.add("87987874");

    //map（function<> ）
    list1.stream().map((String s) -> {
      return Integer.parseInt(s);
    }).forEach(System.out::println);
    System.out.println("-----------------------");

    list1.stream().mapToInt((String s) -> {
      return Integer.parseInt(s);
    }).forEach(System.out::println);
    System.out.println("-----------------------");

    int sum = list1.stream().mapToInt((String s) -> {
      return Integer.parseInt(s);
    }).sum();
    System.out.println(sum);
    System.out.println("-----------------------");

    list1.stream().forEach(System.out::println);
    System.out.println("-----------------------");

    long count = list.stream().filter((String s) -> {
      return s.startsWith("破");
    }).count();
    System.out.println(count);
    System.out.println("-----------------------");

    //把过滤的数据转为另一个list集合
    List<String> collects = list.stream().filter((String s) -> {
      return s.length() == 3;
    }).collect(Collectors.toList());
    for (String collect : collects) {
      System.out.println(collect);
    }
    System.out.println("-----------------------");

    Set<Integer> set1 = list1.stream().map((String s) -> {
      return Integer.parseInt(s);
    }).filter((Integer i) -> {
      return i > 666;
    }).collect(Collectors.toSet());

    for (Integer integer : set1) {
      System.out.println(integer);
    }
    System.out.println("-----------------------");

    String[] strArra = {"阳仔,25", "欧罗,87", "供货商,54", "阿斯,8", "阿斯蒂芬,87", "沙发,15"};
    //把字符串数组转换为流
    Stream<String> stream5 = Stream.of(strArra).filter((String s) -> {
      return Integer.parseInt(s.split(",")[1]) > 30;
    });
    // stream5.forEach((System.out::println)); //这里使用 下面流就使用不了创建流只可以使用一次
    System.out.println("-----------------------");

    //收集操作
    //得到的数据转为map集合
    Map<String, Integer> map1 = stream5.collect(Collectors.toMap((String s) -> {
      return s.split(",")[0];
    }, (String s) -> {
      return Integer.parseInt(s.split(",")[1]);
    }));

    Set<String> keySet = map1.keySet();
    for (String key : keySet) {
      int value = map1.get(key);
      System.out.println(key + "..." + value);
    }
    System.out.println("-----------------------");
  }
}