【代码】JDK 8 常用新特性代码样例

已于 2022-10-23 03:31:23 修改
阅读量174 收藏
点赞数
分类专栏： 实践随记 文章标签： java 前端 javascript
于 2022-10-23 03:10:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16905859/article/details/127470292
版权

jdk 8 常用新特性代码样例

// 分组、统计数量
Map<String, Long> collect = list.parallelStream().collect(Collectors.groupingBy(ReportDetailInfo::getCourier,Collectors.counting()));

// 仅分组
Map<String, List<ReportDetailInfo>> collect = list.parallelStream().collect(Collectors.groupingBy(ReportDetailInfo::getCourier));

/**
java8新特性--Stream将List转为Map汇总
Stream将List转换为Map，使用Collectors.toMap方法进行转换

背景：User类，类中分别有id，name,age三个属性。List集合,userList，存储User对象

1、指定key-value，value是对象中的某个属性值。

 Map<Integer,String> userMap1 = userList.stream().collect(Collectors.toMap(User::getId,User::getName));

2、指定key-value，value是对象本身，User->User 是一个返回本身的lambda表达式

Map<Integer,User> userMap2 = userList.stream().collect(Collectors.toMap(User::getId,User->User));

3、指定key-value，value是对象本身，Function.identity()是简洁写法，也是返回对象本身

 Map<Integer,User> userMap3 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity()));

4、指定key-value，value是对象本身，Function.identity()是简洁写法，也是返回对象本身，key 冲突的解决办法，这里选择第二个key覆盖第一个key。

 Map<Integer,User> userMap4 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity(),(key1,key2)->key2));
**/

// 判断NULL，抛异常
Optional.ofNullable(memberGoods).orElseThrow(()->{throw new AppException("");});


// 返回年纪最大对象
Optional<Employee > userOp= userList.stream().max(Comparator.comparingInt(Employee ::getAge));
Employee maxEmp = userOp.get();


public void test() {
   User user = null;
   user = Optional.ofNullable(user).orElse(createUser());
  // user = Optional.ofNullable(user).orElseGet(() -> createUser());
}
public User createUser(){
   User user = new User();
   user.setName("zhangsan");
   return user;
}


// Map用法
List<StaffPublic> result = staff.stream().map(temp -> {
    StaffPublic obj = new StaffPublic();
    obj.setName(temp.getName());
    obj.setAge(temp.getAge());
    if ("mkyong".equals(temp.getName())) {
        obj.setExtra("this field is for mkyong only!");
    }
    return obj;
}).collect(Collectors.toList());


//flatMap - 将words数组中的元素再按照字符拆分，然后字符去重，最终达到["h", "e", "l", "o", "w", "r", "d"]
//如果使用map，是达不到直接转化成List<String>的结果

// 如果使用的是map方法，返回的是[ ...['y', 'o', 'u', 'r'], ['n', 'a', 'm', 'e']]
// 如果使用的是flatMap方法，返回的是['y', 'o', 'u', 'r', 'n', 'a', 'm', 'e']
List<String> stringList = words.stream()
        .flatMap(word -> Arrays.stream(word.split(" ")))
        .distinct() // 去重
        .collect(Collectors.toList());


// 循环
stringList.forEach(e -> System.out.println(e));

// 分组，过滤
 Map<String, List<Apple>> AppMap2=
 appleList.stream()
 		.filter((Apple a)->a.getWeight()>150) //筛选出大于150的
                .collect(groupingBy(Apple::getColor)); //按颜色分组  最后得到map

Map<Integer, List<User>> collect = list.stream().collect(Collectors.groupingBy(User::getAge));




// 计算&统计：
int max = numbers.stream().mapToInt(x -> x).max().getAsInt();
int min = numbers.stream().mapToInt(x -> x).min().getAsInt();
long count = numbers.stream().mapToInt(x -> x).count();
double avg = numbers.stream().mapToInt(x -> x).average().getAsDouble();
int sum = numbers.stream().mapToInt(x -> x).sum();

