跟上Java的脚步(一) Stream (8&9)

编程语言就像生态系统一样，新的语言会出现，旧语言则被取代，除非它们不断演变。所以Java 也在不断地变化。

　Java 8于2014年3月发布.如：Lambda 表达式、Stream API、Date Time API、Optional 类、Nashorn, JavaScript 等等的变化

　Java 9于2017年9月发布.如：改进的 Stream API、改进 Optional 类、集合工厂方法、私有接口方法、改进的 Javadoc符合兼容 HTML5 标准 等等的变化

　Java 10于2018年3月发布.如：局部变量类型推断var关键字、垃圾回收器优化、新增的API类库(Optional.orElseThrow()，copyOf方法等等)等等的变化

　Java 11于2018年9月发布,如：Collection.toArray(IntFunction)、字符串加强(repeat()，strip()，isBlank()，lines())、HttpClient 等等的变化

　Java 12 于2019年3月19日发布.如：低暂停时间的 GC、字符串(.indent()、.transform())、Files.mismatch() 、switch-case语句的改进、支持unicode 11、 等等的变化

　Java 13于 2019年9月17日发布.如：字符串(String::stripIndent(),String::translateEscapes(),String::formatted(Object... args)) 、switch-case语句的改进、引入Text Blocks 等等

　Java 14 于2020年3月17日 发布 如：record类型、switch-case语句的改进(yield)、instanceof 改动、改进了对NullPointerExceptions的描述 等等变化

　Java 15 于2020年9月15日 发布 如：Hidden Classes、Text Blocks等等

　　网址：http://openjdk.java.net/projects/jdk/15/

　　

　　看一个text Blocks 的例子：

　　

　这些改变会让编程更容易，我们再也不用编写啰唆的语句了。

-- Java天资不错。从一开始，它就是一门精心设计的面向对象的语言，提供了大量有用的库。由于线程和锁，他天生就支持小规模的并发。--

Stream（jdk8）

简介：

　　Java 8的主要好处在于它提供了更多的编程工具和概念，能以更快、更简洁、更易于维护的方式解决新的或现有的编程问题。

　　流处理 java.util.stream  Stream<T> 是一个比较花哨的迭代器。是一个延迟创建的集合。

　　  就像汽车组装流水线一样，汽车排队进入加工站，每个加工站会接收、修改汽车，然后将之传递给下一站做进一步的处理。

　　  尽管流水线实际上是一个序列，但不同加工站的运行一般是并行的。

　　  Java 8可以拿到几个CPU核，分别执行你的Stream操作流水线——这是几乎免费的并行，用不着去费劲搞Thread了。

　　优点：简单易懂 灵活 性能好！

　　举个栗子： 取价格＜400 然后 按价格排序 最后返回list; 就像一个流水线 且代码清晰可读；

 

 　　上代码：

List<Menu> resultList=
                menuList.stream()
                        .filter(d -> d.getPrice()<400)
                        .sorted(comparing(Menu::getPrice))
                        .collect(Collectors.toList());

 

 　　遍历流：看上面的代码可以看出：其实Stream已经帮我们做好了迭代的工作，只要告诉他去做什么就可以了。如果想遍历 用 forEach循环内部成员 。

 menuList.stream().forEach(System.out::println);

使用： 

　　三要素：

　　　　1.数据源-如list 

　　　　2.中间操作-流水线 如 filter map limit sorted distinct

　　　　3.终端操作 如 .collect(Collectors.toList()); .count(); forEach 之类的

filter &JDK9中新增的 takeWhile 和 dropWhile 

 　　看一下他们的区别： takeWhile 在没有西瓜！ 而 dropWhile 是它的取反！

 　　.skip(1) 略过

 接收数组：Arrays.stream(arr) 直接创建流Stream.of(1,10,100) 创建空流Stream.empty();

 流的扁平化：flatMap

 是否存在 anyMatch 当然也有：全符合要求 allMatch ，与之相反没有一个符合：noneMatch 而且他们都是短路的~

 

 返回一个符合条件的：findAny 随便 ，findFirst 第一个

 　　遇到reduce 求和如此简单

 乘

换一个：+

再换一个+ 注意我写的是int哟

最大值，当然也有最小值

 

 拼个字符串玩

数值流：IntStream

 随机生成数字 如此简单 

 

 偶数

 举个栗子：

水果的数量：

Long count=menuList.stream()
                .count();
        System.out.println(count);

最贵的水果：

Comparator<Menu> menuComparator = Comparator.comparingDouble(Menu::getPrice);
        Optional<Menu> c=menuList.stream()
                .collect(maxBy(menuComparator));
        System.out.println(c);

　　用reducing

Comparator<Menu> menuComparator = Comparator.comparingDouble(Menu::getPrice);
        Optional<Menu> c=menuList.stream()
                .collect(reducing((a,b)->a.getPrice()>b.getPrice()?a:b));
        System.out.println(c);

 水果的总价：

Double sumPrice=menuList.stream()
                .collect(summingDouble(Menu::getPrice));
        System.out.println(sumPrice);

 水果的平均价格：

Double avgPrice=menuList.stream()
                .collect(averagingDouble(Menu::getPrice));
        System.out.println(avgPrice);

 拼接水果的名字：

String fName=menuList.stream()
                .map(Menu::getName)
                .collect(joining());
        System.out.println(fName);
        String fName2=menuList.stream()
                .map(Menu::getName)
                .collect(joining(","));
        System.out.println(fName2);

 分组：

按分类分组： 

Map<String,List<Menu>> result1 = menuList.stream().collect(groupingBy(Menu::getType));
        System.out.println(result1);

 按价格分组：

public enum LEVEL{A,B,C}

Map<LEVEL,List<Menu>> result2 = menuList.stream().collect(groupingBy(d->{
            if(d.getPrice()<100) return LEVEL.A;
            else if (d.getPrice()<500) return LEVEL.B;
            else return LEVEL.C;
        }));
        System.out.println(result2);

筛选&分组：价格大于500 并分组：filtering

Map<String,List<Menu>> result1 = menuList.stream().collect(groupingBy(Menu::getType,filtering(d->d.getPrice()>500,toList())));
        System.out.println(result1);

分组&只取名字

Map<String,List<String>> result = menuList.stream().collect(groupingBy(Menu::getType,mapping(Menu::getName,toList())));
        System.out.println(result);

水果和蔬菜的数量：

Map<String,Long> result = menuList.stream().collect(groupingBy(Menu::getType,counting()));
        System.out.println(result);

价格最高的：

Map<String,Optional<Menu>> result = menuList.stream().collect(groupingBy(Menu::getType,maxBy(comparingDouble(Menu::getPrice))));
        System.out.println(result);

求和∑

Map<String,Double> result = menuList.stream().collect(groupingBy(Menu::getType,summingDouble(Menu::getPrice)));
        System.out.println(result);

蔬菜和水果的价格分布

 分区函数=分组的特殊情况：partitioningBy 

 

 下一篇 继续 -》》》》https://www.cnblogs.com/DarGi2019/p/11583624.html

@