Java Stream流

1.作用：是java8中处理集合的关键抽象概念，将集合中的数据变成另一种流的形式，可以对集合进行复杂的操作。Stream(流) 类用于来简化集合类的使用，Stream 本质上是个接口，接口中定义了很多对 Stream 对象的操作；

2.获取Strean流对象：

可以根据集合获取流对象

Collection集合：

default Stream<E> stream(); 返回的是一个有顺序的 和集合源数据相关的对象

2.11.根据list集合获取流对象

package com.wl.a_stream;
import java.util.ArrayList;
import java.util.List;
//根据list集合获取流对象
public class Demo03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("牛彩云");
        list.add("荆二条");
        list.add("荆二条");
        list.add("荆二胖");
        list.stream().forEach((name)-> System.out.println(name));
    }
}

2.2根据set集合获取流对象

package com.wl.a_stream;
import java.util.HashSet;
import java.util.Set;
//根据set集合获取流对象
public class Demo04 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("牛彩云");
        set.add("荆二条");
        set.add("荆二条");
        set.add("荆二胖");
        set.stream().forEach((name)-> System.out.println(name));
    }
}

2.3根据map集合获取对象

package com.wl.a_stream;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.stream.Stream;
public class Demo05 {
    public static void main(String[] args) {
        Map<String , String> map = new HashMap<>();
        map.put("1","啤酒鸭");
        map.put("2","烤全鸭");
        map.put("3","脆皮鸭");
        //map集合没有stream方法，转为集合再来操作
        Set<String> strings = map.keySet();//获取键放到set集合中
        Stream<String> stream = strings.stream();//将set集合中的键变成流
        Collection<String> values = map.values();//获取值放到Collection集合中
        Stream<String> stream1 = values.stream();//将获取的值转为流

        Set<Map.Entry<String, String>> entries = map.entrySet();//将获取的键值对放到集合中
        Stream<Map.Entry<String, String>> stream2 = entries.stream();//将获取的键值对集合转为stream流

    }
}

2.4数组

String[] arr = {"依依" , "思思" , "毵毵"};
Stream<String> arr1 = Stream.of(arr);
arr1.forEach((name)-> System.out.println(name));

3.Stream流对象下面的方法

方法名字	方法作用	方法种类	是否支持链式操作
count	统计个数	终结方法	否
forEach	遍历数据的	终结方法	否
filter	过滤数据	可以拼接	是
limit	取前几个数据	可以拼接	是
skip	跳过前几个	可以拼接	是
map	映射方法	可以拼接	是
concat	拼接	可以拼接	是

4. count 和 forEach

count: 统计流中的个数，返回值是long类型的数据

forEach : 遍历流中的数据

package com.wl.b_stream;
import java.util.ArrayList;
public class Demo01 {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<>();
        arr.add("胡歌");
        arr.add("李逍遥");
        arr.add("宇文拓");
        arr.add("古月胡");
        //链式操作 count()统计流中的个数
        long count = arr.stream().count();
        System.out.println(count);//4
        System.out.println(arr.stream().count());//4
        //forEach遍历流中的数据
        arr.stream().forEach((name)-> System.out.println(name));
    }
}

4.1filter方法

Stream<T> filter(Predicate<? super T> predicate)

返回由于此给定谓词匹配的此流的元素组成的流

package com.wl.b_stream;

import java.util.ArrayList;
//filter方法 过滤
public class Demo02 {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<>();
        arr.add("胡歌");
        arr.add("李逍遥");
        arr.add("李遥");
        arr.add("宇文拓");
        arr.add("古月胡");
        arr.stream().filter((name)->name.startsWith("李")).
                filter((name)->name.endsWith("遥")).forEach((name)-> System.out.println(name));
    }
}

4.2limit方法

限制输出

package com.wl.b_stream;
import java.util.ArrayList;
//limit方法 限制输出
public class Demo03 {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<>();
        arr.add("胡歌");
        arr.add("李逍遥");
        arr.add("李遥");
        arr.add("宇文遥");
        arr.add("古月遥");
        arr.add("古遥");
        arr.add("月遥");
        arr.add("古遥遥");
        arr.stream().limit(4).filter((name)->name.
                endsWith("遥")).forEach((name)-> System.out.println(name));
    }
}

4.3map方法

处理映射关系

package com.wl.b_stream;
//map方法 处理映射关系
import java.util.ArrayList;
import java.util.function.Function;
public class Demo04 {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<>();
        arr.add("12");
        arr.add("13");
        arr.add("14");
        arr.add("15");
        arr.add("16");
       /* //将字符串数值转为int数据类型
        for (String s : arr) {
            int i = Integer.parseInt(s);
            System.out.println(i);
        }*/
        arr.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                int i = Integer.parseInt(s);
                return i;
            }
            //.parseInt() 转int数据的方法
        }).forEach((Integer s)-> System.out.println(s));
        System.out.println("==============");
        //链式
        arr.stream().map((name)->Integer.parseInt(name)).
                forEach((name)-> System.out.println(name));
    }
}

