广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >关于使用Lambda表达式简化Comparator的使用问题
  • 134

0
分享到

关于使用Lambda表达式简化Comparator的使用问题

Lambda表达式Lambda简化ComparatorLambda简化 2023-05-14 14:05:35 134人浏览 独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录Comparator 接口接口简介定义一个示例类用来演示：Dog类接口方法介绍直接使用接口的抽象方法创建 Comparator 对象接口中的静态方法和默认创建 Comparato

Comparator 接口

使用集合时，如果需要实现集合元素排序的话，通常有两种选择，元素本身实现 Comparable 接口或者集合使用 Comparator 对象实现排序。这里来介绍一个 Comparator 这个类。

接口简介

Comparator 是一个函数式接口，这个可以从它的定义上看出来。它具有这个注解：@FunctionalInterface。

这个注解标注此接口属于函数式接口，意味着只能有一个抽象方法，但是带你进去看，你会发现两个抽象方法！

int compare(T o1, T o2);
boolean equals(Object obj);

这并不是定义错误，而是上面那个注解（@FunctionalInterface）的文档里有说明：如果接口声明了一个覆盖了 java.lang.Object 的全局方法之一的抽象方法，那么它不会计入接口的抽象方法数量中，因为接口的任何实现都将具有 java.lang.Object 或者其它地方的实现。 因此，它确实是只有一个抽象方法：

int compare(T o1, T o2);

定义一个示例类用来演示：Dog类

package com.draGon;

public class Dog {
	private String name;
	private int age;
	private double weight;
	
	public Dog(String name, int age, double weight) {
		super();
		this.name = name;
		this.age = age;
		this.weight = weight;
	}
	//省略 getter 和 setter 方法，使用 IDE 自动生成比较方便。
	//下面两个方法，也都可以自动生成。

	@Override
	public String toString() {
		return "Dog [name=" + name + ", age=" + age + ", weight=" + weight + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		long temp;
		temp = Double.doubleToLongBits(weight);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Dog other = (Dog) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(weight) != Double.doubleToLongBits(other.weight))
			return false;
		return true;
	}
}

接口方法介绍

这个接口虽然是一个函数式接口，但是它的方法可不少！所以，它可以实现非常丰富的排序功能！

直接使用接口的抽象方法创建 Comparator 对象

**排序规则是按照年龄升序。我这里使用的表达式为：

o1.getAge()-o2.getAge();

如果想要实现反序，调换 o1和o2的位置即可，但是我们不使用这种方式。下面会使用更加方便的方式。
**

1.使用原始的匿名内部类方式，实现 Comparator 对象。

package com.dragon;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class ComparatorTest {
	public static void main(String[] args) {
		//测试使用的集合，下面不再提供，只提供方法的实现。
		List<Dog> dogList = new ArrayList<>();
		dogList.add(new Dog("小黑", 3, 37.0));
		dogList.add(new Dog("二哈", 2, 40.0));
		dogList.add(new Dog("泰迪", 1, 8.0));
		dogList.add(new Dog("大黄", 4, 55.0));
		rawComparator(dogList);
	}
	
	
	static void rawComparator(List<? extends Dog> dogList) {
		dogList.sort(new Comparator<Dog>() {
			@Override
			public int compare(Dog o1, Dog o2) {
				return o1.getAge()-o2.getAge();
			}
		});
		dogList.forEach(System.out::println);
	}
}

说明：这样显得较为繁琐，不够体现代码的简介，下面使用Java8的 lambda 表达式来改写。

运行结果：

在这里插入图片描述

2.使用Java8 的lambda 表达式来简化代码


static void lambda(List<? extends Dog> dogList) {
	Comparator<Dog> c = (dog1, dog2)->dog1.getAge() - dog2.getAge();
	dogList.sort(c);
	dogList.forEach(System.out::println);
}

3.舍去中间变量 c，进一步简化代码


static void lambda2(List<? extends Dog> dogList) {
	dogList.sort((dog1, dog2)->dog1.getAge() - dog2.getAge());
	dogList.forEach(System.out::println);
}

总结：基本上，我们第一次接触 lambda 的话，都会去学习写这个表达式，感觉使用起来特别的方便，达到了简化代码的目的。

接口中的静态方法和默认创建 Comparator 对象

comparing 方法（静态）

接口中有一个静态方法 comparing，使用起来也特别的方便，基本上可以代替上面的那种方式了，它的参数为：Function<? super T, ? extends U> keyExtractor，这需要传入一个 lambda 表达式。虽然这些方法的定义很复杂，但是使用起来却感觉很简单，复杂的事情都被别人做了。

