JDK8新特性-Stream流

package com.zenqgifeng.practicedemo.lambda;import org.junit.Test;import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;/*** @author zengqifeng* @version 1.0* @date 2020/1/2 10:21* Stream流：对集合中数据加工处理* 传统集合操作方式的弊端      Stream** 获取stream流的两种方式*      1、Collection接口中提供默认方法，故Collection接口的子类全部可以直接获取stream流对象*      2、Stream接口的of静态方法*  stream操作方法分类*      1、返回值不是stream   ：终结类方法  如count  froEach等方法*      2、返回值是stream    ：非终结类方法（可链式调用）filter    mpa     limit等方法**  stream注意事项*      1、stream对象第一次使用完后关闭，因此第二次使用将会报错*      2、返回的是新的stream对象*      3、最终必须调用终结方法，否则前面的方法全部不会执行**  stream相关方法*      forEach*      count**      filter*      findFirst/findAnt   都是查找第一个*      limit               选择前几个元素*      skip                跳过前几个元素*      map                 将当前元素类型映射成我们想要的类型，或者我们只想要操作元素中的某个属性值*      sorted              排序       制定排序规则*      distinct            去重复     复写hashCode和equals方法*      allMatch/anyMatch/noneMatch      是否匹配   全部匹配/只要匹配一个/全都没匹配   返回true*      max/min             最小最大值       也要制定排序规则，取排序后的第一个/最后一个*      reduce              x,y    第二次依赖于第一次操作的结果*      mapToInt            操作Integer集合时，将元素转成int  节省内存和时间(Integer有其它的一些东西，还要拆箱装箱)*      concat              合并两个流（可以是不同类型的流）      合并完后原两个stream就关闭了，不能再使用了*      collect             流中数据收集到集合中（可指定具体类型的集合）*      toArray             流中数据收集到数组中（可指定具体类型的数组）**/
public class Demo04 {public static void main(String[] args) {//1、Collection接口中提供的默认方法获取stream流，Collection接口的子类也都可以使用该方法获取stream流//需求：选择出姓为张，名字是三个字的打印List<String> list = Arrays.asList("张三", "李四", "王五", "张三丰", "张无忌");list.stream().filter((s) -> {return s.startsWith("张");}).filter((s) -> {return s.length() == 3;}).forEach((s) -> {System.out.println(s);});//2、Stream接口中的静态方法String[] strings = {"张三", "李四", "王五", "张三丰", "张无忌"};Stream.of(strings).filter((s) -> {return s.startsWith("张");}).filter((s) -> {return s.length() == 3;}).forEach((s) -> {System.out.println(s);});// Collection接口及其子类皆可直接获取stream流对象，针对hashMap呢HashMap<String, String> hashMap= new HashMap<>();Set<String> strings1 = hashMap.keySet();Collection<String> values = hashMap.values();Set<Map.Entry<String, String>> entries = hashMap.entrySet();Stream<String> stream = strings1.stream();Stream<String> stream1 = values.stream();Stream<Map.Entry<String, String>> stream2 = entries.stream();}/*** forEach*/@Testpublic void test1() {List<String> list = new ArrayList();Collections.addAll(list,"张三", "李四", "王五", "赵六", "赵七");list.stream().forEach(System.out::println);}/*** filter*/@Testpublic void test2() {List<String> list = new ArrayList();Collections.addAll(list,"张三", "李四", "王五", "赵六", "赵七");list.stream().filter((s) -> {return s.startsWith("张");}).forEach(System.out::println);}/*** limit*/@Testpublic void test3() {List<String> list = new ArrayList();Collections.addAll(list,"张三", "李四", "王五", "赵六", "赵七");list.stream().limit(2).forEach(System.out::println);}/*** skip*/@Testpublic void test4() {List<String> list = new ArrayList();Collections.addAll(list,"张三", "李四", "王五", "赵六", "赵七");list.stream().skip(2).forEach(System.out::println);}/*** map  映射，将一种类型映射为另一种类型   例如String--Integer   参数是String，返回值是Integer*/@Testpublic void test5() {List<String> list = new ArrayList();Collections.addAll(list,"1", "2", "3", "4", "5");list.stream().map(Integer::valueOf).forEach(System.out::println);}/*** sorted*/@Testpublic void test6() {List<Integer> list = new ArrayList();Collections.addAll(list,1, 4, 2, 7);list.stream()//自然序   默认是升序//.sorted().sorted((Integer i1, Integer i2) -> {//降序return i2 - i1;}).forEach(System.out::println);}/*** distinct   去重复   自定义类型需要重写hashCode和equals方法*/@Testpublic void test7() {/*Stream<Integer> stream = Stream.of(1, 2, 1, 3, 4, 2);stream.distinct().forEach(System.out::println);*/Stream<Person> stream = Stream.of(new Person("貂蝉", 18),new Person("西施", 19),new Person("西施", 19),new Person("杨玉环", 20),new Person("王昭君", 21),new Person("王昭君", 21));stream.distinct().forEach(System.out::println);}/*** match*/@Testpublic void test8() {List<Integer> list = new ArrayList();Collections.addAll(list,1, 4, 2, 7);boolean b = list.stream().allMatch(i -> i > 0);//true   全部匹配才返回trueSystem.out.println(b);boolean c = list.stream().anyMatch(i -> i > 2);//true   只要有一个匹配上就返回trueSystem.out.println(c);boolean d = list.stream().noneMatch(i -> i > 7);//true   全部不匹配才返回trueSystem.out.println(d);}/*** find findFirst     findAny好像都是查找第一个*/@Testpublic void test9() {List<Integer> list = new ArrayList();Collections.addAll(list,1, 4, 2, 7);//findFirst     findAny好像都是查找第一个//Optional<Integer> first = list.stream().findFirst();Optional<Integer> first = list.stream().findAny();Integer integer = first.get();System.out.println(integer);}/*** max  and min*/@Testpublic void test10() {List<Integer> list = new ArrayList();Collections.addAll(list,5, 1, 4, 2, 7);System.out.println(list.stream().min((o1, o2) -> o1 - 02).get());System.out.println(list.stream().max((o1, o2) -> o1 - 02).get());}/*** reduce 思想*/@Testpublic void test11() {//reduce 的意思/***  第一次 0作为x,第一个元素作为y       x和y处理结果作为下次的x*  第二次 上次的结果作为x,第二个元素作为y  x和y处理结果作为下次的x*  ........*  可用于求和，求最大最小值，累积相关的操作    （下一次操作依赖于上次操作的结果）*/Integer reduce = Stream.of(1, 2, 3, 4, 5).reduce(0, (x, y) -> x + y);System.out.println("reduce" + reduce);/*** map结合reduce* 我们想操作的是元素中的某个属性* 1、map：映射出我们要操作的属性* 2、使用reduce操作它*///求和Integer sum = Stream.of(new Person("张三", 10),new Person("李四", 11),new Person("王五", 12),new Person("赵六", 13)).map(p -> p.getAge()).reduce(0, Integer::sum);System.out.println("sum" + sum);//求最大最小值Integer max = Stream.of(new Person("张三", 10),new Person("李四", 11),new Person("王五", 12),new Person("赵六", 13)).map(p -> p.getAge()).reduce(Integer.MIN_VALUE, Integer::max);System.out.println("max" + max);Integer min = Stream.of(new Person("张三", 10),new Person("李四", 11),new Person("王五", 12),new Person("赵六", 13)).map(p -> p.getAge()).reduce(Integer.MAX_VALUE, Integer::min);System.out.println("min" + min);/*** 统计a出现的次数思路：    统计某一个元素在集合内出现的次数思路* 1、使用map将a元素全部变成1，其它的元素全部变成0* 2、reduce求和就是a元素出现的次数*/Integer count = Stream.of("a", "b", "c", "a", "a").map(s -> {if (s == "a") {return 1;} else {return 0;}}).reduce(0, Integer::sum);System.out.println("count" + count);}/*** mapToInt     Integer 变成int类型处理       节省内存和拆箱装箱的时间* 从下面测试看来，时间耗费Integer：int=39:1* 差的还是挺多的，故提供这些包装类转基本数据类型确实是可却的，很大程度上节省内存和时间** 结论：包装类集合元素操作还是转成基本数据类型操作*/@Testpublic void test12() {Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17);IntStream intStream = integerStream.mapToInt(Integer::intValue);Long start = System.currentTimeMillis();//39//Integer reduce = integerStream.reduce(0, Integer::sum);//1int reduce = intStream.reduce(0, Integer::sum);Long end = System.currentTimeMillis();System.out.println(end - start);}/*** concat   合并两个流  可以是不同类型的流*/@Testpublic void test13() {Stream<String> one = Stream.of("张三", "李四", "王五", "张无忌", "张三丰");Stream<String> two = Stream.of("迪丽热巴", "杨幂", "丫丫", "李沁", "丫蛋");Stream<Integer> three = Stream.of(1, 2, 3, 4);/*Stream<String> newStream = Stream.concat(one, two);newStream.forEach(System.out::println);*///如下表名可以合并两个不同类型的流Stream<? extends Serializable> stream = Stream.concat(one, three);stream.forEach(System.out::println);}/*** collect* 将流中结果收集到指定集合中保存，以便后续处理* 转成set集合会自动去重复*/@Testpublic void test14() {Stream<String> one = Stream.of("张三", "李四", "王五", "张无忌", "张三丰", "张三丰");/*List<String> list = one.filter(s -> s.startsWith("张")).collect(Collectors.toList());System.out.println(list);*//*Set<String> set = one.filter(s -> s.startsWith("张")).collect(Collectors.toSet());System.out.println(set);*//*ArrayList<String> arrayList = one.filter(s -> s.startsWith("张")).collect(Collectors.toCollection(ArrayList::new));System.out.println(arrayList);*/HashSet<String> hashSet = one.filter(s -> s.startsWith("张")).collect(Collectors.toCollection(HashSet::new));System.out.println(hashSet);}/*** toArray* 流转数组*/@Testpublic void test15() {Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);//如果操作很复杂的话 mapToInt    减少内存消耗和装箱拆箱的时间消耗/*Object[] objects = integerStream.toArray();System.out.println(objects);for (Object object : objects) {System.out.println(object);}*/Integer[] integers = integerStream.toArray(Integer[]::new);for (Integer integer : integers) {System.out.println(integer);}}
}class Person {private String name;private Integer age;public Person() {}public Person(String name, Integer age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Person person = (Person) o;return Objects.equals(name, person.name) &&Objects.equals(age, person.age);}@Overridepublic int hashCode() {return Objects.hash(name, age);}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}
}