Stream流入门，Stream流创建

1、什么是Stream？

*也叫Stream流，是JDK8开始新增的一套API，可以用于操作集合或者数组的数据。

*优势：

Stream流大量结合了Lambda的语法风格来编程，提供了一种更加强大也更加简单的操作集合或者数组中的数据，代码更简洁，可读性更好

体验Stream流的优点

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

public class Stream1 {
    public static void main(String[] args) {
        List<String>list=new ArrayList<>();
        List<String>list1=new ArrayList<>();
        list.add("肖战");
        list.add("王一博");
        list.add("黄景瑜");
        list.add("王俊凯");
        list.add("易烊千玺");
        for (String s : list) {
            if (s.startsWith("王")&&s.length()==3){
                list1.add(s);
            }
        }
        System.out.println(list1);
      List<String>list2=list.stream().filter(s->s.startsWith("王")).
              filter(a->a.length()==3).collect(Collectors.toList());
        System.out.println(list2);
    }
}

Stream流的使用步骤

①数据源（集合/数组）——>获取Stream流：Stream流代表一条流水线，并能与数据源进行连接——>(过滤，排序，去重...）调用流水线的各种方法对数据进行处理——>获取结果：获取处理的结果，遍历统计收集到一个新的集合中返回。

1、获取Stream流

获取集合的Stream流

获取Collection提供的Stream流	说明
default  Stream<E>stream（）	获取当前对象的Stream流

获取数组的Stream流

Arrays类提供的如下方法	说明
public static <T> Stream<T>stream(T  [ ] array)	获取当前数组的Strweam流

Stream类提供的如下方法	说明
public static <T> Stream<T>of （ T...value）	获取当前数组的Strweam流

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

public class stream2 {
    public static void main(String[] args) {
        //如何获取list集合的Stream流
        List<String>list=new ArrayList<>();
       Collections.addAll(list,"肖战","王一博","惠英红","尔冬升","王凯");
       Stream<String>stream=list.stream();
       //如何获取Map集合的Stream流
        Map<String,Double>map=new HashMap<>();

        map.put("王健林",180.6);
        map.put("马云",167.6);
        map.put("马化腾",186.6);
        map.put("雷军",182.6);
        map.put("董明珠",168.4);
        Set<String>key=map.keySet();
       Stream<String>stream2= key.stream();
       Collection<Double>values=map.values();
        Stream<Double>stream3= values.stream();
        //如何获取Set集合的Stream流
        Set<String>set=new HashSet<>();
        Stream<String>stream1=set.stream();
        Collections.addAll(set,"肖战","王一博","惠英红","尔冬升","王凯");
        stream1.filter(s->s.contains("王")).forEach(s-> System.out.println(s));
        Set<Map.Entry<String,Double>>set1=map.entrySet();
        Stream<Map.Entry<String,Double>> stream4=set1.stream();
        stream4.filter(e->e.getKey().contains("王")).forEach(e-> System.out.println(e));

        //如何获取数组的Stream流
        String[]arr={"肖战","王一博","惠英红","尔冬升","王凯"};
        Stream<String>stream5=Arrays.stream(arr);
        Stream<String>stream6=Stream.of(arr);
        
    }
}

z、Stream流常见的中间方法

中间方法指的是调用完成后会返回新的Stream流，可以继续使用(支持链式编程)。

Stream提供的常用中间方法	说明
Stream<I>sorted()	对元素进行升序排序
Stream<T> filter(Predicate<? super T> predicate)	用于对流中的数据进行过滤。
Stream<T> limit(long maxSize)	获取前几个元素
Stream<I>sorted(Comparator<? super I>comparator)	按照指定规则排序
Stream<T>skip( long n)	跳过前几个元素
Stream<T>distinct()	去除流中重复的元素。
<R>Stream<R> map(Function<? super T,? extends R> mapper)	对元素进行加工，并返回对应的新流
static <T>Stream<T>concat(Stream a,Stream b)	合并a和b两个流为一个流

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

public class Stream3 {
    public static void main(String[] args) {
        List<Double>score=new ArrayList<>();
        Collections.addAll(score,99.9,100.0,98.9,86.6,89.3);
        //需求1:找出成绩大于等于60分的数据,并升序后，再输出
        Stream<Double>stream=score.stream();
        stream.filter(s->s>=60).sorted().forEach(s-> System.out.println(s));



        List<Student>students=new ArrayList<>();
        Student s1=new Student("肖战",23,187.6);
        Student s2=new Student("钟汉良",47,187.5);
        Student s3=new Student("王一博",27,187.6);
        Student s4=new Student("黄景瑜",32,187.3);
        Collections.addAll(students,s1,s2,s3,s4);
        //需求2:找出年龄大于等于23,且年龄小于等于30岁的学生,并按照年龄降序输出I
                students.stream();
        students.stream().filter(s->s.getAge()>=23&&s.getAge()<=30).sorted((o1,o2)->o2.getAge()-o1.getAge())
        .forEach(s-> System.out.println(s));
        //需求3:取出身高最高的前3名学生，并输出.
        students.stream().sorted((o1,o2)->Double.compare(o2.getHeight(),o1.getHeight()))
        .limit(3).forEach(s-> System.out.println(s));

        //需求4:取出身高倒数的2名学生，并输出。
        students.stream().sorted((o1,o2)->Double.compare(o1.getHeight(),o2.getHeight()))
                .limit(2).forEach(s-> System.out.println(s));
        students.stream().sorted((o1,o2)->Double.compare(o2.getHeight(),o1.getHeight()))
                .skip(students.size()-2).forEach(s-> System.out.println(s));


        //需求5:找出身高超过168的学生叫什么名字，要求去除重复的名字，再输出,
students.stream().filter(s->s.getHeight()>168).map(s->s.getName()).distinct().forEach(s-> System.out.println(s));
        Stream<String>stream1=Stream.of("张三","王五");
        Stream<String>stream2=Stream.of("张三1","王五1","李四1");
        Stream<String>allSet=Stream.concat(stream1,stream2);
        allSet.forEach(s-> System.out.println(s));
    }
}

3、Stream流常见的终结方法

终结方法指的是调用完成后，不会返回新Stream了，没法继续使用流了。

Stream提供的常用终结方法	说明
void forEach(Consumer action)	对此流运算后的元素执行遍历
long count()	统计此流运算后的元素个数
Optional<I>max(Comparator<? super Icomparator)	获取此流运算后的最大值元素
Optional<I>min(Comparator<?super Icomparator)	获取此流运算后的最小值元素

3、Stream流常见的终结方法

收集Stream流:

就是把Stream流操作后的结果转回到集合或者数组中去返回。

Stream流:

方便操作集合/数组的手段;集合/数组:才是开发中的目的。

Stream提供的常用终结方法	说明
R collect(Collector collector)	把流处理后的结果收集到一个指定的集合中去
object[] toArray()	把流处理后的结果收集到一个数组中去

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

public class Stream4 {
    public static void main(String[] args) {


     List<Student> students=new ArrayList<>();
      Student s1=new Student("蜘蛛精",26, 172.5);
      Student s2=new Student("蜘妹精", 26, 172.5);
      Student s3=new Student("紫霞",23,167.60);
      Student s4=new Student("白品品",25,169.0);
      Student  s5=new Student("牛庞王",35, 183.3);
       Student s6=new Student("牛夫人",34, 168.5);
      Collections.addAll(students,s1,s2,s3,s4,s5,s6);
      long count=students.stream().filter(s->s.getHeight()>168).count();
      //需求1:请计算出身高超过168的学生有几人.

        //需求2:请找出身高最高的学生对象，并输出。
Student student=students.stream().max((o1, o2) -> Double.compare(o2.getHeight(),o1.getHeight())).get();
     System.out.println(student);
     //需求3:请找出身高最矮的学生对象，并输出。
     Student student1=students.stream().min((o1, o2) -> Double.compare(o2.getHeight(),o1.getHeight())).get();
     System.out.println(student1);
     //需求4:请找出身高超过170的学生对象，并放到一个新集合中去返回。
     //流只能收集一次
    List<Student>students1= students.stream().filter(s->s.getHeight()>170).collect(Collectors.toList());
     System.out.println(students1);
     //需求5:请找出身高超过170的学生对象，并把学生对象的名字和身高，存入到一个Map集合返回。
Map<String,Double>map=students.stream().filter(s->s.getHeight()>170).collect(Collectors.toMap(a->a.getName(), b->b.getHeight()));
     System.out.println(map);
     //Object[] arr=students.stream().filter(s->s.getHeight()>175).toArray();
     Student[] arr1=students.stream().filter(s->s.getHeight()>175).toArray(Student[]::new);
     System.out.println(Arrays.toString(arr1));
    }
}