Java_Stream流 - 技术栈

什么是Stream？

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

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

体验Stream流

需求：

java 复制代码

   List<String> list = new ArrayList<>();
   list.add("张无忌");
   list.add("周芷若");
   list.add("赵敏");
   list.add("张强");
   list.add("张三丰");

把集合中所有以"张"开头，且是3个字的元素存储到一个新的集合。

java 复制代码

  public class StreamList{
       public static void main(String[] args)
       {
         list<String> names = new ArrayList<>();
         Collection.addAll("张三丰","张无忌","周芷若","赵敏","张强");
         System.out.println(name);
         

         //找出姓张，且是3个字的名字，存入到新集合中去
          List<String> list = new ArrayList<>();
          for(String name:names)
          {
            if(name.startsWith("张") && name.length()==3)
             list.add(name);
             
          }
          System.out.println(list);

   //开始使用Stream流来解决这个需求
     List<String> list2 = name.stream().filter(s->s.startsWith("张")).filter(a->a.length()==3).collect(Collectors.toList());
     System.out.println(list2);

       }
  }

![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/8bf49824cfd24eb7ad5935f04ee09881.png![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/c68096f70b0f471dbc73929c4d637d0c.png)

1、获取Stream流？

获取集合的Stream流

Collection提供的如下方法	说明
default Stream stream()	获取当前集合对象的Stream流

获取数组的Stream流

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

Stream 类提供的如下方法	说明
public static Stream of(T...values)	获取当前接受数据的Stream流

java 复制代码

  public class StreamTest2{
    public static void main(String[] args)
    {
      // 1、如何获取List集合的Stream流？
        List<String> names = new ArrayList<>();
         Collection.addAll("张三丰","张无忌","周芷若","赵敏","张强");
         Stream<String> stream = names.stream();

       //2、如何获取Set集合的Stream流
       Set<String> set = new HashSet<>();
       Collections.addAll(set,"刘德华","张曼玉","蜘蛛精","玛德","德玛西亚")；
       Stream<String> stream1 = set.stream();

      //3、如何获取Map集合的Stream？
      Map<String,Double> map = new HashMap<>();
      map.put("古力娜扎",172.3);
      map.put("迪丽热巴",168.3);
      map.put("马尔扎哈",166.3);
      map.put("卡尔扎巴",168.3);
      
      Set<String> keys = map.keySet();
      Stream<String> ks = keys.stream();

      Collection<Double> values = map.values();
      Stream<Double> vs = values.stream();

      Set<Map.Entry<String,Double>> entries = map.entrySet();
      Stream<Map.Entry<String,Double>> kvs = entries.stream();
      kvs.filter(e-> e.getKey().contains("巴")).forEach(e->System.out.println(e.getKey()+"--->"+e.getValue()));
            
      //4、如何获取数组的Stream流
      String[] names2 = {"张翠山","东方不败","唐大山","独孤求败"};
      Stream<String> stream2 = Arrays.stream(names2);
      Stream<String> stream2 = Stream.of(names2);
      
        
    }
  }

2 、Stream流常见的中间方法

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

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

java 复制代码

  public class StreamTest3{
     public static void main(String[] args)
     {
        List<Double> scores = new ArrayList<>();
        Collection.addAll(scores,88.5,100.0,60.0,99.0,9.5,99.6,25.0);
        //需求1：找出成绩大于等于60分的数据，并升序后，再输出。
        socres.stream().filter(s->s>=60).sorted().forEach(s->System.out.println(s));
        

      List<Student> student = new ArrayList<>();
      Student s1 =new Student("蜘蛛精",26,172.6);
      Student s2 =new Student("蜘蛛精",26,172.6);
      Student s3 =new Student("紫霞",23,167.6);
      Student s4 =new Student("白晶晶",25,169.6);
      Student s5 =new Student("牛魔王",35,183.6);
      Student s6 =new Student("牛夫人",34,168.6);
    
      Collection.addAll(student,s1,s2,s3,s4,s5,s6);
      //需求2 找出年龄大于等于23且年龄小于等于30岁的学生，并按照年龄降序输出。
      Student.stream().filter(s-> s.getAge() >=23 && s.getAge()<=30).sorted((o1,o2)->o2.getAge()-o1.getAge()).forEach(s-> System.out.println(s));

    //需求3 取出身高最高的前三名学生，并输出。
    students.stream().sorted((o1,o2)->Double.compare(o2.getHeight()-o1.getHeight())).limit(3).forEach(System.out::println);

   //需求4:取出身高倒数的2名学生，并输出。
   
  students.stream().sorted((o1,o2)->Double.compare(o2.getHeight(),o1.getHeight())).skip(students.size（）-2).forEach(System.out::println);
  
 //需求5：找出身高超过168的学生叫什么名字，要求去重复的名字，再输出。
  students.stream().filter(s->s.getHeight()> 168)
.map(s->getName());


//distinct去重复，自定义类型对象（希望内容一样就认为重复，重写hashCode，equals）
  students.stream().filter(s->s.getHeight()>168).distinct().forEach(System.out::println); 

   Stream<String> st1 = Stream.of("张三","李四");
   
   Stream<String> st2 = Strewam.of("张三2","李四2","王五");
   Stream<String> allSt = Stream.concat(st1,st2);
   allSt.forEach(System.out::println);
     }
  }

Stream 流常见的终结方法

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

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

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

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

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

java 复制代码

  public class StreamTest4{
    public static void main(String[] args)
    {
      List<Student> students = new ArrayList<>();
      Student s1 =new Student("蜘蛛精",26,172.6);
      Student s2 =new Student("蜘蛛精",26,172.6);
      Student s3 =new Student("紫霞",23,167.6);
      Student s4 =new Student("白晶晶",25,169.6);
      Student s5 =new Student("牛魔王",35,183.6);
      Student s6 =new Student("牛夫人",34,168.6);
    
      Collection.addAll(student,s1,s2,s3,s4,s5,s6);
//需求1：请计算出身高超过168的学生有几人
    long size = students.stream().filter(s->s.getHeight()>168).count();
    System.out.println(size);

 //需求2： 请找出身高最高的学生对象，并输出。
   Student ss = students.stream().max((o1,o2)->Double.compare(o1.getHeight(),o2.getHeight())).get();
   System.out.println(ss); 
 //需求3：请找出身高最矮的学生对象，并输出。
  Student sss= student.stream().min((o1,o2)->Double.compare(o1.getHeight(),o2.getHeight())).get();
  System.out.println(sss);
  
 //需求4：请找出身高超过170的学生对象，并放到一个新集合中去返回
   students.stream().filter(a->a.getHeight()>170).collect(Collection.toList());
   System.out.println(student1);
   
  Set<Student> students2 = students.stream().filter(a->a.getHeight()>170).collect(Collectors.toSet());
  System.out.println(students2); 
 //需求5：请找出身高超过170的学生对象，并把学生对象的名字和身高，存入到一个Map集合
Map<String,Double> map =  students.stream().filter(a->a.getHeight()>170).distinct().collect(Collectors.toMap(a->a.getName(),a->getHeight()))

//Object[] arr = students.stream().filter(a->a.getHeight()>170).toArray();
Student[] arr = students.stream().filter(a->a.getHeight()>170).toArray(len->new Student[len]);
System.out.println(Arrays.toString(arr));


    }
 }