// 也可以用IntSummaryStatistics类来得到统计结果：
IntSummaryStatistics stat = numbers.stream().mapToInt(x -> x).summaryStatistics();
int max = stat.getMax();
int min = stat.getMin();
long count = stat.getCount();    
double avg = stat.getAverage();
long sum = stat.getSum();


// 匿名类
import lombok.AllArgsConstructor;
import lombok.Data;

public @Data @AllArgsConstructor class Cat {
    private String name;
    private double height;
    private double weight;
}
// public int compare(Cat o1, Cat o2) 
Collections.sort(catList, (o1, o2) -> {
    if (o1.getHeight() > o2.getHeight()) {
        return 1;
    } else if (o1.getHeight() < o2.getHeight()) {
        return -1;
    } else {
        return 0;
    }
});


// 排序
catList.sort(Comparator.comparing(Cat::getWeight));
// 逆向排列
catList.sort(Comparator.comparing(Cat::getWeight).reversed());

// 函数式接口
import java.util.function.Consumer;
import java.util.function.Predicate;

import lombok.AllArgsConstructor;
import lombok.Data;

// 有一个订单类，有id，金额，运费这些属性。这个订单有一个折扣方法，我们希望能够根据营销活动，动态修改优惠方案。
public @Data @AllArgsConstructor class Order {
    private long id;
    private double payment;
    private double freight;

    // 优惠政策
    public Order discount(Order order, Predicate<Order> predicate, Consumer<Order> consumer) {
        // 满足Predicate的条件，返回true
        if (predicate.test(order)) {
            // 接收订单对象，对订单对象进行处理
            consumer.accept(order);
        }

        return order;
    }
}
// 新建一个订单，506.5的金额，10.0的运费
Order order = new Order(123, 506.5, 10.0);
// 满足金额>=99的条件，则设置运费为0
order.discount(order,  o -> o.getPayment() >= 99, o -> o.setFreight(0));


 // reduce() ：把Stream 元素组合起来(从1加到5),例如，字符串拼接，数值的 sum，min，max ，average 都是特殊的 reduce。
public static void test5() {
    List list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    System.out.println(list.stream().reduce((param1, param2) -> (int) param1 + (int) param2).get());
}


// min()，max()  找到最大值最小值
list.stream().min((param1, param2) -> (int) param1 > (int) param2 ? 1 : -1).get();
list.stream().max((param1, param2) -> (int) param1 > (int) param2 ? 1 : -1).get();

