Stream流示例、常见生成方式及Stream中间操作方法

比眉伴天荒 2024-04-06 10:10 75阅读 0赞

**目录**

一、Stream流简单示例

二、Stream流常见生成方式

三、Stream流中间操作方法

filter代码示例：

limit&skip代码示例：

concat&distinct代码示例：

sorted代码示例：

map&mapToInt代码示例：

--------------------

## 一、Stream流简单示例 ##

需求：

按照要求集合创建和遍历

> 创建一个结合，存储多个字符串元素
> 
> 把集合中所有以"张"开头的元素存储到一个新的集合
> 
> 把"张"开头的集合中的长度为3的元素存储到一个新的集合
> 
> 遍历上一步得到集合

原始方式示例代码：

public class StreamDemo {
        public static void main(String[] args) {
            //创建一个集合，存储多个字符串元素 
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("心如音");
            list.add("流老蛋");
            list.add("王值");
            list.add("李尔");
            list.add("张新敏");
            list.add("张天坤");
    
            //把集合中所有以"张"开头的元素存储到一个新的集合 
            ArrayList<String> zhangList = new ArrayList<String>();
    
            for(String s : list) {
                if(s.startsWith("张")) {
                    zhangList.add(s);
                }
            }
    
            // System.out.println(zhangList); 
    
            //把"张"开头的集合中的长度为3的元素存储到一个新的集合 
            ArrayList<String> threeList = new ArrayList<String>();
    
            for(String s : zhangList) {
                if(s.length() == 3) {
                    threeList.add(s);
                }
            }
    
            // System.out.println(threeList); 
    
            //遍历上一步得到的集合 
            for(String s : threeList) {
                System.out.println(s);
            }
    
            System.out.println("--------");
            //Stream流来改进 
            // list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
            list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
        }
    }

使用Stream流示例代码：

public class StreamDemo {
        public static void main(String[] args) {
            //创建一个集合，存储多个字符串元素 
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("心如音");
            list.add("流老蛋");
            list.add("王值");
            list.add("李尔");
            list.add("张新敏");
            list.add("张天坤");
    
            //Stream流来改进
            list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() ==
                    3).forEach(System.out::println);
        }
    }

## 二、Stream流常见生成方式 ##

生成Stream流的方式：

> Collection体系集合
> 
> 使用默认方法stream()生成流，default Stream stream()

> Map体系集合
> 
> 把Map转成Set集合，间接生成流

> 数组
> 
> 通过Stream接口的静态方法of(T...values)生成流

代码演示：

public class StreamDemo {
        public static void main(String[] args) {
            //Collection体系的集合可以使用默认方法stream()生成流 
            List<String> list = new ArrayList<String>();
            Stream<String> listStream = list.stream();
    
            Set<String> set = new HashSet<String>();
            Stream<String> setStream = set.stream();
    
            //Map体系的集合间接的生成流 
            Map<String,Integer> map = new HashMap<String, Integer>();
            Stream<String> keyStream = map.keySet().stream();
            Stream<Integer> valueStream = map.values().stream();
            Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
    
            //数组可以通过Stream接口的静态方法of(T... values)生成流 
            String[] strArray = {"hello","world","java"};
            Stream<String> strArrayStream = Stream.of(strArray);
            Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
            Stream<Integer> intStream = Stream.of(10, 20, 30);
        }
    }

## 三、Stream流中间操作方法 ##

概念：

> 中间操作的意思是，执行完成此方法之后，Stream流依然可以继续执行其他操作

