java8 lambda表达式之 Stream常用方法

前言:废话不错,一切都在代码中.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.BinaryOperator;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.Test;

/**
*
* lambda表达式中
* 常用的stream相关方法
* 1.Stream是元素的集合，类似Iterator；
2.可以支持顺序和并行的对原Stream进行汇聚的操作；
* @author huitoukest
* @version 1.0
*
*/
public class MainStream {
/**
*
* @param args
*/
public static void main(String[] args){

MainStream main=new MainStream();
//main.testFilter();
//main.testMap();
//main.testDistinct();
//main.testFlatMap();
//main.testPeek();
//main.testLimit();
//main.testCollect();
//main.testSum();
main.testReduce();
}

/**
* 使用Stream的基本步骤：
1.创建Stream；
2.转换Stream，每次转换原有Stream对象不改变，返回一个新的Stream对象（**可以有多次转换**）；
3.对Stream进行聚合（Reduce/count等等）操作，获取想要的结果；
如何得到Stream对象：
1.通过Collection接口（实现类）的默认方法stream()；
2.通过Stream接口的静态方法Stream.of，比如Stream<Integer> stream = Stream.of(1,9,5);
3.Stream.generate()或者Stream.iterate()生成无限长度的Stream，一般需要用limit(XX)发放来限定长度。
例子：Stream.iterate(1, item -> item + 1).limit(10).forEach(System.out::println);
取出Stream中正整数集合的前10个。
*/

/**
* filter：过滤操作，将返回值是true的结果对应的项留下。
* forEach：遍历操作，依次遍历每一个元素。
* 这里，过滤掉长度大于等于2的元素
*/
@Test
public void testFilter(){
List<String> list=Arrays.asList("b" ,"1","c","dd","2");
list.stream()
.filter((a)->a.length()<2)
.forEach((a)->System.out.println(a))
;
}

/**
* Map：映射操作，对集合中的每个元素做出相同的更改。
* 这里，在每个元素后面加入下划线。
*/
@Test
public void testMap(){
List<String> list=Arrays.asList("b" ,"1","c","dd","2");
list.stream()
.map((a)->a+"_")
.forEach((a)->System.out.println(a))
;
}

/**
* distinct：集合元素去重复操作。
* count: 求出集合中元素的数量。
*/
@Test
public void testDistinct(){
List<String> list=Arrays.asList("1" ,"1","2","dd","2");
Long count=list.stream().distinct().count();
System.out.println(count);
}

/**
* flatMap:和map类似，不同的是其每个元素转换得到的是Stream对象，会把子Stream中的元素压缩到父集合中；
* 即Map是遍历操作List中的元素。而flatMap中，需要我们返回Stream对象，flatMap自己把（返回的）多个Stream
* 中的元素遍历压入一个Stream中。
*/
@Test
public void testFlatMap(){
Stream<List<Integer>> inputStream = Stream.of(
Arrays.asList(1),
Arrays.asList(2,3,5),
Arrays.asList(4,6)
);
Stream<Integer> outputStream = inputStream.flatMap((childList) -> childList.stream());
outputStream.forEach(System.out::println);
}

/**
* Peek:
* 使用Peek的时候需要传入Consumer（消费函数），同时生成一个新的Stream。
* 在我们用到新Stream集合中的具体元素的时候，会先触发消费函数中的操作。
*/
@Test
public void testPeek(){
List<String> list=Arrays.asList("1" ,"a","2","dd","b");
list.stream().peek(a->System.out.println(a+"_"))
.forEach((a)->System.out.println("_"+a))
;
}

/**
* Limit：对一个Stream进行截断操作，获取其前N个元素，如果原Stream中包含的元素个数小于N，那就获取其所有的元素；
* Skip: 返回一个丢弃原Stream的前N个元素后剩下元素组成的新Stream，如果原Stream中包含的元素个数小于N，那么返回空Stream；
*/
@Test
public void testLimit(){
List<String> list=Arrays.asList("1" ,"a","2","dd","b");
list.stream().limit(4)
.skip(1)
.forEach((a)->System.out.println("_"+a))
;
}

/********************************************************************************************
上面基本上属于对Stream的转换，遍历，映射等操作。下面则是对Stream的汇聚（Reduce）操作
*******************************************************************************************/
/**
* 可变汇聚：把输入的元素们累积到一个可变的容器中，比如Collection或者StringBuilder；
其他汇聚：除去可变汇聚剩下的，一般都不是通过反复修改某个可变对象，
而是通过把前一次的汇聚结果当成下一次的入参，反复如此。比如reduce，count，allMatch；
*/
/**
* collect，把Stream中的所有有元素收集到一个结果容器中
* collect属于可变汇聚,同时也是Stream的通用汇聚操作
*/
@Test
public void testCollect(){
List<String> list=Arrays.asList("1" ,"a","2","dd","b");
/**
* Collect这里有三个参数，分别是：(生成一个容器,也是返回的容器，如何往容器中添加元素，如何往容器中添加容器中的元素)。
*
*/
ArrayList<String> aList=list.stream().collect(() -> new ArrayList<String>(),
(lista,b) -> lista.add(b),
(lista, listb) -> lista.addAll(listb));
aList.forEach((a)->System.out.println(a))
;
System.out.println();
/**
* collect方法也接受Collector参数
* Collector<T, A, R>
* T：输入元素类型
* A：缩减操作的可变累积类型（通常隐藏为实现细节）
* R：可变减少操作的结果类型
*/
@SuppressWarnings("unused")
Collector<Integer, ?, TreeSet<Integer>> intoSet =
Collector.of(TreeSet::new, TreeSet::add,
(left, right) -> { left.addAll(right); return left; });
System.out.println();
/**
* Collectors中封装的一些静态方法返回Collector参数
* 包括：toList,toSet,toCollection,toMap等等。
*/
Set<String> aList3=list.stream().collect(Collectors.toSet());
aList3.forEach((a)->System.out.println(a))
;
}

/**一些特定的汇聚操作
* 比如sum，max,count :sum方法不是所有的Stream对象都有的，只有IntStream、LongStream和DoubleStream是实例才有
*/
@Test
public void testSum(){
List<Integer> list=Arrays.asList(1 ,3,2,0);
Long sum=list.stream().mapToLong(a->new Long(a)).sum();
System.out.println(sum);

System.out.println(list.stream().max((a,b)->a.compareTo(b)).get());
System.out.println(list.stream().count());
}

/**
* Reduce,Reduce是一种通用的方法。
* Reduce输入两个参数（a，b）——>的到的结果c将会作为下一次迭代的参数a传入，然后直到结束。
*
*/
@Test
public void testReduce(){
List<Integer> list=Arrays.asList(1 ,3,2,0);
//(a,b)依次迭代,返回Optional<Integer>
System.out.println(list.stream().reduce((a,b)->a+b).get());
//(a,(b,c)->...)附加初始值a,返回a的类型
System.out.println(list.stream().reduce(-1, (sum, item) ->(sum + item)));
//计数
System.out.println(list.stream().reduce(0, (sum, item) ->(sum+1)));
/**
* 这里reduce中传入的是BinaryOperator<T>,通过BinaryOperator自带
* 的maxBy和minBy静态方法可以获得
*/
System.out.println(list.stream().reduce(
BinaryOperator.maxBy((a,b)->a-b)
));
}

/**
* allMatch：是不是Stream中的所有元素都满足给定的匹配条件
*
*/
@Test
public void testAllMatch(){
List<Integer> list=Arrays.asList(1 ,3,2,0);
System.out.println(list.stream().allMatch(a->a>=0));
System.out.println(list.stream().allMatch(a->a>0));
}
/**
* anyMatch：Stream中是否存在任何一个元素满足匹配条件
*
*/
@Test
public void testAnyMatch(){
List<Integer> list=Arrays.asList(1,3,2,0);
System.out.println(list.stream().anyMatch(a->a>100));
System.out.println(list.stream().anyMatch(a->a>2));
}
/**
* findFirst: 返回Stream中的第一个元素，如果Stream为空，返回空Optional
*/
@Test
public void testFindFirst(){
List<Integer> list=Arrays.asList(1,3,2,0);
System.out.println(list.stream().findFirst());
System.out.println(list.stream().findFirst().get());
}

/**
* noneMatch：是不是Stream中的所有元素都不满足给定的匹配条件
*/
@Test
public void testNoneMatch(){
List<Integer> list=Arrays.asList(1,3,2,0);
System.out.println(list.stream().noneMatch(a->a>100));
System.out.println(list.stream().noneMatch(a->a>2));
}
/**
* – max和min：使用给定的比较器（Operator），返回Stream中的最大|最小值
*/
}