/**
总结：
1. 流式操作的引入：提高执行效率（并行），方便编码（有很多API 可用），提高可读性。
2. 流的分类：可以分为串行流和并行流；对于操作：可以分为中间操作和最终操作
3. 流API：
        中间操作：
                filter()： 对元素进行过滤；
                sorted()：对元素排序；
                map()：元素映射；
                distinct()：去除重复的元素 。
        最终操作：
                forEach()：遍历每个元素；
                reduce()：把Stream 元素组合起来。例如，字符串拼接，数值的 sum，min，max ，average 都是特殊的 reduce。
                collect()：返回一个新的集合。
                min()：找到最小值。
                max()：找到最大值。
            
Ps1：除了上面介绍的方法，还有如下方法：
Intermediate：
        map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered
Terminal：
        forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
Short-circuiting：
        anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

**/

	/**
	 * 多条件去重
	 * @param list
	 */
	public static void order() {
	    list.stream().collect(Collectors.collectingAndThen(
	            Collectors.toCollection(() -> new TreeSet<>(
	                    Comparator.comparing(o -> o.getAge() + ";" + o.getName()))), ArrayList::new)).forEach(u -> println(u));
	}


	/**
	 * 转set
	 */
	public static void toSet() {
	    Set<User> collect = list.stream().collect(Collectors.toSet());
	    Iterator<User> iterator = collect.iterator();
	    while(iterator.hasNext()) {
	        System.out.println(iterator.next().getUserId());
	    }
	}

	/**
	 * 转map
	 */
	public static void toMap() {
	    Map<Integer, User> collect = list.stream().collect(Collectors.toMap(User::getUserId, u -> u));
	    for (Integer in : collect.keySet()) {
	      User u = collect.get(in);//得到每个key多对用value的值
	      println(u);
	    }
	}

	/**
	 *map
	 */
	public static void map() {
	    list.stream().map(User::getUserId).forEach(userId -> println(userId));
	    list.stream().mapToInt(User::getAge).forEach(userId -> println(userId));
	    list.stream().mapToDouble(User::getUserId).forEach(userId -> println(userId));
	    list.stream().mapToLong(User::getUserId).forEach(userId -> println(userId));
	}

	/**
	 * 查找与匹配
	 * allMatch方法与anyMatch差不多，表示所有的元素都满足才返回true。noneMatch方法表示没有元素满足
	 */
	public static void anyMatch() {
	    boolean anyMatch = list.stream().anyMatch(u -> u.getAge() == 100);
	    boolean allMatch = list.stream().allMatch(u -> u.getUserId() == 10);
	    boolean noneMatch = list.stream().noneMatch(u -> u.getUserId() == 10);
	    println(anyMatch);
	    println(allMatch);
	    println(noneMatch);
	}

	/**
	 * reduce操作
	 */
	public static void reduce() {
	    Optional<Integer> sum = list.stream().map(User::getAge).reduce(Integer::sum);
	    Optional<Integer> max = list.stream().map(User::getAge).reduce(Integer::max);
	    Optional<Integer> min = list.stream().map(User::getAge).reduce(Integer::min);
	    println(sum);
	    println(max);
	    println(min);
	}


	/**串行排序**/
	List<String> list = new ArrayList<String>();
	for(int i=0;i<1000000;i++){
		double d = Math.random()*1000;
		list.add(d+"");
	}
	long start = System.nanoTime();//获取系统开始排序的时间点
	int count= (int) ((Stream) list.stream().sequential()).sorted().count();
	long end = System.nanoTime();//获取系统结束排序的时间点
	long ms = TimeUnit.NANOSECONDS.toMillis(end-start);//得到串行排序所用的时间
	System.out.println(ms+”ms”);

	/**并行排序：**/
	List<String> list = new ArrayList<String>();
	for(int i=0;i<1000000;i++){
		double d = Math.random()*1000;
		list.add(d+"");
	}
	long start = System.nanoTime();//获取系统开始排序的时间点
	int count = (int)((Stream) list.stream().parallel()).sorted().count();
	long end = System.nanoTime();//获取系统结束排序的时间点
	long ms = TimeUnit.NANOSECONDS.toMillis(end-start);//得到并行排序所用的时间
	System.out.println(ms+"ms");
	// 串行输出为 1200ms，并行输出为 800ms。可见，并行排序的时间相比较串行排序时间要少不少。
