Stream流中的常用方法＞＞forEach、filter、map、count、limit、skip、concat方法的使用

Stream流中的常用方法：
逐一处理：forEach
过滤：filter
映射：map
统计个数：count
取用前几个：limit
跳过前几个：skip
组合：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 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 filter(Predicate<? super T> predicate);
filter方法的参数Predicate中的抽象方法：
Boolean test(T t);
*/
public class Demo02Stream_filter {
public static void main(String[] args) {
//创建一个Stream流
Stream stream = Stream.of(“张三”, “李四”, “张五”, “麻六”);
//对Stream流中的元素进行过滤，只要姓张的人
Stream 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方法。
Stream 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 stream = Stream.of(“1”,“2”,“3”,“4”,“5”,“6”);
//使用map方法，把字符串类型的整数，转换(映射)为Integer类型的整数
Stream 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 list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
Stream 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 limit(long maxSize);
参数是一个lang型，如果集合当前长度大于参数则进行截取；否则不进行操作
limit方法是一个延迟方法，只是对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其他方法
*/
public class Demo05Stream_limit {
public static void main(String[] args) {
//获取一个Stream流
String[] arr = {“张三”, “李四”, “张五”, “麻六”};
Stream stream = Stream.of(arr);
//使用limit对Stream流中的元素进行截取，只要前3个元素
Stream 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 skip(lang n);
如果流当前长度大于n，则跳过前n个；否则将会到的一个长度为0的空流。
*/
public class Demo06Stream_skip {
public static void main(String[] args) {
//获取一个Stream流
String[] arr = {“张三”, “李四”, “张五”, “麻六”};
Stream stream = Stream.of(arr);
//使用skip方法跳过前3个元素
Stream 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 Stream concat(Stream<? extends T> a, Stream<? extends T> b)
*/
public class Demo07Stream_concat {
public static void main(String[] args) {
//创建一个Stream流
Stream stream1 = Stream.of(“张三”, “李四”, “张五”, “麻六”);
//获取一个Stream流
String[] arr = {“田七”, “老八”, “小九”};
Stream stream2 = Stream.of(arr);
//把以上两个流组合为一个流
Stream concat = Stream.concat(stream1, stream2);
//遍历concat流
concat.forEach(name-> System.out.println(name));
}
}
运行结果：

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