代码简洁之道—Stream API
JDK8起新添加的Stream API 把真正的函数式编程风格引入到Java中。以一种声明的方式处理数据，从而写出高效率、干净、简洁的代码。
Stream特性
1、不是数据结构，没有内部存储
2、不支持索引访问
3、延迟计算
4、支持并行操作
5、容易生成数组或集合
6、支持过滤，查找，转换，汇总，聚合等操作，代码优雅
Stream API优势
1、告别for循环
2、多核友好操作
Stream运行机制
Stream分为源source，中间操作，终止操作
流的源可以是一个数组，一个集合，一个生成器方法，一个I/O通道等等
一个流可以有0个或多个中间操作，每一个中间操作都会返回一个新的流，供下一个操作使用，一个流只会有一个终止操作
Stream只有遇到终止操作，源才开始执行遍历操作
Stream常用函数
创建：
通过数组
通过集合
通过Stream.generate
通过Stream.iterate
通过其他API
注：一般来说，都是对集合和数组直接进行流操作，很少的场合才需要自己生成流
中间操作：
过滤filter
去重distinct
排序sorted
截取limit，skip
转换map，flatMap
其他peek
终止操作：
循环forEach
计算min，max，count，average
匹配anyMatch，allMatch，noneMatch，findFirst，findAny
汇聚reduce
收集器toArray collect
Stream API实操
Stream创建
/** * 数组遍历 */ static void seqT(){ String[] strs = {"a","b","c","d","e"}; //将数组转成流 Stream<String> streamStr = Stream.of(strs); //循环打印数组 streamStr.forEach(System.out::println); Stream.of(strs).forEach(System.out::println); }
/** * 集合遍历 */ static void listT(){ List<Integer> list = Arrays.asList(4,3,5,6,2,1); list.stream().forEach(System.out::println); }
/** * 利用流直接生成和操作元素 */ static void streamT(){ //生成5个1 Stream.generate(()->1).limit(5).forEach(System.out::println); }
/** * 利用迭代器操作元素 */ static void iterateT(){ Stream.iterate(1,x->x+1).limit(10).forEach(System.out::println); }
/** * 字符串的流操作 */ static void stringT(){ String str = "fuckyou"; str.chars().mapToObj(item->(char)item).forEach(System.out::println); }
Stream中间操作：中间操作的函数调用，基本都是返回的Stream对象
filter()筛选过滤
/** * 对数组或集合做元素筛选取值 * filter() */ static void filterT(){ Arrays.asList(1,2,3,4,5).stream() .filter(x->x%2!=0).forEach(System.out::println); }
/** * 求集合中1,2,3...100的和 * filter() */ static void sumT(){ int sum = Stream.iterate(1, x -> x + 1).limit(100).mapToInt(x -> x).sum(); System.out.println(sum); }
count()统计
/** * 求集合中1,2,3...100偶数的个数 * count() */ static void oushuT(){ long count = Stream.iterate(1, x -> x + 1).limit(10) .filter(x -> x % 2 == 0).count(); System.out.println(count); }
max(),min()最大最小值
/** * 求集合中的最大，最小值 * max(),min() */ static void maxminT(){ Integer max = Stream.iterate(1, x -> x + 1).limit(10) .max((a, b) -> a - b).get(); Integer min = Stream.iterate(1, x -> x + 1).limit(10) .min((a, b) -> a - b).get(); System.out.println(max); System.out.println(min); }
findAny()查找任意元素
/** * 从集合中找出符合条件的第一个元素 * findany() */ static void findanyT(){ System.out.println(Stream.iterate(1, x -> x + 1).limit(10) .filter(x->x>4).findAny().get()); }
Stream不遇到终止操作，不会执行任何中间操作
/** * Stream不遇到终止操作，不会执行任何中间操作 * 如下例子不会打印"中间操作打印" */ static void nofinT(){ Stream.iterate(1,x->x+1).limit(5).filter(n->{ return n>3; }).forEach(System.out::println); Stream<Integer> intStream = Stream.iterate(1, x -> x + 1).limit(3).filter(n -> { System.out.println("中间操作打印"); return n > 3; }); System.out.println(intStream); }
sorted()排序操作
/** * 对集合的排序操作 * sorted(); */ static void sortT(){ Integer min = Stream.iterate(1, x -> x + 1).limit(10) .sorted().findFirst().get(); System.out.println(min); Integer max = Stream.iterate(1, x -> x + 1).limit(10) .sorted((a, b) -> b - a).findFirst().get(); System.out.println(max); Arrays.asList("c","c++","python","go","java").stream() .sorted().forEach(System.out::println); System.out.println(); Arrays.asList("c","c++","python","go","java").stream() .sorted((a,b)->a.length()-b.length()).forEach(System.out::println); }
collect()对中间操作过程返回
/** * 对Stream的中间操作过程返回一个集合 * collect() */ static void collectT(){ List<Integer> collect = Stream.iterate(1, x -> x + 1).limit(10) .filter(x -> x > 5).collect(Collectors.toList()); collect.forEach(System.out::println); }
flatMap()对集合流的操作
/** * 对集合做复制操作 * flatMap() * Collections.nCopies(times,e).stream() * times—次数 */ static void copyT(){ Stream.iterate(0, x -> x + 2).limit(3) .flatMap(e -> Stream.of(e, e)).forEach(System.out::print); System.out.println(); Stream.iterate(0, x -> x + 2).limit(3) .flatMap(e-> Collections.nCopies(3,e).stream()) .forEach(System.out::print); }
distinct()去重操作
/** * 对集合做去重操作 * distinct() * Collectors.toSet() */ static void distinctT(){ Stream.iterate(0, x -> x + 2).limit(3) .flatMap(e-> Collections.nCopies(3,e).stream()) .distinct().forEach(System.out::println); Stream.iterate(0, x -> x + 2).limit(3) .flatMap(e-> Collections.nCopies(3,e).stream()) .collect(Collectors.toSet()).forEach(System.out::println); }
skip()跳跃操作
/** * 跳跃操作,打印20-30 * skip() */ static void skipT(){ Stream.iterate(20, x -> x + 1).limit(11).forEach(System.out::println); System.out.println(); Stream.iterate(1, x -> x + 1).limit(40) .skip(19).limit(10).forEach(System.out::println); }
mapToInt() 集合类型转换
/** * 批量String转Integer */ static void strs2intT(){ String str = "10,20,66,88"; Stream.of(str.split(",")).mapToInt(x->Integer.valueOf(x)+1) .forEach(System.out::println); System.out.println(); Stream.of(str.split(",")).map(x->Integer.valueOf(x)) .mapToInt(x->x+1).forEach(System.out::println); System.out.println(); Stream.of(str.split(",")).mapToInt(Integer::valueOf) .forEach(System.out::println); }
map()集合对象操作
/** * Stream的对象操作 */ static void objT(){ String str = "dog,cat,monkey,fish"; Stream.of(str.split(",")).map(x->new Person(x,12)) .map(x->x.getName()).forEach(System.out::println); }
peek()流操作中间步骤
/** * 打印数值的同时计算出结果 * peek(); */ static void midprintT(){ String str = "1,2,3,4,5,6,7,8,9,10"; int sum = Stream.of(str.split(",")).peek(System.out::println) .mapToInt(Integer::valueOf).sum(); System.out.println(sum); }
allMatch()，anyMatch()表达式匹配
/** * 表达式匹配 * allMatch() * anyMatch() */ static void matchT(){ String str = "cat,dog,fish,tom"; //全部匹配 System.out.println(Stream.of(str.split(",")) .allMatch(x -> x.length() == 3)); //部分匹配 System.out.println(Stream.of(str.split(",")) .anyMatch(x -> x.length() == 3)); }
对集合取并集，交集，合集，合并集合，差集操作
class Person{ private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
/** * flatmap取并集，交集，合集，合并集合，差集操作 * map操作 */ static void flatmap1T(){ //交集 Map<String,Person> personMap1 = new HashMap<String,Person>(){ { put("1",new Person("cat",11)); put("2",new Person("dog",12)); put("3",new Person("cow",13)); } }; Map<String,Person> personMap2 = new HashMap<String,Person>(){ { put("1",new Person("cat",23)); put("4",new Person("bird",14)); put("5",new Person("bird",15)); } }; //取交集 Map map1 = personMap1.entrySet().stream().filter(e->personMap2.containsKey(e.getKey())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); System.out.println("交集=="+map1); //并集并解决Duplicate key Map map2 = Stream.of(personMap1.entrySet(),personMap2.entrySet()) .flatMap(Collection::stream).distinct() .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,(value1,value2)->value1)); System.out.println("并集1=="+map2); //根据对象属性取并集并解决Duplicate key Map map3 = Stream.of(personMap1.entrySet(),personMap2.entrySet()) .flatMap(Collection::stream).filter(distinctByKey(e->e.getValue().getName())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,(value1,value2)->value1)); System.out.println("并集2=="+map3); //差集 Map map4 = personMap1.entrySet().stream().filter(e->!personMap2.containsKey(e.getKey())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); System.out.println("差集=="+map4); } //元素去重 private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) { Map<Object,Boolean> seen = new ConcurrentHashMap<>(); return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null; }
/** * flatmap取并集，交集，合集，合并集合，差集操作 * list操作 */ static void flatmap3T(){ Map<String,Person> personMap1 = new HashMap<String,Person>(){ { put("1",new Person("fuck",11)); put("2",new Person("dog",12)); } }; Map<String,Person> personMap2 = new HashMap<String,Person>(){ { put("3",new Person("cat",23)); } }; List<Map<String,Person>> list1 = new ArrayList<Map<String,Person>>(){ { add(personMap1); add(personMap2); } }; Map<String,Person> personMap3 = new HashMap<String,Person>(){ { put("1",new Person("king",11)); put("4",new Person("fish",12)); } }; Map<String,Person> personMap4 = new HashMap<String,Person>(){ { put("5",new Person("cow",23)); } }; List<Map<String,Person>> list2 = new ArrayList<Map<String,Person>>(){ { add(personMap3); add(personMap4); } }; //交集 list1.stream().map(Map::entrySet).flatMap(Set::stream).filter(e->{ return list2.stream().map(Map::entrySet).flatMap(Set::stream) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)) .containsKey(e.getKey()); }).forEach(k->System.out.println(k.getValue().getName())); //并集，合并到一个list List merge = Stream.of(list1,list2).flatMap(Collection::stream).distinct() .collect(Collectors.toList()); merge.forEach(System.out::println); //差集 = list1 - 交集 list1.stream().map(Map::entrySet).flatMap(Set::stream).filter(e->{ return !list2.stream().map(Map::entrySet).flatMap(Set::stream) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)) .containsKey(e.getKey()); }).forEach(k->System.out.println(k.getValue().getName())); }
集合间根据关联关系进行关联操作
class Consumer{ private String userid; private String username; private String address; public Consumer(String userid, String username, String address) { this.userid = userid; this.username = username; this.address = address; } public String getUserid() { return userid; } public void setUserid(String userid) { this.userid = userid; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } } class Product{ private String userid; private String prodid; private String prodname; private String money; public Product(String userid, String prodid, String prodname, String money) { this.userid = userid; this.prodid = prodid; this.prodname = prodname; this.money = money; } public String getUserid() { return userid; } public void setUserid(String userid) { this.userid = userid; } public String getProdid() { return prodid; } public void setProdid(String prodid) { this.prodid = prodid; } public String getProdname() { return prodname; } public void setProdname(String prodname) { this.prodname = prodname; } public String getMoney() { return money; } public void setMoney(String money) { this.money = money; } }
/** * 集合间根据关联关系进行关联操作 * 将顾客和商品的集合根据顾客id关联查询汇集到一个大集合 */ static void flatmap2T(){ //消费者集合 List<Consumer> conList = new ArrayList<Consumer>(){ { add(new Consumer("1","jerry","广东深圳")); add(new Consumer("2","tom","浙江杭州")); add(new Consumer("3","jack","四川成都")); } }; //商品集合 List<Product> proList = new ArrayList<Product>(){ { add(new Product("1","k1","华为","5000")); add(new Product("2","k2","小米","4500")); add(new Product("3","k3","苹果","6300")); } }; conList.stream().flatMap(x->proList.stream().filter(y->x.getUserid().equals(y.getUserid())) .map(y->{ return new HashMap<String,Object>(){ { put("userid",x.getUsername()); put("username",x.getUsername()); put("address",x.getAddress()); put("prodid",y.getProdid()); put("prodname",y.getProdname()); put("money",y.getMoney()); } }; })).collect(Collectors.toList()).forEach(System.out::println); }