常见方法：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="width:231px;">方法名</td> 
   <td style="width:267px;">说明</td> 
  </tr> 
  <tr> 
   <td style="width:231px;"> <p style="margin-left:0;text-align:left;">Stream fifilter(Predicate predicate) </p> </td> 
   <td style="width:267px;"> 
    <div>
      用于对流中的数据进行过滤 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:231px;"> 
    <div>
      Stream limit(long maxSize) 
    </div> </td> 
   <td style="width:267px;"> 
    <div>
      返回此流中的元素组成的流，截取前指定参数个数的数据 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:231px;"> 
    <div>
      Stream skip(long n) 
    </div> </td> 
   <td style="width:267px;"> 
    <div>
      跳过指定参数个数的数据，返回由该流的剩余元素组成的流 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:231px;"> 
    <div>
      static Stream concat(Stream a, Stream b) 
    </div> </td> 
   <td style="width:267px;"> 
    <div>
      合并a和b两个流为一个流 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:231px;"> 
    <div>
      Stream distinct() 
    </div> </td> 
   <td style="width:267px;"> 
    <div>
      返回由该流的不同元素（根据Object.equals(Object) ）组成的流 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:231px;"> 
    <div>
      Stream sorted() 
    </div> </td> 
   <td style="width:267px;"> 
    <div>
      返回由此流的元素组成的流，根据自然顺序排序 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:231px;"> 
    <div>
      Stream sorted(Comparator 
    </div> 
    <div>
      comparator) 
    </div> </td> 
   <td style="width:267px;"> 
    <div>
      返回由该流的元素组成的流，根据提供的Comparator进行排序 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:231px;"> 
    <div>
      Stream map(Function mapper) 
    </div> </td> 
   <td style="width:267px;"> 
    <div>
      返回由给定函数应用于此流的元素的结果组成的流 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:231px;"> 
    <div>
      IntStream mapToInt(ToIntFunction 
    </div> 
    <div>
      mapper) 
    </div> </td> 
   <td style="width:267px;"> 
    <div>
      返回一个IntStream其中包含将给定函数应用于此流的元素的结果 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

### filter代码示例： ###

public class StreamDemo01 {
        public static void main(String[] args) {
            //创建一个集合，存储多个字符串元素 
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("心如音");
            list.add("流老蛋");
            list.add("王值");
            list.add("李尔");
            list.add("张新敏");
            list.add("张天坤");
    
            //需求1：把list集合中以张开头的元素在控制台输出 
            list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
            System.out.println("--------");
    
            //需求2：把list集合中长度为3的元素在控制台输出 
            list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
            System.out.println("--------");
    
            //需求3：把list集合中以张开头的，长度为3的元素在控制台输出 
            list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() ==
                    3).forEach(System.out::println);
        }
    }

### limit&skip代码示例： ###

public class StreamDemo02 {
        public static void main(String[] args) {
            //创建一个集合，存储多个字符串元素 
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("心如音");
            list.add("流老蛋");
            list.add("王值");
            list.add("李尔");
            list.add("张新敏");
            list.add("张天坤");
    
            //需求1：取前3个数据在控制台输出 
            list.stream().limit(3).forEach(System.out::println);
            System.out.println("--------");
    
            //需求2：跳过3个元素，把剩下的元素在控制台输出 
            list.stream().skip(3).forEach(System.out::println);
            System.out.println("--------");
    
            //需求3：跳过2个元素，把剩下的元素中前2个在控制台输出 
            list.stream().skip(2).limit(2).forEach(System.out::println);
        }
    }

### concat&distinct代码示例： ###

public class StreamDemo03 {
        public static void main(String[] args) {
            //创建一个集合，存储多个字符串元素 
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("心如音");
            list.add("流老蛋");
            list.add("王值");
            list.add("李尔");
            list.add("张新敏");
            list.add("张天坤");
    
            //需求1：取前4个数据组成一个流 
            Stream<String> s1 = list.stream().limit(4);
    
            //需求2：跳过2个数据组成一个流 
            Stream<String> s2 = list.stream().skip(2);
    
            //需求3：合并需求1和需求2得到的流，并把结果在控制台输出 
            Stream.concat(s1,s2).forEach(System.out::println); 
    
            //需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复 
            Stream.concat(s1,s2).distinct().forEach(System.out::println);
        }
    }

### sorted代码示例： ###

public class StreamDemo04 {
        public static void main(String[] args) {
            //创建一个集合，存储多个字符串元素 
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("linqingxia");
            list.add("zhangmanyu");
            list.add("wangzuxian");
            list.add("liuyan");
            list.add("zhangmin");
            list.add("zhangwuji");
    
            //需求1：按照字母顺序把数据在控制台输出 
            list.stream().sorted().forEach(System.out::println); 
    
            //需求2：按照字符串长度把数据在控制台输出 
            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);
        }
    }

### map&mapToInt代码示例： ###

public class StreamDemo05 {
        public static void main(String[] args) {
            //创建一个集合，存储多个字符串元素 
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("10");
            list.add("20");
            list.add("30");
            list.add("40");
            list.add("50");
    
            //需求：将集合中的字符串数据转换为整数之后在控制台输出 
            list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println); 
            list.stream().map(Integer::parseInt).forEach(System.out::println); 
            list.stream().mapToInt(Integer::parseInt).forEach(System.out::println); 
    
            //int sum() 返回此流中元素的总和 
            int result = list.stream().mapToInt(Integer::parseInt).sum();
            System.out.println(result);
        }
    }