comparing 方法源码

public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
{
    Objects.requireNonNull(keyExtractor);
    return (Comparator<T> & Serializable)
        (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}

1.使用 comparing方法创建 Comparator 对象


static void lambda3(List<? extends Dog> dogList) {
	dogList.sort(Comparator.comparing(Dog::getAge));
	dogList.forEach(System.out::println);
}

说明： 通过上面的源码可以看到，c1 和 c2 的位置是固定的（排序是固定的升序方式），它是通过 Function 接口，调用apply方法，生成一个对象，然后调用 compareTo 方法进行比较的。（例如，我们传进去的是age，类型为int，但是通过apply会返回 Integer类型。因为包装类型和 String 类都实现了 Comparable 接口。）

注意： 如果不使用方法引用的话，那么 Dog::getAge 应该被替换为：

(dog1, dog2)->dog1.getAge() - dog2.getAge()

不过，这样做显然就是去了简介性。

2.使用重载的 comparing 方法创建 Comparator 对象

comparing 方法源码

 public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
 {
     Objects.requireNonNull(keyExtractor);
     Objects.requireNonNull(keyComparator);
     return (Comparator<T> & Serializable)
         (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                           keyExtractor.apply(c2));
 }

说明： 它比上面的 comparing 方法多了一个参数，意味着它可以实现更丰富的比较操作。而且，这个参数也是一个 Comparator 对象。

好了，下面使用这个方法，来实现按照年龄逆序排序。


static void lambda4(List<? extends Dog> dogList) {
	//它的第二个参数，可能会引起困惑，第二个参数的类型就是第一个参数指定的类型（如果是基本类型，则为对应的包装类）
	dogList.sort(Comparator.comparing(Dog::getAge, (age1, age2)->age2-age1));
	dogList.forEach(System.out::println);
}

注意： 这里的第二个参数中的 age1 和 age2 的实际类型为 Integer而不是 int，可以直接相减的原因是因为自动拆箱机制，所以这里推荐更换为：

说明： 这样看起来，似乎不够简洁，下面将使用更加简洁的方式来实现逆序排序。

(age1, age2)->age2.compareTo(age1)

运行结果：

在这里插入图片描述

3.使用comparing方法的更加简洁形式
Comparator 具有一个静态的方法，它的功能很简单就是逆序。


static void lambda5(List<? extends Dog> dogList) {
	dogList.sort(Comparator.comparing(Dog::getAge, Comparator.reverseOrder()));
	dogList.forEach(System.out::println);
}

这样，代码就显得简洁多了，当然了，还可以使用一个默认方法当到同样的目的。


static void lambda55(List<? extends Dog> dogList) {
	dogList.sort(Comparator.comparing(Dog::getAge).reversed());
	dogList.forEach(System.out::println);
}

thenComparing 方法（默认）

thenComparing 方法源码：

default <U extends Comparable<? super U>> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor)
{
    return thenComparing(comparing(keyExtractor));
}

有时候，会碰到这样的需求，需要使用多种排序方法，而不是单纯的一种。例如使用：姓名、年龄、体重进行排序。这时就需要使用 thenComparing 方法了。


static void lambda7(List<? extends Dog> dogList) {
	dogList.sort(Comparator
			.comparing(Dog::getName)
			.thenComparing(Dog::getAge)
			.thenComparing(Dog::getWeight));
	dogList.forEach(System.out::println);
}

说明1： 这里按照三个条件排序是指如果姓名相同了，再按照下一个排序，以此类推，所以你可能看不出来差别（这个结果和按照姓名排序一样，主要是排序的数据不太适合，但我不想换了。）。

说明2： 你仍然可以继续添加更多的排序规则，因为 thenComparing 方法也有重载的方法。

运行结果：

在这里插入图片描述

thenComparing 方法的重载方法源码：

 default <U> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
 {
     return thenComparing(comparing(keyExtractor, keyComparator));
 }

它的第二个方法，也和上面的 comparing 方法作用相同，是自己实现一个key的比较器，这里就不再说明了。

适用于 Int、long 和 double 类型的 thenComapring 方法

default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
    return thenComparing(comparingInt(keyExtractor));
}
  
default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
    return thenComparing(comparingLong(keyExtractor));
}  

default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
    return thenComparing(comparingDouble(keyExtractor));
}

