生成流

  • 通过数据源（集合，数组等）生成流
  • Stream流的常见生成方式：
    • Collection体系的集合可以使用默认方法stream()生成流，default Stream stream() 。
    • Map体系的集合间接生成流
    • 数组可以通过Stream接口的静态方法of(T… values)生成流 ```java import java.util.*; import java.util.stream.Stream;

public class Demo { public static void main(String[] args) { List list = new ArrayList<>() ; Stream listStream = list.stream() ;

  1.     Set<String> set = new HashSet<>() ;
  2.     Stream<String> setStream = set.stream() ;
  4.     Map<String,Integer> map = new HashMap<>() ;
  5.     Stream<String> mapKeyStream = map.keySet().stream() ;
  6.     Stream<Integer> mapValueStream = map.values().stream() ;
  8.     Stream<Map.Entry<String,Integer>> entryStream = map.entrySet().stream() ;
  10.     String[] strArray = {"hello","world","java"} ;
  11.     Stream<String> strArrayStream = Stream.of(strArray) ;
  12.     Stream<String> strArrayStream2 = Stream.of("hello","world","java") ;
  13.     Stream<Integer> strArrayStream3 = Stream.of(10,20,30) ;
  14. }

}

  1. <a name="oSWHe"></a>
  2. #### 中间操作
  4. - 一个流后面可以跟随零个或者多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用。
  5. - **_Stream<T> filter(Predicate predicate)_**  用于对流中的数据进行过滤。
  6. - **_Stream<T> limit(long maxSize)_**  返回此流中的元素组成的流，截取前指定参数个数的数据。
  7. - **_Stream<T> skip(long n) _** 跳过指定参数个数的数据，返回由该流剩余元素组成的流。
  8. - **_static<T> Stream<T> concat(Stream a,Stream b) _** 合并a和b两个流为一个流
  9. - **_Stream<T> distinct()_**  返回由该流的不同元素（根据Object.equals(Object)组成的流）0
  10. - **_Stream<T> sorted() _** 返回此流的元素组成的流，根据自然顺序排序。
  11. - **_Stream<T> sorted(Comparator comparator)_**  返回由该流的元素组成的流，根据提供的Comparator进行排序
  12. - **_<R> Stream<R> map(Function mapper)_**  返回由给定函数应用于此流的元素的结果组成的流
  13. - **_IntStream mapToInt(ToIntFunction mapper) _** 返回一个IntStream其中包含给定函数应用于此流的元素的结果；InStream表示原始的int流；ToIntFunction接口中的方法   int applyAsInt(T value)
  14. ```java
  15. import java.util.*;
  16. import java.util.stream.Stream;
  18. public class Demo {
  19.     public static void main(String[] args) {
  20.         ArrayList<String> arrayList = new ArrayList<>() ;
  21.         arrayList.add("林青霞");
  22.         arrayList.add("张曼玉");
  23.         arrayList.add("王祖贤");
  24.         arrayList.add("柳岩");
  25.         arrayList.add("张敏");
  26.         arrayList.add("张无忌");
  28.         Stream<String> s1 = arrayList.stream().limit(4) ;
  29.         Stream<String> s2 = arrayList.stream().limit(2) ;
  30.         Stream.concat(s1,s2).forEach(System.out::println);
  31.         System.out.println("----------------");
  33.         //跳过前两个，再把剩下的输出
  34.         arrayList.stream().skip(2).limit(2).forEach(System.out::println);
  35.         System.out.println("----------------");
  37.         //输出姓张且名字为个字的
  38.         arrayList.stream().filter(s->s.startsWith("张"))
  39.                 .filter(s -> s.length()==3).forEach(System.out::println);
  40.     }
  41. }
  1. import java.util.*;
  2. import java.util.stream.Stream;
  4. public class Demo {
  5.     public static void main(String[] args) {
  6.         ArrayList<String> arrayList = new ArrayList<>() ;
  7.         arrayList.add("林青霞");
  8.         arrayList.add("张曼玉");
  9.         arrayList.add("王祖贤");
  10.         arrayList.add("柳岩");
  11.         arrayList.add("张敏");
  12.         arrayList.add("张无忌");
  14.         arrayList.stream().sorted().forEach(System.out::println);
  15.         System.out.println("----------------");
  16.         //只按长度排序
  17.         arrayList.stream().sorted((s1,s2) -> s1.length()-s2.length()).forEach(System.out::println);
  18.         System.out.println("----------------");
  19.         //长度一致，根据名字排序
  20.         arrayList.stream().sorted((s1,s2) ->{
  21.             int num1 = s1.length()-s2.length();
  22.             int num2 = num1==0?s1.compareTo(s2):num1 ;
  23.             return num2 ;
  24.         }).forEach(System.out::println);
  25.     }
  26. }
  27. 运行结果：
  28. 张敏
  29. 张无忌
  30. 张曼玉
  31. 林青霞
  32. 柳岩
  33. 王祖贤
  34. ----------------
  35. 柳岩
  36. 张敏
  37. 林青霞
  38. 张曼玉
  39. 王祖贤
  40. 张无忌
  41. ----------------
  42. 张敏
  43. 柳岩
  44. 张无忌
  45. 张曼玉
  46. 林青霞
  47. 王祖贤
  49. Process finished with exit code 0
  1. import java.util.*;
  3. public class Demo {
  4.     public static void main(String[] args) {
  5.         ArrayList<String> list = new ArrayList<>() ;
  6.         list.add("10");
  7.         list.add("20");
  8.         list.add("30");
  9.         list.add("40");
  10.         list.add("50");
  11.         list.add("60");
  12.         //将集合中的数据转成整数后输出
  13.         list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
  15.         int result = list.stream().mapToInt((s) -> Integer.parseInt(s)).sum();
  16.         System.out.println(result);
  17.     }
  18. }
  19. 运行结果：
  20. 10
  21. 20
  22. 30
  23. 40
  24. 50
  25. 60
  26. 210

