java8学习笔记

1.jpg

1.流

• 流是java API的新成员，它允许以声明式的方式处理数据集合（通过查询语句来表达，而不是临时编写一个实现），可以把流看成遍历数据集的高级迭代器
• 流可以透明的并行处理

示例：

import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.toList;
List<String> lowCaloricDishesName = menu.stream()
 .filter(d -> d.getCalories() < 400)  //选出400卡路里以下的菜肴
 .sorted(comparing(Dish::getCalories))  //按照卡路里排序
 .map(Dish::getName)   //提取菜肴的名称
 .limt(3)                             //截断流，使元素不超过给定数量
 .collect(toList());    //将所有的名称保存在List中

如果想利用多核架构并行执行这段代码，只需要把stream()换成parallelStream();
因为filter,sorted,map,collect等操作是与具体线程无关的高层次组件，所以他们内部实现可以是单线程的，也可能透明的充分利用电脑的多核架构；

2.流与集合

集合和流之间的差异就在于什么时候进行计算

• 集合：集合是一个内存中的数据结构，它包含数据结构中目前所有的值，集合中的每个元素都得先计算出来才能添加到集合中（你可以往集合中添加元素或者删除元素，但是不管什么时候，集合中的每个元素都是放在内存中的，元素都得先计算出来才能成为集合的一部分）（供应商驱动）
• 流：流是在概念上固定的数据结构（不能添加或者删除元素）其元素按需计算，从另一个角度说，流就像是一个延迟创建的集合，只要在消费者要求的时候才会计算值（需求驱动，实时制造）

2.1 流只能遍历一次

3.流操作

QQ截图20190419180918.png

• filter、map和Limit可以连成一条流水线，称为中间操作
• collect 触发流水线执行并且关闭它，称为终端操作，终端操作会从流水线生成结果，其结果是任何不是流的值，比如List，Integer甚至是void

long count = menu.stream()
 .filter(d -> d.getCalories() > 300)
 .distinct()
 .limit(3)
 .count();    //count操作返回的是一个long，不是流，所以是终端操作

QQ截图20190419181827.png

4.使用流

4.1筛选、切片

• 筛选信息---外部迭代

List<Dish> vegetarianDishes = new ArrayList<>();
for(Dish d: menu){
    if(d.isVegetarian()){
        vegetarianDishes.add(d);
   }
} 

• 筛选信息---内部迭代（Stream API）

import static java.util.stream.Collectors.toList;
List<Dish> vegetarianDishes = menu.stream().filter(Dish::isVegetarian).collect(toList());

• 流支持distinct方法，过滤重复数据

//筛选出列表中所有的偶数，并确保没有重复
List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
numbers.stream()
 .filter(i -> i % 2 == 0)
 .distinct()        
 .forEach(System.out::println); 

• 截断流--流支持limit(n)方法，返回一个不超过给定长度的流，所需的长度作为参数传递费limit

List<Dish> dishes = menu.stream()
 .filter(d -> d.getCalories() > 300)              //卡路里大于300
 .limit(3)                               //符合卡路里大于300的前三个元素
 .collect(toList());                //终端操作，流转化为List

• 跳过元素--流支持skip(n)方法，返回一个扔掉了前n个元素的流。如果元素不足n个，则返回一个空流

List<Dish> dishes = menu.stream()
 .filter(d -> d.getCalories() > 300)
 .skip(2)     //跳过卡路里大于300的前两个元素
 .collect(toList());

4.2 映射

4.2.1 对流中每一个元素应用函数

• 流支持Map方法，它会接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素

List<Integer> dishNameLengths = menu.stream()
 .map(Dish::getName)                    //map 提取名称
 .map(String::length)                      // 返回 名称长度
 .collect(toList());                           //终端操作，流转化为List

4.2.2 流的扁平化

• 使用flatMap方法--各个数组并不是分别映射成一个流，而是映射成流的内容