说明：这几个方法和上面的 thenComparing 方法作用基本相同，但是更加适合处理 int、long和double类型。如果需要排序的类型为这几个，使用这些方法很好，但是我还是喜欢通用的 thenComparing 方法，这里只演示一个 thenComparingDouble 方法：

static void thenComparingDouble() {
	List<Dog> dogList = new ArrayList<>();
	dogList.add(new Dog("小黑", 3, 37.0));
	dogList.add(new Dog("二哈", 2, 55.0));
	dogList.add(new Dog("泰迪", 1, 8.0));
	dogList.add(new Dog("大黄", 2, 40.0));
	
	dogList.sort(Comparator
			.comparing(Dog::getAge)
			.thenComparingDouble(Dog::getWeight));
	dogList.forEach(System.out::println);
}

运行结果：

在这里插入图片描述

如果去掉 thenComparingDouble 方法，运行结果为：
注意和上面的结果对比。

在这里插入图片描述

适用于 Int、long 和 double 类型的 comapring 方法

这三个方法，也是专门用于处理 int、long 和double类型的，和使用 comparing方法差不多。

public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
    return (Comparator<T> & Serializable)
        (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
}

 public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
     Objects.requireNonNull(keyExtractor);
     return (Comparator<T> & Serializable)
         (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
 }

public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
    Objects.requireNonNull(keyExtractor);
    return (Comparator<T> & Serializable)
        (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
}

这里演示 comparingInt 和 comparingDouble 两个方法的用法：
我感觉没什么区别，可能是我这个测试用例太简单了吧。


static void comparingToInt(List<? extends Dog> dogList) {
	dogList.sort(Comparator.comparingInt(Dog::getAge));
	dogList.forEach(System.out::println);
}


static void comparingToDouble(List<? extends Dog> dogList) {
	dogList.sort(Comparator.comparingDouble(Dog::getWeight));
	dogList.forEach(System.out::println);
}

对于集合中含有 null 值元素的排序

static void nullSort() {
		List<String> strList = new ArrayList<>();
		strList.add("dog");
		strList.add("cat");
		strList.add(null);
		strList.add("Bird");
		strList.add(null);
		
		strList.sort(Comparator.comparing(String::length));
		strList.forEach(System.out::println);
	}

运行上面的代码，结果为：

在这里插入图片描述

说明：null 值是一个很头疼的问题，所以 Comparator接口也专门提供了处理null值得方法，它们都是对 null 值友好的方法（null-friendly）。

//null 值在前面。
//Returns a null-friendly comparator that considers null to be less than non-null.
 public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
     return new Comparators.NullComparator<>(true, comparator);
 }

//null 值在后面。
//Returns a null-friendly comparator that considers null to be greater than non-null.
public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
    return new Comparators.NullComparator<>(false, comparator);
}

因此，对于含有null值的元素进行排序，可以这样做：


public static void nullValueSort() {
	List<String> strList = new ArrayList<>();
	strList.add("dog");
	strList.add("cat");
	strList.add(null);
	strList.add("Bird");
	strList.add(null);
	//我一开始以为是一个字符常量呢？但是一想不对劲，原来是一个静态常量比较器。
	//这个是 String 类的比较器：CASE_INSENSITIVE_ORDER
	//null 值在前排序
	strList.sort(Comparator.nullsFirst(String.CASE_INSENSITIVE_ORDER));
	strList.forEach(System.out::println);
	System.out.println("===================分隔符====================");
	//null 值在后排序
	strList.sort(Comparator.nullsLast(String.CASE_INSENSITIVE_ORDER));
	strList.forEach(System.out::println);
}

运行结果：
注：摆脱了，烦人的NullPointerException，哈哈。

在这里插入图片描述

接口中其它方法

reversed方法

in other Words, it returns a comparator that imposes the reverse of the natural ordering on a collection of objects that implement the Comparable interface。
换言之，它返回一个比较器，该比较器对实现可比较接口的对象集合施加与自然顺序相反的顺序。

说明： 由于它是默认方法，所以必须由比较器对象本身来调用，正好可以实现逆序操作。可以在创建比较器后继续调用这个方法，就可以实现逆序了。但是要注意它调用的顺序，它和下面这个 reverseOrder 方法还是不一样的，下面这个方法是静态方法，可以通过类直接调用。注意，用法上的区别就是了。

 default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
 }

reverseOrder 方法

public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
    return Collections.reverseOrder();
}

如果直接使用这个方法，创建比较器对象的话，那么集合里面的元素必须使用 Comparable 接口。

