简述stream流

初识stream流

把所有为张开头,长度为3的元素存储的新集合中，原本我们需要用for循环遍历两次才能得到指定的结果，而stream一串代码即可解决。

public class StreamDemo {

    public static void main(String[] args) {
        knowStream();
    }

	private static void knowStream() {
        ArrayList<String> listTemp = new ArrayList<>();
        listTemp.add("张无忌");
        listTemp.add("周芷若");
        listTemp.add("赵敏");
        listTemp.add("张强");
        listTemp.add("张三丰");

	//把所有为张开头,长度为3的元素存储的新集合中
 		listTemp.stream().filter(name -> name.startsWith("张"))
  						.filter(name -> name.length() == 3)
 						.forEach(name -> System.out.println(name));
	}
}

获取stream流

获取stream流的情况有四种，如下：
           单列集合 stream() Collection中的默认方法。
           双列集合 先转为单列集合才能使用stream流。
           数组 stream() Arrays工具类的静态方法。
            一堆零散数据 stream接口中的静态方法。

public class StreamDemo {

   public static void main(String[] args) {
       getStream();
   }
      public static void getStream(){
       /*
       单列集合 stream()  Collection中的默认方法
       双列集合  先转为单列集合才能使用stream流
       数组 stream()     Arrays工具类的静态方法
       一堆零散数据      stream接口中的静态方法
        */

       //1.单列集合获取stream流
       ArrayList<String> list = new ArrayList<>();
       Collections.addAll(list,"a","b","c","d","e");

       list.stream().forEach(word -> System.out.println(word));

       System.out.println("----------------------------");

       //2.双列集合获取stream流
       HashMap<String,Integer> hm = new HashMap();
       hm.put("a",1);
       hm.put("b",2);
       hm.put("c",3);

       //第一种获取stream的方法
       hm.keySet().stream().forEach(item -> System.out.println(item));

       //第二种获取stream的方法
       hm.entrySet().stream().forEach(item -> System.out.println(item));

       System.out.println("----------------------------");

       //3.数组获取stream流
       String[] strs = {"a","b","c"};
       Arrays.stream(strs).forEach(item -> System.out.println(item));

       System.out.println("----------------------------");

       //4.一堆零散数据获取stream流
       //stream接口中静态方法of的细节
       //方法的形参可以是可变参数，可以传递一堆零散的数据，也可以传递数组
       //但是数组必须是引用类型的，如果传递基本数据类型，就会把整个数组当成一个元素，放到stream当中
       Stream.of(1,2,3,4,5).forEach(item -> System.out.println(item));
  	 }
   }

stream流的方法

stream流有两种方法，一种为中间方法，执行完仍可使用。另一种为终结方法，执行完将执行下一条语句，直接进行返回。

中间方法

注意：
            1.中间方法，返回新的stream流，原来的stream流只能使用一次，建议使用链式编程。
            2.修改Stream流的数据，不会影响到原来集合或数组中的数据。

public class StreamMethods1 {
    public static void main(String[] args) {
        filter();  //过滤
        //limit(); //获取前几个元素
        //skip();  //跳过前几个元素
        //distinct(); //元素去重，依赖hashcode和equals方法
        //concat(); //合并a，b为一个流
        //map();  //转换流中的数据类型
    }

    /**
     * 过滤
     */
    public static void filter(){
        ArrayList<String> list =  new ArrayList<>();
        Collections.addAll(list,"张无忌","赵敏","张三丰","张翠山","张良","王麻子","谢广坤");
        list.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3)
                .forEach(name -> System.out.println(name));
    }

    /**
     * 获取前几个元素
     */
    public static void limit(){
        ArrayList<String> list =  new ArrayList<>();
        Collections.addAll(list,"张无忌","赵敏","张三丰","张翠山","张良","王麻子","谢广坤");
        list.stream().limit(3).forEach(item -> System.out.println(item));
    }

    /**
     * 跳过前几个元素
     */
    public static void skip(){
        ArrayList<String> list =  new ArrayList<>();
        Collections.addAll(list,"张无忌","赵敏","张三丰","张翠山","张良","王麻子","谢广坤");

        list.stream().skip(2).forEach(item -> System.out.println(item));
    }

    /**
     * 元素去重，依赖hashcode和equals方法
     */
    public static void distinct(){
        ArrayList<String> list =  new ArrayList<>();
        Collections.addAll(list,"张无忌","赵敏","张三丰","张翠山","张良","王麻子","谢广坤","谢广坤");

        list.stream().distinct().forEach(item -> System.out.println(item));
    }

    /**
     * 合并a，b为一个流
     */
    public static void concat(){
        ArrayList<String> list1 =  new ArrayList<>();
        Collections.addAll(list1,"张无忌","赵敏","张三丰","张翠山","张良","王麻子","谢广坤");

        ArrayList<String> list2 =  new ArrayList<>();
        Collections.addAll(list2,"张无忌","赵敏");

        Stream.concat(list1.stream(),list2.stream()).forEach(item -> System.out.println(item));

    }

    /**
     * 转换流中的数据类型
     */
    public static void map(){
        ArrayList<String> list =  new ArrayList<>();
        Collections.addAll(list,"张无忌-15","赵敏-15","张三丰-18","张翠山-88","张良-50","王麻子-1","谢广坤-2");

        //只获取里面的数据进行打印

        //string -> int
        //第一个类型：流中原本的类型
        //第二个类型：要转换的类型

        //apply的形参表示liu中的每一个数据
        //返回值: 表示转换之后的数据
        /*list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.valueOf(s.split("-")[1]);
            }
        }).forEach(item -> System.out.println(item));*/

        list.stream().map(item -> Integer.valueOf(item.split("-")[1])).forEach(item -> System.out.println(item));
    }
}

终结方法

其中包含forEach(遍历集合中的数据)，count(统计集合中的数据)，toArray(收集流中的数据，放入数组)和collect(收集流中的数据，放入集合)，本次只介绍前两种。

public class StreamMethod2 {
    public static void main(String[] args) {
        //forEach(); //遍历
        //count();  //统计
    }

    /**
     * 遍历
     */
    public static void forEach() {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "赵敏", "张三丰", "张翠山", "张良", "王麻子", "谢广坤");
        list.stream().forEach(item -> System.out.println(item));
    }

    /**
     * 统计
     */
    public static void count() {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "赵敏", "张三丰", "张翠山", "张良", "王麻子", "谢广坤");

        System.out.println(list.stream().count());
    }
}