Stream流的初步了解

Stream流初步了解

---

---

前言

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、Stream流式思想

当需要对多个元素进行操作的时候，考虑到性能及便利性，我们应该首先拼好一个模型不走方案，然后再按照方案去执行它。
Stream是一个来自数据源的元素队列。
元素是特定类型的对象，形成一个队列，java中的Stream并不会存储元素，而是按需计算。例如一个生产线，我们只需要在不同的环节对产品做出不同的操作即可，而不需要对其进行保存。
数据源是流的来源，可以是集合，数组等。

---

特点：
stream流是一个管道流，只能被消费（使用）一次，
第一个stream流使用完毕后，会自动流转到下一个stream流中，
而第一个stream流已经关闭，无法再调用方法。

---

下面是一个简化案例，用stream取代for循环

/*
   相对于for循环，stream流对数据进行过滤，专注于做什么，而不是怎么做
   并不会存储数据，而是仅仅对数据进行操作计算
   使代码更简洁优雅
*/
import java.util.ArrayList;
import java.util.List;

public class Demo01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王二");
        list.add("张五六");
        list.add("张七八");
        //目的:1、筛选出姓张的人
        //    2、姓张且三个字
        //    3、输出
        list.stream()
                .filter(name->name.startsWith("张"))
                .filter(name->name.length()==3)
                .forEach(name-> System.out.println(name));
    }
}

二、获取流

两种方法获取流：

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

/*
  1、所有的collection集合都可以通过stream默认方法获取流
    defult Stream<E> stream();

  2、 Stream接口的静态方法of可以获取数组对应的流
     static<T> Stream<T> of (T...values);
     参数为可变参数，所以我们可以传递数组
*/
public class Demo02 {
    public static void main(String[] args) {
         //集合转化为stream流
        List<String> list=new ArrayList<>();
        Stream<String> stream = list.stream();

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

          //将键存入set集合中，将set集合转化为stream流
        Map<Integer,String> map=new HashMap<>();
        Set<Integer> set1=map.keySet();
        Stream<Integer> stream2 = set1.stream();

          //将值存入collection集合中，将collection集合转化为stream流
        Collection<String> values = map.values();
        Stream<String> stream3 = values.stream();

          //获取键值对
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        Stream<Map.Entry<Integer, String>> stream4 = entries.stream();

        //把数组转化为stream流
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4);
        int[]arr={1,2,3};
        Stream<int[]> arr1 = Stream.of(arr);
    }


}

常用方法

延迟方法：返回值还是stream接口自身类型的方法，支持链式调用（除终结方法以外都是延迟方法）。
终结方法：返回值类型不再是stream接口自身类型的方法，不支持链式调用，（count、forEach方法）。

forEach方法

void forEach(Consumer<? super T> action);​ 该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。
​ Consumer接口是一个消费型的函数式接口,可以传递Lambda表达式,消费数据.
简单记:
​ forEach方法,用来遍历流中的数据
​ 是一个终结方法,遍历之后就不能继续调用Stream流中的其他方法
`

import java.util.stream.Stream;

public class forEach {
    public static void main(String[] args) {
                //获取一个Stream流
                Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六", "田七");
                //使用Stream流中的方法forEach对Stream流中的数据进行遍历
                 stream.forEach((String name)->{ 
                     System.out.println(name);
                });           

    }
}

filter方法

Stream流中的常用方法_filter:用于对Stream流中的数据进行过滤
Stream filter(Predicate<? super T> predicate); filter方法的参数Predicate是一个函数式接口,所以可以传递Lambda表达式,对数据进行过滤
​ Predicate中的抽象方法: boolean test(T t);

import java.util.stream.Stream;

public class filter {
    public static void main(String[] args) {
        //创建一个Stream流
        Stream<String> stream = Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌");
        //对Stream流中的元素进行过滤,只要姓张的人
        Stream<String> stream2 = stream.filter((String name)->{return name.startsWith("张");});
        //遍历stream2流
        stream2.forEach(name-> System.out.println(name));
        /*
            Stream流属于管道流,只能被消费(使用)一次
            第一个Stream流调用完毕方法,数据就会流转到下一个Stream上
            而这时第一个Stream流已经使用完毕,就会关闭了
            所以第一个Stream流就不能再调用方法了
            IllegalStateException: stream has already been operated upon or closed
         */
        //遍历stream流
        stream.forEach(name-> System.out.println(name));

    }
}

map方法

如果需要将流中的元素映射到另一个流中，可以使用map方法.
Stream map(Function<? super T, ? extends R> mapper);
该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
​ Function中的抽象方法:R apply(T t);

import java.util.stream.Stream;

/*
     如果需要将流中的元素映射到另一个流中，可以使用map方法.
          <R> Stream<R> map(Function<? super T, ? extends R> mapper);
     该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
​          Function中的抽象方法:R apply(T t);
 */
public class map {
    public static void main(String[] args) {
        Stream<String> stringStream = Stream.of("1", "2", "3", "4");
        Stream<Integer> integerStream = stringStream.map((String s) -> {
            return Integer.parseInt(s);
        });
        integerStream.forEach(i->{
            System.out.println(i);
        });
    }

count方法

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

public class count方法 {
    public static void main(String[] args) {
        List<Integer>list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}

limit方法

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

public class limit {
    public static void main(String[] args) {
        String [] str={"彭于晏","徐瑞航","吴彦祖","刘宪华"};
        Stream<String> str1 = Stream.of(str);
        Stream<String> limit = str1.limit(3);
        limit.forEach(i-> System.out.println(i));

    }

}

skip方法

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

public class limit {
    public static void main(String[] args) {
        String [] str={"彭于晏","徐瑞航","吴彦祖","刘宪华"};
        Stream<String> str1 = Stream.of(str);
       // Stream<String> limit = str1.limit(3);
      //  limit.forEach(i-> System.out.println(i));
        Stream<String> skip = str1.skip(2);
        skip.forEach(i-> System.out.println(i));
    }

}

concat方法

Stream流中的常用方法_concat:用于把流组合到一起
如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat

import java.util.stream.Stream;

public class concat {
    public static void main(String[] args) {
        String [] str={"彭于晏","徐瑞航","吴彦祖","刘宪华"};
        Stream<String> str1 = Stream.of(str);

        String [] str3={"郭富城","刘亦菲"};
        Stream<String> str2 = Stream.of(str3);

        Stream<String> concat = Stream.concat(str1, str2);
        concat.forEach(i-> System.out.println(i));
    }
}