4.4skip方法

跳过前几个值

import java.util.ArrayList;
//skip方法
public class Demo05 {
    public static void main(String[] args) {
        ArrayList<String> arr2 = new ArrayList<>();
        arr2.add("胡歌");
        arr2.add("李逍遥");
        arr2.add("李遥");
        arr2.add("宇文遥");
        arr2.add("古月遥");
        arr2.add("古遥");
        arr2.add("月遥");
        arr2.stream().skip(4).filter((name)->name.endsWith("遥")).
                forEach((name)-> System.out.println(name));
    }
}

4.5concat合并两个流

package com.wl.b_stream;
import java.util.ArrayList;
import java.util.stream.Stream;
// concat合并两个流
public class Demo06 {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<>();
        arr.add("12");
        arr.add("13");
        arr.add("14");
        arr.add("15");
        arr.add("16");
        ArrayList<String> arr2 = new ArrayList<>();
        arr2.add("胡歌");
        arr2.add("李逍遥");
        arr2.add("李遥");
        arr2.add("宇文遥");
        //将两个集合转为stream流
        Stream<String> stream = arr.stream();
        Stream<String> stream1 = arr2.stream();
        //将两个流合并 concat  
        Stream<String> concat = Stream.concat(stream, stream1);
        //forEach 遍历打印
        concat.forEach((name)-> System.out.println(name));
    }
}

5.收集流

stream.collect(Collectors.toList())

stream.collect(Collectors.toSet())

toList(); 将流转为List集合

toSet(); 将流转为Set集合

因为真实的开发的时候，最终的结果还是集合 流只是扮演了中间处理数据的角色,中转站

package com.wl.b_stream;
import java.util.ArrayList;
import java.util.stream.Collectors;
public class Demo07 {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<>();
        arr.add("胡歌");
        arr.add("李逍遥");
        arr.add("李遥");
        arr.add("宇文遥");
        arr.add("古月遥");
        arr.add("古遥");
        arr.add("古遥");
        arr.add("月遥");
        arr.add("古遥遥");
        arr.stream().skip(4).filter((name)->name.endsWith("遥")).
                collect(Collectors.toList()).forEach((name)-> System.out.println(name));
        System.out.println("==================");
        arr.stream().skip(4).filter((name)->name.endsWith("遥")).
                collect(Collectors.toSet()).forEach((name)-> System.out.println(name));
    }
}

练习：

package com.wl.zy_stream;
import java.util.ArrayList;
import java.util.stream.Stream;
/*现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作：
        1:男演员只要名字为3个字的前三人
        2:女演员只要姓林的，并且不要第一个
        3:把过滤后的男演员姓名和女演员姓名合并到一起
        4:把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
        https://yebd1h.smartapps.cn/pages/blog/index?blogId=117229163&_swebfr=1&_swebFromHost=baiduboxapp*/
class Actor{
    private String name;

    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 Work01 {
    public static void main(String[] args) {
        //第一个ArrayList集合 存储6名男演员
        ArrayList<String> arr = new ArrayList<>();
        arr.add("胡歌");
        arr.add("隋炀帝");
        arr.add("秦始皇");
        arr.add("倪大红");
        arr.add("张凯");
        arr.add("霍建华");
        //第二个ArrayList集合 存储6名女演员
        ArrayList<String> arr1 = new ArrayList<>();
        arr1.add("刘亦菲");
        arr1.add("林黛玉");
        arr1.add("林心如");
        arr1.add("李知恩");
        arr1.add("黄荣");
        arr1.add("林允儿");
        //1.男演员只要名字为3个字的前三人
        Stream<String> manStr = arr.stream().filter((name)->name.length() == 3).
                limit(3);
      //  manStr.forEach((name)-> System.out.println(name));
        System.out.println("================");
        //2.女演员只要姓林的，并且不要第一个
        Stream<String> womanStr = arr1.stream().filter((name1)->name1.startsWith("林")).
                skip(1);
       // womanStr.forEach((name)-> System.out.println(name));
        System.out.println("==============");
        //3:把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> stream = Stream.concat(manStr, womanStr);
        //stream.forEach(System.out::println);//==> stream.forEach((name)-> System.out.println(name));
        //4:把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
        //想输出 需要把上面的 终结方法注释掉（forEach等）
        stream.map(Actor::new).forEach(System.out::println);

    }
}