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));
    }
}

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));
    }
}

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);
    }
}

取用前几个：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));
    }
}