Java Stream流及其方法使用

（一）概述

        过去我们在遍历一个数组的时候，使用的是循环的方式，但是，仔细想想，我们我们为什么一定要用for 循环，或者是while循环呢？我们的目的是得到数组中的某些，或者全部内容，而我们是通过for循环的方式去获取的，换言之，for循环只是过程，他并不是必须的，我们只需要得到结果，中间的过程我们可以不在乎。因此，便出现了Java Stream的方式，它是类似于生产线，流的方式去处理。

• 核心思想： 它关注的是要做什么，而不是怎么做

（二）如何获取流

Stream 是1.8 加入的常用接口，不是函数式接口

• 获取流的方式：
  所有的Collection 集合都可以通过stream默认方法获得，
  default Stream stream()
  stream的静态方法of可以获得对应数组的流
  staticStream of

代码：

public class Stream_huoqu {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        Stream stream1 = list.stream();
        Set set = new HashSet<>();
        Stream stream2 = set.stream();
        //map,我们可以通过间接的方式，将其转化为Stream流
        //转换键
        Map map = new HashMap();
        Set keySet = map.keySet();
        Stream stream3 = keySet.stream();
        //转换值
        Collection values = map.values();
        Stream stream4 = values.stream();
        //转换键值对
        Set> entries = map.entrySet();
        Stream> stream5 = entries.stream();
        //把数组转换为Stream
        Stream stream6 = Stream.of(1,2,3,4,5,6);
        Integer[] arr ={1,2,3,4,5,6};
        Stream stream7 = Stream.of(arr);
        String[] arr2 = {"a","b","c","d","e"};
        Stream stream8 = Stream.of(arr2);
    }
}

(三)Stream中的方法

 1）foreach 方法
     是一个终结方法

• foreach(consumer)
  所谓的终结方法就是一旦使用这个方法之后，就不能再使用这个流了。

 2）filter方法
     专递的是Predicate 函数接口，是一个判断的接口 这个接口中，有抽象方法test(T t) 主要用来判断，过滤。

 3) map 方法
     映射方法,中传的是Function 接口,使用map方法把字符串类型的数据，映射为Integer的数据

 4)limit方法
     是一个延时方法，返回一个新的流
 5)skip 方法
     跳过前几个数据

 6）concat方法
     组合方法，可以把两个流 合并成为一个流,是一个静态方法

代码：

import java.util.ArrayList;
import java.util.stream.Stream;

/*
* 用来遍历流中的数据
* foreach 是一个终结方法
*
*   foreach(consumer)
* */
public class Stream_foreach {
    public static void main(String[] args) {

        //foreach 方法 终结方法， 使用之后，就不能使用其他流方法
        //因为传的接口是consumer 接口，而stream流，是管道流，只能消费一次，
        //所以消费一次之后，不能在进行第二次消费。
        Stream stream = Stream.of("张三", "李四", "王五","张无忌","周芷若");
//        stream.forEach(s-> System.out.println(s));

        //Predicate 函数接口，是一个判断的接口
        //其中有抽象方法test(T t)
        Stream stream1 = stream.filter(s->s.startsWith("张"));
        stream1.forEach(s-> System.out.println(s));

        //map 方法，映射方法
        //其中传的是Function 接口
        //使用map方法把字符串类型的数据，映射为Integer的数据
        System.out.println("===================================");
        Stream stream2 = Stream.of("1", "2", "3", "4", "5");
        Stream stream3 = stream2.map(s->Integer.parseInt(s));
        stream3.forEach(s-> System.out.println(s));

        System.out.println("=================");
        //count方法 用于统计流中元素的个数
        //Long count 是一个终结方法
        ArrayList list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        Stream stream4 = list.stream();
        long count1 = stream4.count();
        System.out.println(count1
        );


//        limit方法 是一个延时方法，返回一个新的流
        String[] arr = {"美羊羊","喜洋洋","懒洋洋","灰太狼"};
        Stream stream5 = Stream.of(arr);
        Stream stream6 = stream5.limit(3);//截取前三个数据
        stream6.forEach(s-> System.out.println(s));
        System.out.println("===========================");
        //skip 方法，跳过前几个方法
        Stream stream7 = Stream.of(arr);
        Stream stream8 = stream7.skip(3);
        stream8.forEach(s-> System.out.println(s));


        //组合方法 concat 可以把两个流 合并成为一个流,是一个静态方法
        String[] arr2 = {"美羊羊","喜洋洋","懒洋洋","灰太狼"};
        Stream stream10 = Stream.of(arr);
        Stream stream9 = Stream.of("张三", "李四", "王五","张无忌","周芷若");
        Stream con = Stream.concat(stream10,stream9);
        con.forEach(s-> System.out.println(s));


    }
}

输出姓张的并且名字长度是3的人的名字

代码：

import java.util.ArrayList;
import java.util.List;
public class Stram_List_gaishu {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张量");
        list.add("张三丰");

        list.stream().filter(s->s.startsWith("张"))
                    .filter(s->s.length()==3)
                    .forEach(s-> System.out.println(s));

    }
}

第一组数据，找出名字长度为3的前三个和第二组数据姓张的人的非前两个数据组合，并且用这些姓名产生一个新Person对象，输出最后的Person信息。

代码

主类

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class Stream_jihe {

    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("迪丽热巴");
        list.add("赵敏");
        list.add("张三");
        list.add("李四");
        list.add("二狗");
        list.add("王二麻子");
        list.add("周芷若");
        Stream stream = list.stream();
        Stream stream1 = stream.filter(s->s.length()==3).limit(3);
//        stream1.forEach(s-> System.out.println(s));

        List list1 = new ArrayList<>();
        list1.add("张三");
        list1.add("王五");
        list1.add("建国");
        list1.add("国安");
        list1.add("张四");
        list1.add("张无忌");
        list1.add("张三丰");

        Stream stream2 = list1.stream();
        Stream stream3 = stream2.filter(s->s.startsWith("张")).skip(2);
//        stream3.forEach(s-> System.out.println(s));
        Stream.concat(stream1,stream3).map(s->new Person(s)).forEach(s-> System.out.println(s));

    }
}

Person类：

public class Person {
    private String name;

    public Person() {

    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}