这篇文章找不到可以使用的可以看看这个: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实战(多练习)的更多相关文章

  1. 行为参数化与lambda表达式 - 读《Java 8实战》

    零. 概述 第一部分:1~3章 主要讲了行为参数化和Lambda表达式 第二部分:4~7章 主要讲了流的应用,包括流与集合差异,流的操作,收集器,注的并行执行 第三部分:8~12章 主要讲了怎样用Ja ...

  2. Java8学习(3)- Lambda 表达式

    猪脚:以下内容参考<Java 8 in Action> 本次学习内容: Lambda 基本模式 环绕执行模式 函数式接口,类型推断 方法引用 Lambda 复合 上一篇Java8学习(2) ...

  3. [Code] 变态之人键合一

    目的也比较单纯,选一门语言,走向人键合一. 选了两本书作为操练场:<精通Python设计模式>.<Data Structure and Algorithm in Python> ...

  4. Lambda的使用与实战

    简介 (下面的简介也可以自己百度,一般进来的都是想知道怎么去用,所以这里主要也是重点在用法与实战上) Lambda表达式是Java SE 8中一个重要的新特性.lambda表达式允许你通过表达式来代替 ...

  5. 读书笔记,《Java 8实战》,第三章,Lambda表达式

    第一节,Lambda管中窥豹    可以把Lambda表达式理解为简洁地表示可传递的匿名函数的一种方式,它没有名称,但它有参数列表.函数主题和返回值.    本节介绍了Lambda表达式的语法,它包括 ...

  6. 乐字节-Java8核心特性实战之Lambda表达式

    大家好,小乐又来给大家分享Java8核心特性了,上一篇文章是<乐字节|Java8核心实战-接口默认方法>,这次就来讲Java8核心特征之Lambda表达式. Java8 引入Lambda表 ...

  7. java8实战二------lambda表达式和函数式接口,简单就好

    一.Lambda 可以把Lambda表达式理解为简洁地i表示可传递的匿名函数的一种方式:它没有名称,但它有参数列表.函数主体.返回类型,可能还是一个可以抛出的异常列表. 听上去,跟我们用的匿名类,匿名 ...

  8. Java8 Lambda表达式实战之方法引用(一)

    方法的引用 方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法,方法引用提供了一种引用而不执行方法的方式,如果抽象方法的实现恰好可以使用调用另外一个方法来实现,就有可能可以使用方法引用 方法 ...

  9. 《JAVA8实战》读书笔记之传递方法和传递lambda

    传递方法: 假设 你有一个Apple类,它 有一个getColor方法,还有一个变量inventory保存着一个Apples的列表.你可能想要选出所 有的绿苹果,并返回一个列表.通常我们用筛选(fil ...

随机推荐

  1. QT的lineidet的光标问题

    http://blog.csdn.net/Howard_Liu1314/article/details/10456165

  2. linux下 signal信号机制的透彻分析与各种实例讲解

    转自:http://blog.sina.com.cn/s/blog_636a55070101vs2d.html 转自:http://blog.csdn.net/tiany524/article/det ...

  3. June 21st 2017 Week 25th Wednesday

    Discontent is the first step in progress. 不知足是前进中的第一步. Several days ago, I wrote down a quote which ...

  4. org.openqa.selenium.WebDriverException: unknown error: missing or invalid 'entry.level'

    错误原因:chrome与chromedriver版本号不匹配,升级后即可解决

  5. Centos 7 安装Anaconda3

    1.首先下载地址: https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/ 使用清华镜像下载速度快 2.安装 bash Anaconda3-5.1 ...

  6. sql的寫法,推薦的寫法,全文索引提高類似like查詢的效率

    說明:logistics_detail表中每個deliver_id可能對應多個loginticsType,但是我們只要獲取最大的那一個. SELECT dm.delivery_code,dm.deli ...

  7. 解决vuex requires a Promise polyfill in this browser问题

    造成这种现象的原因归根究底就是浏览器对ES6中的promise无法支持,因此需要通过引入babel-polyfill来是我们的浏览器正常使用es6的功能 首先通过npm来安装: npm install ...

  8. Java 分支结构

    Java 分支结构 - if...else/switch 顺序结构只能顺序执行,不能进行判断和选择,因此需要分支结构. Java 有两种分支结构: if 语句 switch 语句 if 语句 一个 i ...

  9. JS n秒后自动跳转实例

    <p><a href="<?php echo base_url();?>usercenter/index" id="message" ...

  10. vue 方法相互调用注意事项与详解

    vue在同一个组件内: methods中的一个方法调用methods中的另外一个方法: 可以直接这样调用:this.$options.methods.test(); this.$options.met ...