Java之Stream流

流在java的官方文档中被定义为视图。通过流去完成什么样的任务，而不是如何去实现它。通俗一点来讲它相对于集合就是表达了做什么，而不是怎么做。
流和集合的差异
1.流并不储存数据，数据还是储存在底层的集合中。
2.流的操作并不能修改数据，它只是在原本的流中产生新的流。
3.流的操作是惰性的，只要不使用终结方法提交操作我们就可以一直无限流。

流有
stream() //流 将任何集合转换为一个流
parallelStream() //并行流、顺序流

流的创建

Stream<String> words = Stream.of(contents.split("\\PL+")); //将数组转换成为流
Stream<String> silence = Stream.empty();    //创建一个没有任何元素的流

Stream<String> echos = Stream.generate(() -> "Echo");    //创建一个常量值的流
Stream<Double> randoms = Stream.generate(Math :: random);    //获取一个随机数的流

//产生一个无限流，在它的值上产生新的值、在前一个元素上调用后一个方法产生值
Stream<BigInteger> integers = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));

 

filter、map 和 flatMap 方法

//过滤产生新的流
List<String> wordList = ...;
Stram<String> longWords = wordList.stream().filter(w -> w.length() > 12);

//用map转换成新的流
Stream<String> lowercaseWords = words.stram().map(String :: toLowerCase);
Stream<String> firsLetters = words.stram().map(s -> s.substring(0, 1));

//用flatMap 将所有当前流中所有元素连接到一起
Stream<String> flatResult = words.stream().flatMap(w -> ... );

抽取子流和连接流

//获取一个限制大小的流
Stream<Double> randows = Stream.generate(Math :: random).limit(100);
//丢弃前n个元素
Stream<String> words = Stream.of(contents.split("\\PL+")).skip(1);
//连接两个元素的流
Stream<String> combined = Sream.concat( ... , ...);

其他的流转换

//剔除重复元素的流
Stream<String> uniqueWords = Stream.of("a", "a", "b", "c").distinct();
//对流进行排序
Stream<String> longesFirst = words.stram().sorted(Comparator.comparing(String :: length).reversed());
//peek 产生和原来的流相同，但是每次获取一个元素时都调用一次函数
Object[] powers = Stream.iterate(1.0, p -> p*2).peek(e -> System.out.println("Fetching" + e)).limit(20).toArray();

简单约简
约简是一种终结操作。

//获取最大值
Optional<String> largest = words.max(String :: compareToIgnoreCase);

Optional<T>类型
Optional<T>对象是一种包装器对象，要么包装了T类型的对象，要么没有包装任何对象。
如何使用Optional值

 

//没有任何匹配的时候返回空字符串
String result = optionalString.orElse("");
//计算默认值
String result = optionalString.orElseGet(() -> Locale.getDefault().getDisplayName());
//没有任何值时抛出异常
String result = optionalString.orElseThrow(IllegalStateException :: new);

//如果值存在将它添加进某个集中
optionalVlaue.ifPresent(v -> results.add(v));
//或
optionalValue.ifPresent(results :: add);

ifPresent不会返回任何值，如果想处理函数结果过应该使用map
//added 可能存在三种值，true、false、空的Optional
Optional<Boolean> added = optionalValue.map(results :: add);

 

 

不适合使用OPtional值的方式
在Optional值为null使用get将会抛出NoSuchElementException对象。
所以不要直接使用get()方法，应先判断值是否存在。

if(optionalValue.isPresent())
optionalValue.get().someMethod();
//或
if(vlaue != null)
value.someMethod();

创建Optional值

Optional.of(result)和Optional.empty()

public static Optional<Double> inverse(Double x)
{
return x == 0 ？ Optional.empty() : Optional.of(1/X);
}

ofNullable方法
ofNullable(obj)会在obj不为null 的情况返回Optional.of(obj),否则返回Optional.empty()。

用flatMap来构建Optional值的函数
flatMap就像是管道，在Optional<T>对象的方法f有产生另外的Optional<U>对象g时不能直接调用s.f().g()。
因为它们属于不同类型的Optional<T>。则是就可以用到flatMap。

Optional<U> result = s.f().flatMap(T :: g)