@羡鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
jdk8新特性常用功能使用实例
baidu_30829927的博客
05-14 146
jdk8新特性常用功能使用实例
JDK8新特性
有多勉为其难的博客
09-05 2440
Stream是JDK8中引入，Stream是一个来自数据源的元素序列并支持聚合操作。可以让你以一种声明的方式处理数据，Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。一个stream是由三部分组成的。数据源，零个或一个或多个中间操作，一个或零个终止操作。
JDK8新特性带案例讲解
最新发布
a1374469523的博客
05-24 386
默认方法通过实例调用，静态方法通过接口名调用默认方法可以被继承，实现类可以直接调用接口默认方法，也可以重写接口默认方法静态方法不能被继承，实现类不能重写接口的静态方法，只能使用接口名调用在JDK中帮我们提供的有函数式接口，主要是在 java.util.function 包中。注意：Stream和IO流(InputStream/OutputStream)没有任何关系，请暂时忘记对传统IO流的固有印象！
【JavaSE】jdk8新特性
知识输出、记录学习
09-22 4307
尚硅谷JavaSE笔记——jdk8新特性。个人实践总结，知识记忆架构不一定适合所有人，建议先阅读文章目录
JDK8的新特性
huyulong0612的博客
07-21 5386
java8 的新特性
JDK8新特性: lambda表达式 接口新特性 函数式接口 Option类 方法引用 Stream API 日期API
qq_44648800的博客
06-11 149
JAVA8新特性: 发展史 lambda表达式 接口新特性 函数式接口 Option类 方法引用 Stream API 日期API
jdk8新特性对应代码
07-14
以下是一些JDK8的主要新特性及其相关代码解释： 1. **Lambda表达式**： Lambda表达式是JDK8最重要的新特性之一，它允许函数作为方法参数，简化了匿名内部类的使用。Lambda表达式的语法简洁明了，形式为`...
JDK8新特性（pdf版）
06-26
JDK8新特性 JDK8是Java开发平台的最新版本，自从1995年Java的诞生以来，Java已经发展了二十多年， Java仍是企业和开发人员的首选开发平台。JDK8新特性课程内容包括了解Java发展史、Lambda表达式、接口的增强、函数...
JDK8 新特性学习.rar
01-19
JDK8是Java开发工具包的一个重要版本...通过学习和掌握这些JDK8的新特性，开发者能够编写出更高效、更简洁、更易维护的代码。无论是对于初学者还是经验丰富的开发者，深入理解这些特性都将对提升Java编程技能大有裨益。
JDK8核心新特性
06-20
JDK8已经发行有几年了，在该版本中推出了不少新特性，其中比较有代表的新特性有：Lambda表达式，Stream流，方法引用。在网上也有很多关于这些新特性的介绍，但个人觉得网上的很多文字对新特性的介绍是不够全面的，...
day22_JDK8新特性.pdf
11-02
总的来说，JDK8的这些新特性显著改善了Java的开发体验，使得Java在现代软件开发中保持了竞争力。Lambda表达式的引入让Java具备了函数式编程的能力，Stream API则提供了高效的集合处理方式，这些都极大地提升了开发者...
jdk8新特性例子
10-23
Jdk8新特性例子，内容包含 接口默认方法， 函数引用， java.util.stream api 和java.time api map的新增方法等。例子采用记事本编写，下载者需自行下载jdk8安装并配置好环境，编译（javac）运行（java）
java中Map的常用方法总结
2201_75452232的博客
02-21 5905
java中Map的常用方法
java第10天
qq_46426476的博客
12-28 384
第1章 Lambda表达式 1.1 概述 ​ Lambda 表达式（lambda expression）是一个匿名函数。主要用来优化匿名内部类的结构。我们先看下传统的匿名内部类的使用方式。 new Thread(new Runnable() { @Override public void run() { System.out.println("有一个线程即将执行。"); } }).start(); ​ 这是一个开启线程的案例，在这个案例中，这个Runnab
java8新特性（简述十大新特性）
ywl470812087的博客
12-23 3399
你真的开始用JDK8了吗？如果你没有用上一些新特性，请别说自己使用了Java8。Java 8可谓是自Java 5以来最具革命性的版本了，她在语言、编译器、类库、开发工具以及Java虚拟机等方面都带来了不少新特性。我们来一一回顾一下这些特性。
JDK8十大新特性
qq_46469577的博客
05-16 9544
JDK十大新特性。
JDK8常用新特性的原理与代码演示
个人学习笔记库，一篇一篇记录成长的足迹
02-28 369
jdk8新特性，Labmda，Stream，Optional，时间处理，BASE64
JDK8新特性应用实践
m0_69526738的博客
05-08 437
() -> statement arg -> statement (arg1, arg2, …) -> { body-block } (Type1 arg1, Type2 arg2, …) -> { method-body-block;return value; } Lambda表达式有返回值，返回值的类型也由编译器推理得出。如果Lambda表达式中的语句块只有一行，则可以不用使用return语句，下列两个代码片段效果相同： Arrays.asList( “a”, “b”, “d”
（详细+示例）JDK8新特性二：方法引入详述
qq_41649001的博客
07-29 205
JDK8新特性 5 方法引入 5.1 定义 方法引入可以结合Lambda表达式让编写的代码变得更加精简，它提供了很多非常有用的语法，可以直接引用已有java类或对象的方法或者构造器，离不开Lambda表达式。 类别 静态方法引入 对象方法引入 实例方法引入 构造函数引入 5.2 方法引入规则 遵守： 引入的方法的形参（个数，对应位置类型）必须和函数接口中方法的形参（个数、对应位置类型）一致 如果函数接口中方法没有返回值，那么引入的方法可以有返回值或者没有返回值。 如果函数接口中方法有返回值，
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值