Lambda实战(多练习)
- 这篇文章找不到可以使用的可以看看这个:https://www.cnblogs.com/shenlanzhizun/p/6027042.html
- import org.junit.Test;
- import java.math.BigDecimal;
- import java.time.LocalDate;
- import java.util.*;
- import java.util.stream.Collectors;
- import java.util.stream.Stream;
- /**
- * @auther hhh
- * @date 2019/1/3 22:07
- * @description
- */
- public class LambdaCombat {
- /**
- * lambda 表达式、方法的引用、Stream API实战
- */
- @Test//转换
- public void test1() {
- //将字符串转化为map
- /**
- * index.do?itemId=1&userId=1000&type=20&token=111111&key=index
- */
- String s = "index.do?itemId=1&userId=1000&type=20&token=111111&key=index";
- //转化为map,key为数组第0个,value为数组第一个,toMap有两个Function参数,以下代码代表输入一个数组输出一个数组中的值
- Map<String, String> map = Stream.of(s.split("&")).map(str -> str.split("=")).collect(Collectors.toMap(arr -> arr[0], arr -> arr[1]));
- System.out.println(map);//{type=20, userId=1000, index.do?itemId=1, key=index, token=111111}
- }
- private List<Book> bookTest() {
- List<Book> list = new ArrayList<>();
- //Integer id, String name, BigDecimal price, String type, LocalDate pulishDate
- list.add(new Book(1, "书1", 225.6d, "分类一", LocalDate.now().plusDays(10)));
- list.add(new Book(2, "书2", 225.6d, "分类一", LocalDate.now().plusDays(15)));
- list.add(new Book(3, "书3", 125.6d, "分类一", LocalDate.now().plusMonths(1)));
- list.add(new Book(4, "书4", 5.6d, "分类二", LocalDate.now().plusMonths(2)));
- list.add(new Book(5, "书5", 2.6d, "分类二", LocalDate.now().plusMonths(4)));
- list.add(new Book(6, "书6", 45.6d, "分类二", LocalDate.now().plusYears(1)));
- list.add(new Book(7, "书7", 55.6d, "分类三", LocalDate.now().minusYears(1)));
- list.add(new Book(8, "书8", 55.6d, "分类三", LocalDate.now().plusYears(2)));
- list.add(new Book(9, "书9", 25.16d, "分类四", LocalDate.now().minusYears(10)));
- list.add(new Book(10, "书10", 25.63d, "分类四", LocalDate.now().minusMonths(3)));
- return list;
- }
- @Test//重点掌握,很常见
- public void test2() {
- //取出所有book的ID放到List中
- List<Book> books = this.bookTest();
- List<Integer> list = books.stream().map(book -> book.getId()).peek(System.out::println).collect(Collectors.toList());
- System.out.println(list);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
- //使用方法的引用
- List<Integer> ids = books.stream().map(Book::getId).peek(System.out::println).collect(Collectors.toList());
- System.out.println(ids);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
- //取出ID以后其使用,分割,转化为一个字符串,先将其转成字符串,然后使用 , 拼接
- String s = books.stream().map(book -> book.getId().toString()).collect(Collectors.joining(","));
- System.out.println(s);//1,2,3,4,5,6,7,8,9,10
- String s1 = books.stream().map(book -> book.getId().toString()).collect(Collectors.joining(",", "(", ")"));//表示在最前面加一个括号在最后面加一个括号
- System.out.println(s1);//(1,2,3,4,5,6,7,8,9,10)
- String s2 = books.stream().map(book -> "'" + book.getId() + "'").collect(Collectors.joining(",", "(", ")"));
- System.out.println(s2);//('1','2','3','4','5','6','7','8','9','10') 每个字符使用单引号割开
- }
- @Test
- public void test3() {
- List<String> list = this.bookTest().stream().map(Book::getType).collect(Collectors.toList());
- System.out.println(list);//[分类一, 分类一, 分类一, 分类二, 分类二, 分类二, 分类三, 分类三, 分类四, 分类四]
- //去重
- List<String> list1 = this.bookTest().stream().map(Book::getType).distinct().collect(Collectors.toList());
- Set<String> set = this.bookTest().stream().map(Book::getType).collect(Collectors.toSet());
- System.out.println(list1);//[分类一, 分类二, 分类三, 分类四]
- System.out.println(set);//[分类二, 分类四, 分类三, 分类一]
- }
- @Test//排序
- public void test4() {
- //根据价格排序
- //从低到高,输出价格排序
- List<Double> list = this.bookTest().stream().map(Book::getPrice).sorted(Comparator.naturalOrder()).collect(Collectors.toList());
- //从高到低,输出价格排序
- List<Double> list1 = this.bookTest().stream().map(Book::getPrice).sorted(Comparator.reverseOrder()).collect(Collectors.toList());
- System.out.println("从低到高,输出价格排序:" + list);
- System.out.println("从高到低,输出价格排序:" + list1);
- //输出书本集合,从低到高排序
- List<Book> list2 = this.bookTest().stream().sorted((book1, book2) -> book2.getPrice().compareTo(book1.getPrice())).collect(Collectors.toList());
- System.out.println("输出书本集合,从低到高排序:" + list2);
- //输出书本集合,从高到低排序
- //转化为一个Comparator<Book>对象
- Comparator<Book> comparator = (book1, book2) -> book2.getPrice().compareTo(book1.getPrice());
- List<Book> books = this.bookTest().stream().sorted(comparator.reversed()).collect(Collectors.toList());
- System.out.println("输出书本集合,从高到低排序:" + books);
- System.out.println("--------------------------------------------");
- //按照价格排序从高到低,如果价格相同,按照出版时间排序从晚到早
- List<Book> list3 = this.bookTest().stream().sorted(comparator.reversed()).sorted(comparator.thenComparing((book1, book2) ->
- book2.getPulishDate().isAfter(book1.getPulishDate()) ? 1 : -1)).collect(Collectors.toList());
- System.out.println("按照价格排序从高到低,如果价格相同,按照出版时间排序从晚到早" + list3);
- //可以实现多个排序,类似数据库效果
- System.out.println("--------------------------------------------");
- //使用更简单的方式
- //默认排序,从低到高
- List<Book> list4 = this.bookTest().stream().sorted(Comparator.comparing(Book::getPrice)).collect(Collectors.toList());
- //从高到低
- List<Book> list5 = this.bookTest().stream().sorted(Comparator.comparing(Book::getPrice).reversed()).collect(Collectors.toList());
- //多个排序
- List<Book> list6 = this.bookTest().stream().sorted(Comparator.comparing(Book::getPrice).thenComparing(Book::getPulishDate).reversed()).collect(Collectors.toList());
- System.out.println(list6);
- }
- @Test
- public void test5() {
- //转化成一个map,key是ID,value是Book
- // Map<Integer,Book> map = this.bookTest().stream().collect(Collectors.toMap(book->book.getId(),book -> book));
- Map<Integer, Book> map1 = this.bookTest().stream().collect(Collectors.toMap(Book::getId, book -> book));
- System.out.println(map1);
- }
- @Test
- public void test6() {
- //计算平均价格
- Double avg = this.bookTest().stream().collect(Collectors.averagingDouble(Book::getPrice));
- System.out.println("计算平均价格:" + avg);
- //取出价格最高的一本书
- Book max = this.bookTest().stream().collect(Collectors.maxBy(Comparator.comparing(Book::getPrice))).get();
- System.out.println("取出价格最高的一本书:" + max);
- //取出价格最低的一本书
- Book min = this.bookTest().stream().collect(Collectors.minBy(Comparator.comparing(Book::getPrice))).get();
- System.out.println("取出价格最低的一本书" + min);
- //取出最早发布时间的书
- Book bookEarly = this.bookTest().stream().collect(Collectors.minBy(Comparator.comparing(Book::getPulishDate))).get();
- System.out.println("取出最早发布时间的书" + bookEarly);
- //找出最贵的,且是最新出版的
- Book book = this.bookTest().stream().collect(Collectors.maxBy(Comparator.comparing(Book::getPrice).thenComparing(Book::getPulishDate).reversed())).get();
- System.out.println("找出最贵的,且是最新出版的:" + book);
- }
- @Test
- public void test7() {
- //按类型分组
- //返回的是一个map,key对应的是类型,value对应的是每一种类型中的具体的书本
- Map<String, List<Book>> map = this.bookTest().stream().collect(Collectors.groupingBy(Book::getType));
- System.out.println("按类型分组" + map);
- map.keySet().forEach(key -> {
- System.out.println(key);
- System.out.println(map.get(key));
- }
- );
- //统计每本类型有多少本书,输出的是一个map<String,Long>,key是数组,Long是数量
- Map<String, Long> map1 = this.bookTest().stream().collect(Collectors.groupingBy(Book::getType, Collectors.counting()));
- System.out.println("统计每本类型有多少本书:" + map1);//{分类二=3, 分类四=2, 分类三=2, 分类一=3}
- //按照价格分类,求出每种类型的书籍的总价格
- Map<String, Double> map2 = this.bookTest().stream().collect(Collectors.groupingBy(Book::getType, Collectors.summingDouble(Book::getPrice)));
- System.out.println("按照价格分类,求出每种类型的书籍的总价格" + map2);
- //每种类型书籍的平均价格
- Map<String, Double> map3 = this.bookTest().stream().collect(Collectors.groupingBy(Book::getType, Collectors.averagingDouble(Book::getPrice)));
- System.out.println("每种类型书籍的平均价格:" + map3);
- //找出每种类型最贵的
- Map<String, Optional<Book>> map4 = this.bookTest().stream().collect(Collectors.groupingBy(Book::getType, Collectors.maxBy(Comparator.comparing(Book::getPrice))));
- System.out.println("找出每种类型最贵的" + map4);
- //找出每种类型最便宜的
- Map<String, Optional<Book>> map5 = this.bookTest().stream().collect(Collectors.groupingBy(Book::getType, Collectors.minBy(Comparator.comparing(Book::getPrice))));
- System.out.println(map5);
- System.out.println("----------------------------------------------------");
- Book maxBook = this.bookTest().stream().max(Comparator.comparing(Book::getPrice)).get();
- List<Book> maxBooks = this.bookTest().stream().filter(b -> BigDecimal.valueOf(b.getPrice()).compareTo(BigDecimal.valueOf(maxBook.getPrice())) == 0).collect(Collectors.toList());
- System.out.println("最贵的书有多本,取出最贵的多本书籍的集合"+maxBooks);
- System.out.println("----------------------------------------------------");
- //每种类型出版时间最晚的
- Map<String, Optional<Book>> map6 = this.bookTest().stream().collect(Collectors.groupingBy(Book::getType, Collectors.maxBy(Comparator.comparing(Book::getPulishDate))));
- }
- @Test
- public void test8() {
- //过滤
- //取出80块以上的书,时间从近到远
- this.bookTest().stream().filter(book -> book.getPrice() >= 80).sorted(Comparator.comparing(Book::getPulishDate).reversed()).forEach(System.out::println);
- List<Book> list = this.bookTest().stream().filter(book -> book.getPrice() >= 80).sorted(Comparator.comparing(Book::getPulishDate).reversed()).collect(Collectors.toList());
- System.out.println("取出80块以上的书,时间从近到远" + list);
- }
- }
- public static void main(String[] args) {//对String与Integer进行排序
- List<String> strings = Arrays.asList("4444","22","333");//从短到长
- Collections.sort(strings,(a,b)->a.length()-b.length());
- System.out.println(strings);//[22, 333, 4444]
- List<Integer> strings1 = Arrays.asList(4444,22,333);//从大到小
- Collections.sort(strings1,(a,b)->b-a);
- System.out.println(strings1);//[4444, 333, 22]
- }
- //如果单独只要过滤一个匹配值,可以使用Option.get(),可以直接获取value
- Student optStu = studentList.stream().filter(student -> "stuName".equals(student.getName())).findFirst().get();
Lambda实战(多练习)的更多相关文章
- 行为参数化与lambda表达式 - 读《Java 8实战》
零. 概述 第一部分:1~3章 主要讲了行为参数化和Lambda表达式 第二部分:4~7章 主要讲了流的应用,包括流与集合差异,流的操作,收集器,注的并行执行 第三部分:8~12章 主要讲了怎样用Ja ...
- Java8学习(3)- Lambda 表达式
猪脚:以下内容参考<Java 8 in Action> 本次学习内容: Lambda 基本模式 环绕执行模式 函数式接口,类型推断 方法引用 Lambda 复合 上一篇Java8学习(2) ...
- [Code] 变态之人键合一
目的也比较单纯,选一门语言,走向人键合一. 选了两本书作为操练场:<精通Python设计模式>.<Data Structure and Algorithm in Python> ...
- Lambda的使用与实战
简介 (下面的简介也可以自己百度,一般进来的都是想知道怎么去用,所以这里主要也是重点在用法与实战上) Lambda表达式是Java SE 8中一个重要的新特性.lambda表达式允许你通过表达式来代替 ...
- 读书笔记,《Java 8实战》,第三章,Lambda表达式
第一节,Lambda管中窥豹 可以把Lambda表达式理解为简洁地表示可传递的匿名函数的一种方式,它没有名称,但它有参数列表.函数主题和返回值. 本节介绍了Lambda表达式的语法,它包括 ...
- 乐字节-Java8核心特性实战之Lambda表达式
大家好,小乐又来给大家分享Java8核心特性了,上一篇文章是<乐字节|Java8核心实战-接口默认方法>,这次就来讲Java8核心特征之Lambda表达式. Java8 引入Lambda表 ...
- java8实战二------lambda表达式和函数式接口,简单就好
一.Lambda 可以把Lambda表达式理解为简洁地i表示可传递的匿名函数的一种方式:它没有名称,但它有参数列表.函数主体.返回类型,可能还是一个可以抛出的异常列表. 听上去,跟我们用的匿名类,匿名 ...
- Java8 Lambda表达式实战之方法引用(一)
方法的引用 方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法,方法引用提供了一种引用而不执行方法的方式,如果抽象方法的实现恰好可以使用调用另外一个方法来实现,就有可能可以使用方法引用 方法 ...
- 《JAVA8实战》读书笔记之传递方法和传递lambda
传递方法: 假设 你有一个Apple类,它 有一个getColor方法,还有一个变量inventory保存着一个Apples的列表.你可能想要选出所 有的绿苹果,并返回一个列表.通常我们用筛选(fil ...
随机推荐
- IE Edge 下载文件的时候,文件名不能有windows不支持的特殊字符
IE Edge 下载文件的时候,文件名不能有windows不支持的特殊字符,比如:等. 马了个批的,其他浏览器包括IE就可以自动转换,比如:会自动变为_.
- JavaScrip File类拓展
##今天在做jsp的文件上传功能,想着上传文件后在当前页面把选取的文件信息展现出来,查来查去,发现了js中的file类,之前在w3c和runboob盯了好久找找不到....不过终于还是在网上查到了这个 ...
- unity3d中设计模式的学习<一>:泛型单例
单例是游戏开发中比较常见的设计模式,虽然针对的功能不同,但是有一些功能还是共有的,代码也不少,如果能放在一个基类里面是最好不过了,但是单例里需要有个instance功能来返回当前对象,所以这个功能必须 ...
- 转:Recsys2013论文导读
月中在香港参加recsys2013会议,文章不少,对我有价值的并不算多,再跟目前工作相关的就更少了.这里过滤了几篇我觉得比较有意思的文章,加上了自己的理解,作为导读. A Fast Parallel ...
- 应用监控Metrics
应用监控Metrics 一.Metrics简介 应用监控系统Metrics由Metrics.NET+InfluxDB+Grafana组合而成,通过客户端Metrics.NET在业务代码中 ...
- POJ-1845 Sumdiv---因子和(快速幂+快速加法+因子和公式)
题目链接: https://cn.vjudge.net/problem/POJ-1845 题目大意: 求AB的因子和 解题思路: 先将A质因数分解,然后B次方的质因数指数就是乘上B即可 这里要mod9 ...
- UVa 10048 - Audiophobia(Floyd变形)
链接: https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem& ...
- virtualbox 安装 mac os x lion 10.7实现全屏显示!
1. 启动Virtual Box虚拟机,在虚拟机里编辑 /Library/Preferences/SystemConfiguration/com.apple.Boot.plist,找到 <dic ...
- python代码是解释型语言,为什么还有编译过程?
Python 代码在运行前,会先编译(翻译)成中间代码,每个 .py 文件将被换转成 .pyc 文件,.pyc 就是一种字节码文件,它是与平台无关的中间代码,不管你放在 Windows 还是 Linu ...
- 19、配置嵌入式servlet容器(下)
使用外置的Servlet 嵌入式Servlet容器:应用打成可执行的j ar 优点:简单.便携: 缺点:默认不支持JSP.优化定制比较复杂 使用定制器[ServerProperti ...