/**
** 对于一张单词表，如何返回一张列表，列出里面 各不相同的字符 呢？例如，给定单词列表["Hello","World"]，你想要返回列表["H","e","l", "o","W","r","d"]
**/
List<String> uniqueCharacters =
 words.stream()
 .map(w -> w.split(""))            //将每个单词转换成由其字母构成的数组
 .flatMap(Arrays::stream)        //将各个生成流扁平化为单个流
 .distinct()
 .collect(Collectors.toList()); 

4.3查找和匹配

Stream API提供了allMatch，anyMatch,noneMatch,findFirst和findAny方法匹配数据集中的某些元素

4.3.1 检查谓词是否至少匹配一个元素

• anyMatch方法--流中是否有一个元素能匹配给定的谓词,该方法返回一个Boolean，因此是一个终端操作

if(menu.stream().anyMatch(Dish::isVegetarian)){
    System.out.println("The menu is (somewhat) vegetarian friendly!!");
} 

4.3.2 检查谓词是否匹配所有元素

• allMatch方法的工作原理和anyMatch类似，但它会看流中的元素是否都能匹配给定的谓词

boolean isHealthy = menu.stream()
   .allMatch(d -> d.getCalories() < 1000);  //所有菜的热量都低于1000卡路里 才返回true；

• noneMatch方法--确保流中没有任何元素与给定的谓词匹配

boolean isHealthy = menu.stream()
 .noneMatch(d -> d.getCalories() >= 1000);  //所有菜的热量都低于1000卡路里 才返回true；

• anyMatch,allMatch和noneMatch这三个操作都用到了所谓的短路，相当于java中&& 和 || 运算符短路在流中的版本

4.3.3 查找元素

• findAny 方法将返回当前流中的任意元素

Optional<Dish> dish = menu.stream()
     .filter(Dish::isVegetarian)   //筛选素菜
     .findAny();  //找到一个立即结束流返回

• Optional<T>类（java.util.Optional）是一个容器类，代表一个值存在或不存在。在上面的代码中，findAny可能什么元素都没找到

4.3.4 查找第一个元素

List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> firstSquareDivisibleByThree =
 someNumbers.stream()
 .map(x -> x * x)
 .filter(x -> x % 3 == 0)
 .findFirst(); // 9 

4.4 归约

4.4.1元素求和

//reduce求和：第一个参数是求和初始值
List<Integer> numbers = Arrays.asList(5,7,9,12,45,67);
Integer total = numbers.stream().reduce(0, Integer::sum);  //145
//流中没有任何元素，无法返回和的情况
List<Integer> numbers11 = Arrays.asList();
Optional<Integer> total1 = numbers11.stream().reduce(Integer::sum); //Optional.empty

4.4.2最大值和最小值

List<Integer> numbers = Arrays.asList(5,7,9,12,45,67);
Optional<Integer> max = numbers.stream().reduce(Integer::max);  //Optional[67]
Optional<Integer> min = numbers.stream().reduce(Integer::min);    //Optional[5]

示例：求数组大小

List<Integer> numbers = Arrays.asList(5,7,9,12,45,67);
Integer ArrayTotal = numbers.stream().map(e -> 1).reduce(0,Integer::sum); // 6
long count = numbers.stream().count(); 

以上代码有一个问题，它有一个暗含的装箱成本，每个Integer都必须拆箱成一个原始类型，在进行求和

4.5 数值流

4.5.1原始类型流特化

java8引入了三个原始类型特化流接口来解决拆箱问题：IntStream,DoubleStream和LongStream，分别将流中的元素特化为int，long和double，从而避免了暗含的装箱成本。

1.映射到数值流

将流转换为特定版本的常用方法是mapToInt,mapToDouble,mapToLong,这些方法和前面说的map方法的工作方式一样，只是返回的是一个特化流，而不是Stream<T>

int calories = menu.stream()                      //返回一个Stream<dish>
 .mapToInt(Dish::getCalories)
 .sum(); 
````VUE