这次呢，主要来讲讲使用 化骨绵掌-stream 中和核心部分 运功。
本节中，我将Stream类中的返回值类型还是Stream类对象的方法集中提取出来。给大家做一波讲解。
主要为以下几种
无需等待上游类型 ##### filter | map | flatMap | peek | peek |
需要等待上游类型 ##### distinct | limit | sorted
只要明白，每种的功能，想清楚上下游Stream对象中的元素类型，做出适当的拼接。
就能灵活快捷优雅的运用了。
filter 内力的筛选
filter 演示.gif
public class Test20181204 {
//内力源头
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
@Test
public void test1() {
//运功手法1 内力筛选
//filter
List<Integer> collect = integerList.stream().
//第一次运功 找出偶数
filter(i -> i % 2 == 0).
//第二次运功 找出小于5的数字
filter(i -> i < 5).
collect(Collectors.toList());
System.out.println(collect);
}
}
[2, 4]
Stream<T> filter(Predicate<? super T> predicate);
filter方法，来自于Stream对象，输出Stream对象，上下游对象类型相同。
在每一节上完成一种筛选功能。
参数为一个Predicate 简单理解为 一个返回值类型为boolean的方法。
map 内力的转型map 演示.gif
public class Test20181204 {
//内力源头
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
@Test
public void test1() {
//运功手法2 内力转换
//map
List<String> collect = integerList.stream()
.map(integer -> ("数字" + integer))
.map(s -> s + "哈哈哈").collect(Collectors.toList());
System.out.println(collect);
}
}
[数字1哈哈哈, 数字2哈哈哈, 数字3哈哈哈, 数字4哈哈哈, 数字5哈哈哈, 数字6哈哈哈, 数字7哈哈哈, 数字8哈哈哈, 数字9哈哈哈, 数字10哈哈哈]
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
map方法，来自于Stream对象，输出Stream对象，下游对象类型可以和上游不同。
在每一节上完成一种形变功能。
参数为了一个Function 简单理解为 一个有固定返回类型的方法。
flatMap 内力平铺
flatMap 演示 普清.gif
public class Test20181205 {
//内力源头
private List<String> stringsList = Arrays.asList("1,1,1", "2,2,2", "3,3,3");
@Test
public void test1() {
//运功手法5 内力平铺
//flatMap
List<String> collect = stringsList.stream().
flatMap(
s -> Arrays.asList(s.split(",")).stream()
)
.collect(Collectors.toList());
System.out.println(collect);
}
}
[1, 1, 1, 2, 2, 2, 3, 3, 3]
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
flatMap方法，来自于Stream对象，输出Stream对象，下游对象类型可以和上游不同。
从上游流中获取元素，通过某种方法将元素变成Stream对象，然后将每个元素产生的Stream对象顺序的拼接成一个大的Stream对象。
参数为一个 返回结果为Stream对象的Function
peek 内力镜像
peek 演示.gif
public class Test20181205 {
//内力源头
private List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
@Test
public void test1() {
//运功手法6 内力镜像
//peek
List<Integer> collect = integerList.stream()
.peek(integer -> System.out.println(integer))
.collect(Collectors.toList());
System.out.println(collect);
}
}
1
2
3
4
5
[1, 2, 3, 4, 5]
Stream<T> peek(Consumer<? super T> action);
peek方法，来自于Stream对象，输出Stream对象，上下游流中元素无变化。
从上游流中获取元素，对每个元素执行一个动作。
参数为一个Consumer，可简单理解为一个无返回的方法。
skip 内力跃迁
public class Test20181205 {
//内力源头
private List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
@Test
public void test1() {
//运功手法 内力跃迁
//peek
List<Integer> collect = integerList.stream()
.skip(3)
.collect(Collectors.toList());
System.out.println(collect);
}
}
[4, 5]
Stream<T> skip(long n);
skip方法，来自于Stream对象，输出Stream对象，上下游对象类型相同。
跳过上游流中的前n个元素，将剩下的元素输出到下游流中。
参数为 希望跳过元素的个数
sorted 内力排序
public class Test20181205 {
//内力源头
private List<Integer> integerList1 = Arrays.asList(3, 2, 1, 5, 4);
@Test
public void test1() {
//运功手法 内力排序
//sorted
List<Integer> collect = integerList1.stream()
.sorted()
.collect(Collectors.toList());
System.out.println(collect);
}
@Test
public void test2() {
//运功手法 内力排序
//sorted
List<Integer> collect = integerList1.stream()
.sorted((o1, o2) -> o2 - o1)
.collect(Collectors.toList());
System.out.println(collect);
}
}
test1:[1, 2, 3, 4, 5]
Stream<T> sorted();
test2:[5, 4, 3, 2, 1]
Stream<T> sorted(Comparator<? super T> comparator);
sorted方法，来自于Stream对象，输出Stream对象，上下游对象类型相同。
对上游Stream中的元素排序，元素需要实现Comparable接口
参数为可选的
1不传入元素的话，使用自然顺序排序法。
2传入一个Comparator,用来控制排序。
distinct 内力去重
public class Test20181204 {
//内力源头
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3, 4, 5);
@Test
public void test1() {
//运功手法3 内力去重
//distinct
List<Integer> collect = integerList.stream()
.distinct().collect(Collectors.toList());
System.out.println(collect);
}
}
[1, 2, 3, 4, 5]
Stream<T> distinct();
distinct方法，来自于Stream对象，输出Stream对象，上下游对象类型相同。
将上游流中的重复元素去除，保证下游流中元素唯一。
无参数
limit 内力限制
public class Test20181204 {
//内力源头
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3, 4, 5);
@Test
public void test1() {
//运功手法4 内力限制
//limit
List<Integer> collect = integerList.stream().
limit(6).collect(Collectors.toList());
System.out.println(collect);
}
}
[1, 2, 3, 4, 5, 1]
Stream<T> limit(long maxSize);
limit方法，来自于Stream对象，输出Stream对象，上下游对象类型相同。
将上游流中的前n个元素输出到下游流中。
参数为 希望取出元素的个数