static void reverseSort() {
	List<String> strList = new ArrayList<>();
	strList.add("dog");
	strList.add("cat");
	strList.add("Bird");
	
	strList.sort(Comparator.reverseOrder());
	strList.forEach(System.out::println);
}

注意：这里有一个很有趣的地方，这个方法Comparator.reverseOrder()无法使用方法引用改写：Comparator::reverseOrder，具体原因我看了，但是不是太理解，就不说了。

运行结果：

在这里插入图片描述

补充： 晚上思考了一下，结合别人的答案，这里其实也是不难理解的。自所以不能使用方法引用，是因为它根本就不是 lambda 表达式。Lambda 表达式需要依赖一个函数式接口，也就是 Comparator 接口。它的作用就是一个简化，所以它的需要的参数就是 int compare(T o1, T o2); 的方法中的参数。

所以，如果这样写的话，会报一个错误。
The type Comparator does not define reverseOrder(String, String) that is applicable here

strList.sort(Comparator::reverseOrder);

因此，上面这个写法就是错误的了。它并不能使用lambda的形式改写。

reverseOrder 和 reversed联合使用

	static void reverseSort() {
		List<String> strList = new ArrayList<>();
		strList.add("dog");
		strList.add("cat");
		strList.add("Bird");
		
		Comparator c = Comparator.reverseOrder().reversed();
		strList.sort(c);
		strList.forEach(System.out::println);
	}

说明：上面这个例子我不会添加泛型了，我无论怎么添加都是错误的，但是如果不添加泛型的话，那么编译就能通过了。但是这个东西的泛型似乎很奇怪，我也不太明白了，但是这个方法很有趣，反序的反序又是正序了。（这里存粹是娱乐一下，但是好像发现了好玩的东西。）

运行结果：

在这里插入图片描述

naturalOrder

定制排序里面居然有一个方法名叫做自然排序，这个方法感觉很有趣。但是使用的话，需要抑制一下 unchecked 警告。

@SuppressWarnings("unchecked")
public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
    return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
}

方法注释里面说明了：

@param  <T> the {@link Comparable} type of element to be compared。

参数必须是 Comparable类型的，即实现 Comparable 接口。

自然排序：


@SuppressWarnings("unchecked")
static void lambda6(List<? extends Dog> dogList) {
	dogList.sort((Comparator<Dog>) Comparator.naturalOrder());
	dogList.forEach(System.out::println);
}

如果直接运行这个方法会产生问题，必须要先实现 Comparable接口才行，并重写 compareTo方法。

@Override
public int compareTo(Dog o) {
	return age-o.age;
}

运行结果：

在这里插入图片描述

说明：不太明白，安排这个方法的目的何在，感觉很奇怪。

总结

大致介绍了一下 Comparator 接口中的方法，并写了很多演示方法。写这篇博客的起因是我用到 Comparator 接口的时候，感觉似乎有很多丰富的方法，似乎怎么写都行（哈哈），所以干脆一劳永逸，抽时间看一看这个 Comparator 到底怎么写，发现确实是很有趣的。

到此这篇关于关于使用Lambda表达式简化Comparator的使用问题的文章就介绍到这了,更多相关Lambda表达式简化Comparator内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:
点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 关于使用Lambda表达式简化Comparator的使用问题

