阶段二27_面向对象高级_stream流[流的获取,中间操作方法,结操作方法,收集操作]

知识：

(1)Stream流的获取
    单列集合 : 集合对象.stream();
    双列集合 : 不能直接获取,需要间接获取[集合对象.keySet().stream();集合对象.entrySet().stream();]
    数: Arrays.stream(数组名);
    同种数据类型的多个数据:Stream.of(数据1,数据2,数据3......);
(2)Stream流的常见中间操作方法:filter,limit,skip,concat,distinct()
(3)Stream流的常见终结操作方法:forEach,count
(4)Stream流的收集操作：
   在Stream流中无法直接修改集合,数组等数据源中的数据。
   R collect(Collector collector)[工具类Collectors提供了具体的收集方式]
      public static <T> Collector toList()：把元素收集到List集合中
      public static <T> Collector toSet()：把元素收集到Set集合中
      public static  Collector toMap(Function keyMapper,Function valueMapper)：把元素收集到Map集合中

一.体验Stream流

需求：按照下面的要求完成集合的创建和遍历
创建一个集合，存储多个字符串元素
把集合中所有以"张"开头的元素存储到一个新的集合
把"张"开头的集合中的长度为3的元素存储到一个新的集合
遍历上一步得到的集合

public class MyStream1 {
    public static void main(String[] args) {
        //集合的批量添加
        ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
        list1.stream().filter(s->s.startsWith("张"))
        .filter(s->s.length() == 3)
        .forEach(s-> System.out.println(s));
    }
}

二.Stream流的三类方法

(1)获取Stream流
创建一条流水线，并把数据放到流水线上准备进行操作
(2)中间方法
流水线上的操作。
一次操作完毕之后，还可以继续进行其他操作。
(3)终结方法
一个Stream流只能有一个终结方法
是流水线上的最后一个操作

三.Stream流的获取方法

(1)单列集合

可以使用Collection接口中的默认方法stream?()生成流
	default Stream<E> stream()

(2)双列集合

间接的生成流
可以先通过keySet或者entrySet获取一个Set集合，再获取Stream流

(3)数组

Arrays中的静态方法stream 生成流

(4)同种数据类型的多个数据

1，2，3，4，5….
“aaa”,“bbb”,“ccc”….
使用Stream.of(T…values)生成流

(5)具体案例：

public class MyStream2 {
    public static void main(String[] args) {
        //1.单列集合
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.stream().forEach(s-> System.out.println(s));

        //2.双列集合
        HashMap<String,Integer> hm = new HashMap<>();
        hm.put("zhangsan",23);
        hm.put("lisi",24);
        hm.put("wangwu",25);
        hm.put("zhaoliu",26);
        hm.put("qianqi",27);
        //双列集合不能直接获取Stream流
        //keySet
        //先获取到所有的键
        //再把这个Set集合中所有的键放到Stream流中
        hm.keySet().stream().forEach(s-> System.out.println(s));
        //entrySet
        //先获取到所有的键值对对象
        //再把这个Set集合中所有的键值对对象放到Stream流中
        hm.entrySet().stream().forEach(s-> System.out.println(s));

        //3.数组
        int [] arr = {1,2,3,4,5};
        Arrays.stream(arr).forEach(s-> System.out.println(s));

        //4.同种数据类型的多个数据
        Stream.of(1,2,3,4,5,6,7,8).forEach(s-> System.out.println(s));
    }
  }

四.Stream流的常见中间操作方法

Stream<T> filter?(Predicate predicate)：用于对流中的数据进行过滤
Predicate接口中的方法
boolean test(T t)：对给定的参数进行判断，返回一个布尔值 

/** Stream流的中间方法 */
public class MyStream3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        //filter方法获取流中的 每一个数据.
        //而test方法中的s,就依次表示流中的每一个数据.
        //我们只要在test方法中对s进行判断就可以了.
        //如果判断的结果为true,则当前的数据留下
        //如果判断的结果为false,则当前数据就不要.
        list.stream().filter(
		   new Predicate<String>() {
			@Override
			public boolean test(String s) {
				boolean result = s.startsWith("张");
				return result;
			}
		   }
        ).forEach(s-> System.out.println(s));
        //因为Predicate接口中只有一个抽象方法test
        //所以我们可以使用lambda表达式来简化
        //list.stream().filter( (String s)->{  boolean result = s.startsWith("张");  return result;} ).forEach(s-> System.out.println(s));
        list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));
    }
}

五.Stream流的常见中间操作方法

Stream<T> limit(long maxSize)：截取指定参数个数的数据[保留值前面数据]
Stream<T> skip(long n)：跳过指定参数个数的数据[跳过值，保留后面的所有数据]
static <T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流
Stream<T> distinct()：去除流中重复的元素。依赖(hashCode和equals方法)

具体案例：

public class MyStream4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");
        list.add("谢广坤");

        //1.Stream limit(long maxSize)：截取指定参数个数的数据
        list.stream().limit(2).forEach(s-> System.out.println(s));//结果：张三丰,张无忌
        
        //2.Stream skip(long n)：跳过指定参数个数的数据
        list.stream().skip(5).forEach(s-> System.out.println(s));//结果：谢广坤,谢广坤
        
        //3.static  Stream concat(Stream a, Stream b)：合并a和b两个流为一个流
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("张三丰");
        list2.add("张无忌");
        list2.add("张翠山");
        list2.add("王二麻子");
        list2.add("张良");
        list2.add("谢广坤");
        Stream.concat(list.stream(),list2.stream()).forEach(s-> System.out.println(s));
        
        //4.Stream distinct()：去除流中重复的元素。依赖(hashCode和equals方法)
        list.stream().distinct().forEach(s-> System.out.println(s))
    }
}

