Stream流中的常用方法：

1. 逐一处理：forEach
2. 过滤：filter
3. 映射：map
4. 统计个数：count
5. 取用前几个：limit
6. 跳过前几个：skip
7. 组合：concat

逐一处理：forEach

package JDK8.Xin.Demo01Stream;

import java.util.stream.Stream;

/*
    Stream流中的常用方法_forEach
    void forEach(Consumer<? supper T> action);
    该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。
    Consumer接口是一个消费型接口，可以传递Lambda表达式，消费数据。

    简单记：
        forEach方法，用来遍历流中的数据
        是一个终结方法，遍历之后就不能继续调用Stream流中的其他方法
 */
public class Demo01Stream_ForEach {
    public static void main(String[] args) {
        //获取一个Stream流
        Stream<String> stream = Stream.of("张三", "李四", "王五", "麻六");
        //使用Stream流中的方法forEach对Stream流中的数据进行遍历
        /*stream.forEach((name)->{
            System.out.println(name);
        });*/

        //优化Lambda表达式
        stream.forEach(name->System.out.println(name));
    }
}

运行结果：

张三
李四
王五
麻六

 过滤：filter

package JDK8.Xin.Demo01Stream;

import java.util.stream.Stream;

/*
    Stream流中常用方法_filter：用于对Stream流中的数据进行过滤
    Stream<T> filter(Predicate<? super T> predicate);
    filter方法的参数Predicate中的抽象方法：
        Boolean test(T t);
 */
public class Demo02Stream_filter {
    public static void main(String[] args) {
        //创建一个Stream流
        Stream<String> stream = Stream.of("张三", "李四", "张五", "麻六");
        //对Stream流中的元素进行过滤，只要姓张的人
        Stream<String> stream2 = stream.filter(name->name.startsWith("张"));
        //遍历stream2流
        stream2.forEach(name-> System.out.println(name));
    }
}

运行结果：

张三
张五

映射：map

package JDK8.Xin.Demo01Stream;

import java.util.stream.Stream;

/*
    如果需要将流中的元素映射到另一个流中，可以使用map方法。
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
    Function中的抽象方法：
        R apply(T t);
 */
public class Demo03Stream_map {
    public static void main(String[] args) {
        //获取一个Stream类型的Stream流
        Stream<String> stream = Stream.of("1","2","3","4","5","6");
        //使用map方法，把字符串类型的整数，转换(映射)为Integer类型的整数
        Stream<Integer> stream2 = stream.map(s->Integer.parseInt(s));
        //遍历stream2流
        stream2.forEach(i-> System.out.println(i));
    }
}

运行结果：

1
2
3
4
5
6

统计个数：count

package JDK8.Xin.Demo01Stream;

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

/*
    Stream流中的常用方法_count：用于统计Stream流中元素的个数
    Long count();
    count方法是一个终结方法，返回值是一个Long类型的整数
    所以不能再继续调用Stream流中的其他方法了
 */
public class Demo04Stream_count {
    public static void main(String[] args) {
        //获取一个Stream流
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}

运行结果：

6

取用前几个：limit

package JDK8.Xin.Demo01Stream;

import java.util.stream.Stream;

/*
    Stream流中的常用方法_limit：用于截取流中的元素
    limit方法可以对流进行截取，只取用前n个。
    Stream<T> limit(long maxSize);
        参数是一个lang型，如果集合当前长度大于参数则进行截取；否则不进行操作
    limit方法是一个延迟方法，只是对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其他方法
 */
public class Demo05Stream_limit {
    public static void main(String[] args) {
        //获取一个Stream流
        String[] arr = {"张三", "李四", "张五", "麻六"};
        Stream<String> stream = Stream.of(arr);
        //使用limit对Stream流中的元素进行截取，只要前3个元素
        Stream<String> stream2 = stream.limit(3);
        //遍历stream2流
        stream2.forEach(name-> System.out.println(name));
    }
}

运行结果：

张三
李四
张五

跳过前几个：skip

package JDK8.Xin.Demo01Stream;

import java.util.stream.Stream;

/*
    Stream流中的常用方法_skip：用于跳过元素
    如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流：
    Stream<T> skip(lang n);
        如果流当前长度大于n，则跳过前n个；否则将会到的一个长度为0的空流。
 */
public class Demo06Stream_skip {
    public static void main(String[] args) {
        //获取一个Stream流
        String[] arr = {"张三", "李四", "张五", "麻六"};
        Stream<String> stream = Stream.of(arr);
        //使用skip方法跳过前3个元素
        Stream<String> stream2 = stream.skip(3);
        //遍历stream2流
        stream2.forEach(name-> System.out.println(name));
    }
}

运行结果：

麻六

组合：concat

package JDK8.Xin.Demo01Stream;

import java.util.stream.Stream;

/*
    Stream流中的常用方法_concat：用于把流组合到一起
    如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat
    static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
 */
public class Demo07Stream_concat {
    public static void main(String[] args) {
        //创建一个Stream流
        Stream<String> stream1 = Stream.of("张三", "李四", "张五", "麻六");
        //获取一个Stream流
        String[] arr = {"田七", "老八", "小九"};
        Stream<String> stream2 = Stream.of(arr);
        //把以上两个流组合为一个流
        Stream<String> concat = Stream.concat(stream1, stream2);
        //遍历concat流
        concat.forEach(name-> System.out.println(name));
    }
}

运行结果：

张三
李四
张五
麻六
田七
老八
小九