本文链接: https://www.lsjlt.com/news/203197.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • 关于使用Lambda表达式简化Comparator的使用问题
    目录Comparator 接口接口简介定义一个示例类用来演示：Dog类接口方法介绍直接使用接口的抽象方法创建 Comparator 对象接口中的静态方法和默认创建 Comparato...
    99+
    2023-05-14
    Lambda表达式 Lambda简化Comparator Lambda简化
  • 怎么使用Lambda表达式简化Comparator的使用问题
    这篇“怎么使用Lambda表达式简化Comparator的使用问题”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“怎么使用La...
    99+
    2023-07-05
  • 【javaSE】 Lambda表达式与Lambda表达式的使用
    文章目录 🌳Lambda表达式的背景🚩Lambda表达式的语法🚩函数式接口 🎋Lambda表达式的基本使用🎄...
    99+
    2023-09-15
    开发语言 java Lambda表达式 源码
  • Java使用lambda表达式简化代码的示例详解
    目录目的推理一下实现接口，使用方法内部类实现接口，使用方法局部内部类实现接口，使用方法匿名内部类实现接口，使用方法使用lamda表达式的，实现方法可带参数只有一个参数有返回值只有一条...
    99+
    2022-11-13
    Java lambda表达式简化代码 Java lambda表达式 Java 简化代码
  • QueryWrapper的lambda表达式使用OR
    com.baomidou.mybatisplus.core.conditions.query.QueryWrapper是MybatisPlus框架构造查询条件常用的对象 使用lambda表达式写法更为清晰，简洁： QueryWrap...
    99+
    2023-08-31
    java mybatis Powered by 金山文档
  • 关于Lambda表达式的方法引用和构造器引用简的单示例
    目录方法引用和构造器引用Lambda支持的方法引用和构造器引用代码：总结方法引用和构造器引用 了解了 Lambda 表达式有一段时间了，但是都没有怎么练习，一直停留在最低层次的了解程...
    99+
    2023-05-14
    Lambda Lambda方法引用 Lambda构造器引用
  • 怎么使用Lambda表达式简化代码提高生产力
    这篇文章主要介绍“怎么使用Lambda表达式简化代码提高生产力”，在日常操作中，相信很多人在怎么使用Lambda表达式简化代码提高生产力问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”怎么使用Lambda表达式...
    99+
    2023-07-06
  • java Lambda表达式的使用心得
    目录Lambda表达式的心得Lambda表达式法传统方法使用Lambda表达式 你首先要知道的Lambda表达式的技巧Lambda表达式只能用来简化仅包含一个public方法的接口的...
    99+
    2022-11-12
  • Java的Lambda表达式如何使用
    这篇文章主要介绍“Java的Lambda表达式如何使用”，在日常操作中，相信很多人在Java的Lambda表达式如何使用问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Java的Lambda表达式如何使用”的疑...
    99+
    2023-06-30
  • C++11的lambda表达式怎么使用
    这篇文章主要讲解了“C++11的lambda表达式怎么使用”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“C++11的lambda表达式怎么使用”吧！可变lambda假设有如下vector，保...
    99+
    2023-06-19
  • Java中Lambda表达式的使用详解
    目录理解函数式接口以及 Lambda表达式的发展过程Lambda表达式及语法一起来看看具体的使用你需要注意什么Lambda的实际运用1.对集合排序2.遍历集合3.遍历集合（带条件）4...
    99+
    2022-11-12
  • lambda表达式在java8中的使用方法
    这篇文章给大家介绍lambda表达式在java8中的使用方法，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。定义 TantanitReader:public class TantanitReader { private ...
    99+
    2023-05-31
    java8 lambda ava
  • Java8新特性之Lambda表达式的使用
    目录1. lambda表达式介绍2. lambda表达式的重要特征3. lambda表达式对域外变量的限制4. lambda表达式的优缺点5. lambda表达式的使用场景1. la...
    99+
    2022-11-12
  • C++实例详解lambda表达式的使用
    目录lambda表达式1、lambda表达式语法2、lambda应用3、lambda表达式的应用实践1、计算器案例2、智能指针案例3、优先级队列lambda表达式 C++11 函数对...
    99+
    2022-11-13
  • Lambda表达式的使用及注意事项
    目录Lambda表达式的使用Lambda表达式的省略模式Lambda使用注意事项Lambda表达式和匿名内部类的区别Lambda表达式的使用 练习： 定义一个接口flyable，里面...
    99+
    2022-11-13
  • C++11中的lambda表达式怎么使用
    本篇内容介绍了“C++11中的lambda表达式怎么使用”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！可调用对象对于一个表达式e，如果可以编...
    99+
    2023-06-19
  • C++精要分析lambda表达式的使用
    目录引言语法与示例捕获列表捕获引用特殊用法实现原理应用引言 C++要走向现代语言，如果不支持lambda表达式，你很难认为这门语言和现代有什么关系。幸好，从C++11标准起，它就实现...
    99+
    2022-11-13
  • Android Studio中使用lambda表达式的方法
    module的build.gradle里buildTypes中添加：compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility Jav...
    99+
    2023-05-31
    android studio lambda
  • Java的Lambda表达式使用实例分析
    这篇文章主要讲解了“Java的Lambda表达式使用实例分析”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Java的Lambda表达式使用实例分析”吧！Lambada 简介lambda 表达...
    99+
    2023-07-05
  • 关于RealonePlay的使用问题
    RealOnePlayer是一款音乐和视频播放器，用于播放各种媒体文件。以下是一些关于使用RealOnePlayer的常见问题和解答...
    99+
    2023-08-08
    RealonePlay
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作