收集结果
当处理完流之后，想要获取里面的元素是。可以调用iterator方法或者forEach
stream.forEach(System.out :: println);
在并行流上，forEach方法会以任意顺序遍历。如果想按流中的顺序可以调用forEachOrdered方法。
更多的是转变成为一种数据结构。可以调用toArray。
收集到数组中
因为无法在运行时创建泛型数组，所以steam.toArray()会返回一个Object[]数组。
如果想正确创建指定类型数组。

String[] result = stream.toArray(String[] :: new);

收集到集合中

List<String> result = stream.collect(Collectors.toList());
//或
Set<String> result = stream.collect(Collectors.toSet());
//如果想指定集合种类
TreeSet<String> result = stream.collect(Collectors.toCollection(TreeSet :: new));

连接流中所有字符串

String result = stream.collect(Collectors.joinjing());
//想加分割符
String result = stream.collect(Collectors.joinjing(","));
//如果不是字符串，得先转成字符串
String result = stream.map(Object :: toString).collect(Collectors.joining(","));

对流的结果约简为总和、平均值、最大值或最小值

IntSummaryStatistics summary = stream.collect(Collectors.summarizingInt(String :: length));
double averageWordLength = summary.getAverage();
double maxWordLength = summary.getMax();

收集到映射表中
假设有Stream<Person>

Map<Integer, String> idToName = people.collect(Collectors.toMap(Person :: getId, Person :: getName));
//第二值也可使用函数
Map<Integer, String> idToName = people.collect(Collectors.toMap(Person :: getId, Function.identity()));

如果有多个元素相同的键将会抛出IllegalStateExcpetion对象
这时可以使用第三个函数来处理冲突

Stream<Locale> locale = Stream.of(Locale.getAvailableLocales());
Map<String, String> languages = locales.collect(
    Collectors.toMap(
    　　Locale :: getDisplayLanguage,
    　　l -> l.getDisplayLanguage(l),
    　　(existingValue, newValue) -> existingValue
　　)
);

群组和分区
groupingBy一种更方便的方法，它会见现有的集与新集合并。

Map<String, List<Locale>> countryToLocales = locales.collect(Collectors.groupingBy(Locale :: getCountry));
List<Local> swissLocales = countryToLocales.get("CH")；

分类函数是断言函数，在这种情况下使用partitioningBy比使用groupingBy更高效

Map<Boolean, List<Locale>> englishAanOtherLocales = locales.collect(
Collectors.partitioningBy(l -> l.getLanguage().equals("en")));
List<Local> englishLocales =englishAndToLocales.get(true)；

groupingByConcurrent方法使用并行流时可获得并行映射表与toConcurrentMap方法类似。

下游收集器

//groupingBy产生的映射表，它的每个值是列表，想获得集就得
Map<String, Set<Locale>>countryToLocaleSet = locales.collect(groupingBy(Locale :: getCountry, toSet()));
//counting收集元素个数
Map<String, Long> countryToLocalCounts = locales.collect(groupingBy(Locale :: getCountry, counting()));
//summing(Int|Long|Double) 接受引元，产生它们的和
Map<String, Integer> stateToCityPopulation = locales.collect(
　　groupingBy(City :: getState, summingInt(City :: getPopulation)));
//maxBy、minBy获取最大、小值
Map<String, Optional<City>>stateToLargestCity = cities.collect(
　　groupingBy(City :: getState, maxBy(Comparator.comping(City :: getPopulation))));
//mapping方法使用函数
Map<String, Optional<String>> stateToLargestCityName = cities.collect(
　　groupingBy(City :: getState, mapping(City :: getName, maxBy(Comparator.comping(String :: length)))));
//mapping方法收集到集
Map<String, Set<String>> countryToLanguages = locales.collect(
　　groupingBy(Locale :: getDisplayCountry, mapping(Locale :: getDisplayLanguage, toSet())));
//IntSummaryStatistics使用汇总(适用int、long、double)
Map<String, IntSummaryStatistics> stateToCityPopulationSummary = cities.collect(
　　groupingBy(Ctiy :: getState, summarizing(Ctiy :: getPopulation)));