六.Stream流的常见终结操作方法

void forEach(Consumer action)：对此流的每个元素执行操作
Consumer接口中的方法 void accept?(T t)：对给定的参数执行此操作
long count()：返回此流中的元素数
具体实现案例：

public class MyStream5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        //1.void forEach(Consumer action)：对此流的每个元素执行操作[Consumer接口中的方法	void accept(T t)：对给定的参数执行此操作]
        //在forEach方法的底层,会循环获取到流中的每一个数据.
        //并循环调用accept方法,并把每一个数据传递给accept方法
        //s就依次表示了流中的每一个数据.
        //所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.
        list.stream().forEach(
		  new Consumer<String>() {
			@Override
			public void accept(String s) {
				System.out.println(s);
			}
		  }
        );
        //lambda表达式的简化格式
        //是因为Consumer接口中,只有一个accept方法
        list.stream().forEach( (String s)->{ System.out.println(s); } );
        //lambda表达式还是可以进一步简化的.
        list.stream().forEach(s->System.out.println(s));
        //2.long count()：返回此流中的元素数
        long count = list.stream().count();
        System.out.println(count);
    }
}

七.Stream流的收集操作

需求1：过滤元素并遍历集合
定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
将集合中的奇数删除，只保留偶数。
遍历集合得到2，4，6，8，10
结论：在Stream流中无法直接修改集合,数组等数据源中的数据。

public class MyStream6 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        list.stream().filter(number -> number % 2 == 0).forEach(number -> System.out.println(number));
        System.out.println("====================");
        //在Stream流中无法直接修改集合,数组等数据源中的数据。
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}

Stream流的收集方法
R collect(Collector collector)
工具类Collectors提供了具体的收集方式
public static <T> Collector toList()：把元素收集到List集合中
public static <T> Collector toSet()：把元素收集到Set集合中

public class MyStream7 {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        for (int i = 1; i <= 10; i++) { list1.add(i);  }
        list1.add(10);
        
        //1.public static  Collector toList()：把元素收集到List集合中
        //filter负责过滤数据的.
        //collect负责收集数据.
        //获取流中剩余的数据,但是他不负责创建容器,也不负责把数据添加到容器中.
        //Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.
        List<Integer> list = list1.stream().filter(number -> number % 2 == 0)
        .collect(Collectors.toList());
        System.out.println(list); //结果：2,4,6,8,10,10
        
        //2.public static  Collector toSet()：把元素收集到Set集合中
        Set<Integer> set = list1.stream().filter(number -> number % 2 == 0)
        .collect(Collectors.toSet());
        System.out.println(set); //结果：2,4,6,8,10
    }
  }

public static  Collector toMap(Function keyMapper,Function valueMapper)：把元素收集到Map集合中
需求：
创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄
"zhangsan,23"，"lisi,24"，"wangwu,25"
保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值

代码实现：

public class MyStream8 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("zhangsan,23");
        list.add("lisi,24");
        list.add("wangwu,25");
        Map<String, Integer> map = list.stream().filter(
		  s -> {
			String[] split = s.split(",");
			int age = Integer.parseInt(split[1]);
			return age >= 24;
		  }
        )
        //collect方法只能获取到流中剩余的每一个数据.
        //在底层不能创建容器,也不能把数据添加到容器当中
        //Collectors.toMap 创建一个map集合并将数据添加到集合当中
        //s 依次表示流中的每一个数据
        //第一个lambda表达式就是如何获取到Map中的键
        //第二个lambda表达式就是如何获取Map中的值
        .collect(Collectors.toMap(
             s -> s.split(",")[0], //key
             s -> Integer.parseInt(s.split(",")[1])  //vaule
         ));
        System.out.println(map);
    }
}

八.Stream流的收集操作,练习：

现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作
1.男演员只要名字为3个字的前两人
2.女演员只要姓杨的，并且不要第一个
3.把过滤后的男演员姓名和女演员姓名合并到一起
4.把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
演员类Actor，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法

public class Actor {
    private String name;
    public Actor() {}
    public Actor(String name) { this.name = name;}
    public String getName() {   return name;}
    public void setName(String name) {  this.name = name; }

    @Override
    public String toString() {
        return "Actor{" +    "name='" + name + '\'' +'}';
    }
}
public class MyStream9 {
    public static void main(String[] args) {
        ArrayList<String>  manList = new ArrayList<>();
        manList.add("张国立");
        manList.add("张晋");
        manList.add("刘烨");
        manList.add("郑伊健");
        manList.add("徐峥");
        manList.add("王宝强");
        ArrayList<String>  womanList = new ArrayList<>();
        womanList.add("郑爽");
        womanList.add("杨紫");
        womanList.add("关晓彤");
        womanList.add("张天爱");
        womanList.add("杨幂");
        womanList.add("赵丽颖");
        //男演员只要名字为3个字的前两人
        Stream<String> stream1 = manList.stream().filter(name -> name.length() == 3).limit(2);
        //女演员只要姓杨的，并且不要第一个
        Stream<String> stream2 = womanList.stream().filter(name -> name.startsWith("杨")).skip(1);
        Stream.concat(stream1,stream2).forEach(name -> {
            Actor actor = new Actor(name);
            System.out.println(actor);
        });
    }
}

九更多内容
http://www.gxcode.top/code