终结操作：

  • 一个流只能有一个终结操作，当着操作执行后，流就被用“光”了，无法再被操作。所以这必定是流的最后一个操作
  • void forEach(Consumer action) 对此流的每个元素执行操作

  • long count() 返回此流中的元素数

    Stream流的收集操作

  • 对数据使用Stream流的操作完毕后，把流中的数据收集到集合中

    • R collect(Collector collector)
    • 这个收集方法是一个接口
  • 工具类Collector提供了具体的收集方式
    • public static Collector toList() 把元素收集到LIst集合中
    • public static Collector toSet() 把元素收集到Set集合中
    • public static Collector toMap(Function keyMapper,Function valueMapper) 把元素收集到Map集合中 ```java import java.util.*; import java.util.stream.Collectors; import java.util.stream.Stream;

public class Demo { public static void main(String[] args) { List list = new ArrayList<>(); list.add(“林青霞”); list.add(“柳岩”); list.add(“林志玲”); list.add(“王祖贤”); //得到名字为三个字的 Stream listStream = list.stream().filter(s -> s.length()==3) ; //操作完毕后的数据收集到List集合中并遍历 List names = listStream.collect(Collectors.toList()); for(String name:names) System.out.println(name);

  1.     Set<Integer> set = new HashSet<>() ;
  2.     set.add(10);
  3.     set.add(20);
  4.     set.add(30);
  5.     set.add(33);
  6.     set.add(35);
  7.     //得到年龄大于25的，收集起来遍历
  8.     Set<Integer> ages = set.stream().filter(s -> s>25).collect(Collectors.toSet()) ;
  9.     for(Integer age:ages)
  10.         System.out.println(age);
  12.     String[] strArray = {"林青霞,30","张曼玉,35","王祖贤,33","柳岩,25"};
  13.     //得到字符串中年龄数据大于28的流,得到一个map集合。
  14.     Map<String,Integer> map = Stream.of(strArray)
  15.             .filter(s -> Integer.parseInt(s.split(",")[1])>28)
  16.             .collect(Collectors.toMap(s -> s.split(",")[0],
  17.                     s->Integer.parseInt(s.split(",")[1])));
  18.     Set<String> keySet = map.keySet() ;
  19.     for(String key:keySet){
  20.         Integer value = map.get(key) ;
  21.         System.out.println(key+","+value);
  22.     }
  23. }

} 运行结果： 林青霞 林志玲 王祖贤 33 35 30 林青霞,30 王祖贤,33 张曼玉,35

Process finished with exit code 0 ```