Java 之 lambda 表达式（一）

news2024/11/24 20:40:53

目录

一. 前言

二. lambda 表达式语法

2.1. 语法1：无参，无返回值

2.2. 语法2：一个参数，无返回值

2.3. 语法3：两个参数，lambda 体中有多条语句

2.4. 语法4：两个以上参数，有返回值

三. 函数式接口

3.1. 定义

3.2. 自定义函数式接口

3.3. 内置函数式接口

3.3.1. Consumer 示例

3.3.2. Supplier 示例

3.3.3. Function 示例,>

3.3.4. Predicate 示例

四. 方法引用

4.1. 对象::实例方法名

4.2. 类::静态方法名

4.3. 类::实例方法名

五. 构造器引用和数组引用

5.1. 构造器引用

5.2. 数组引用

六. lambda 表达式的作用域

6.1. 访问局部变量

6.2. 访问局部引用，静态变量，实例变量

6.3. 访问局部变量作限制的原因

七. 总结

一. 前言

    咱们首先来说说 lambda 这个名字，lambda 并不是一个什么的缩写，它是希腊第十一个字母 λ 的读音，同时它也是微积分函数中的一个概念，所表达的意思是一个函数入参和出参定义，在编程语言中其实是借用了数学中的 λ，并且多了一点含义，在编程语言中功能代表它具体功能的叫法是匿名函数（Anonymous Function），根据百科的解释：

匿名函数（英语：Anonymous Function）在计算机编程中是指一类无需定义标识符（函数名）的函数或子程序。

    接着再来说说 lambda 的历史，虽然它在 JDK8 发布之后才正式出现，但是在编程语言界，它是一个具有悠久历史的东西，最早在 1958 年在 Lisp 语言中首先采用，而且虽然 Java 脱胎于 C++，但是 C++ 在2011年已经发布了 lambda 了，但是 JDK8 的 LTS 在2014年才发布，所以 Java 被人叫做老土不是没有原因的，现代编程语言则是全部一出生就自带 lambda 支持，所以 lambda 其实是越来越火的一个节奏。

    lambda 在编程语言中往往是一个匿名函数，也就是说 lambda 是一个抽象概念，而编程语言提供了配套支持，比如在 Java 中其实为 lambda 进行配套的就是函数式接口，通过函数式接口生成匿名类和方法进行 lambda 式的处理。那么，既然这一套规则我们明白了，那么 lambda 所提供的好处在 Java 中就是函数式接口所提供的能力了，函数式接口往往则是提供了一些通用能力，这些函数式接口在 JDK 中也有一套完整的实践，那就是 Stream。

    lambda 表达式也可称为闭包。类似于JavaScript中的闭包，是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码。它们是一种可传递的匿名函数，可以作为参数传递给方法或存储在变量中，因此可以在需要的时候调用它们。同时，JDK 也提供了大量的内置函数式接口供我们使用，使得 lambda 表达式的运用更加方便、高效。

二. lambda 表达式语法

    语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda 运算符或箭头操作符 ，读作 (goes to)，它将 lambda 分为两个部分：
1. 左侧：指定了 lambda 表达式需要的所有参数；
2. 右侧：制定了 lambda 体，即 lambda 表达式要执行的功能。

(parameters) -> expression
// 或
(parameters) -> { statements; }

2.1. 语法1：无参，无返回值

无参，无返回值，lambda 体只需一条语句。如下：

public void test01(){
    Runnable runnable = () -> System.out.println("Runnable 运行");
    runnable.run(); // 结果：Runnable 运行
}

2.2. 语法2：一个参数，无返回值

public void test02() {
    Consumer<String> consumer = (x) -> System.out.println(x);
    consumer.accept("Hello Consumer"); // 结果：Hello Consumer
}

// 参数的小括号可以省略，如下：
public void test02() {
    Consumer<String> consumer = x -> System.out.println(x);
    consumer.accept("Hello Consumer"); // 结果：Hello Consumer
}

2.3. 语法3：两个参数，lambda 体中有多条语句

public void test03() {
    Comparator<Integer> com = (x, y) -> {
        System.out.println("函数式接口");
        return Integer.compare(x, y);
    };
    System.out.println(com.compare(2,4)); // 结果：-1
}

2.4. 语法4：两个以上参数，有返回值

有两个以上参数，有返回值，若 lambda 体中只有一条语句，return和大括号都可以省略不写。

public void test04() {
    Comparator<Integer> com=(Integer x, Integer y) -> Integer.compare(x, y);
    System.out.println(com.compare(4, 2)); // 结果：1
}

// 表达式的参数列表的数据类型可以省略不写，因为JVM可以通过上下文推断出数据类型，即“类型推断”
public void test04(){
    Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
    System.out.println(com.compare(4, 2)); // 结果：1
}

三. 函数式接口

3.1. 定义

    只包含一个抽象方法的接口，就称为函数式接口。我们可以通过 lambda表达式来创建该接口的实现对象。我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以用于检测它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

3.2. 自定义函数式接口

按照函数式接口的定义，自定义一个函数式接口，如下：

@FunctionalInterface
public interface MyFuncInterf<T> {
   public T getValue(String origin);
}

定义一个方法将函数式接口作为方法参数：

public String toLowerString(MyFuncInterf<String> mf, String origin) {
    return mf.getValue(origin);
}

将 lambda 表达式实现的接口作为参数传递：

public void test01(){
	String value = toLowerString((str) -> {
		return str.toLowerCase();
	}, "ABC");
    System.out.println(value); // 结果ABC
}

3.3. 内置函数式接口

四大核心函数式接口的介绍，如下所示：

函数式接口参数类型返回类型用途

Consumer<T>

消费型接口

Tvoid对类型为 T 的对象应用操作，包含方法：void accept(T t);

Supplier<T>

供给型接口

无T返回类型为 T 对象，包含方法：T get();

Function<T, R>

函数型接口

TR对类型为 T 的对象应用操作，并返回结果，结果是R类型的对象。包含方法：R apply(T t);

Predicate<T>

断言型接口

Tboolean确定类型为 T 的对象是否满足某约束，并返回 boolean 值。包含方法：boolean test(T t);

其他接口的定义，如下所示：

3.3.1. Consumer<T> 示例

public void makeMoney(Integer money, Consumer<Integer> consumer) {
	consumer.accept(money);
}

public void test01() {
    makeMoney(100, t -> System.out.println("今天赚了" + t)); // 结果：今天赚了100
}

3.3.2. Supplier<T> 示例

/**
 * 产生指定的整数集合放到集合中
 * Iterable接口的forEach方法的定义：方法中使用到了Consumer消费型接口，
 *     default void forEach(Consumer<? super T> action) {
 *         Objects.requireNonNull(action);
 *         for (T t : this) {
 *             action.accept(t);
 *         }
 *     }
 */
public void test01() {
	List list = addNumInList(10, () -> (int) (Math.random() * 100));
	list.forEach(t -> System.out.println(t));
}

public List addNumInList(int size, Supplier<Integer> supplier) {
	List<Integer> list = new ArrayList();
	for (int i = 0; i < size; i++) {
	  list.add(supplier.get());
	}
	return list;
}

3.3.3. Function<T, R> 示例

/**
 * 
 * 使用函数式接口处理字符串。
 */
public String handleStr(String s, Function<String, String> f) {
    return f.apply(s);
}

public void test01() {
	System.out.println(handleStr("abc", (String s) -> s.toUpperCase()));
}
  
// 结果：ABC

3.3.4. Predicate<T> 示例

/**
 * 自定义条件过滤字符串集合
 */
public void test01() {
	List<String> strings = Arrays.asList("啊啊啊", "2333", "666", "777");
	List<String> stringList = filterStr(strings, (s) -> s.length() > 3);
	for (String s : stringList) {
		System.out.println(s);
	}
}

public List<String> filterStr(List<String> list, Predicate<String> predicate) {
	ArrayList result = new ArrayList();
	for (int i = 0; i < list.size(); i++) {
		if (predicate.test(list.get(i))) {
			result.add(list.get(i));
		}
	}
	return result;
}

四. 方法引用

    当要传递给 lambda 体的操作，已经有实现的方法了，就可以使用方法引用。（实现抽象方法的参数列表，必须与方法引用的参数列表一致，方法的返回值也必须一致，即方法的签名一致）。方法引用可以理解为方法引用是 lambda 表达式的另外一种表现形式。

    方法引用的语法，使用操作符“::”将对象或类和方法名分隔开。方法引用的使用情况共分为以下三种：
1. 对象::实例方法名
2. 类::静态方法名
3. 类::实例方法名

4.1. 对象::实例方法名

/**
 * PrintStream中的println方法定义 
 *     public void println(String x) {
 *         synchronized (this) {
 *             print(x);
 *             newLine();
 *         }
 *     }
 */
// 对象::实例方法名
public void test01() {
    PrintStream out = System.out;
    Consumer<String> consumer = out::println;
    consumer.accept("hello");
}

4.2. 类::静态方法名

/**
 * Integer类中的静态方法compare的定义：
 *     public static int compare(int x, int y) {
 *         return (x < y) ? -1 : ((x == y) ? 0 : 1);
 *     }
 */
public void test01() {
	Comparator<Integer> comparable = (x, y) -> Integer.compare(x, y);
	// 使用方法引用实现相同效果
	Comparator<Integer> integerComparable = Integer::compare;
	System.out.println(integerComparable.compare(4, 2)); // 结果：1
	System.out.println(comparable.compare(4, 2)); // 结果：1
}

4.3. 类::实例方法名

public void test01() {
	BiPredicate<String, String> bp = (x, y) -> x.equals(y);
    // 使用方法引用实现相同效果
    BiPredicate<String, String> bp2 = String::equals;
    System.out.println(bp.test("1", "2")); // 结果：false
    System.out.println(bp.test("1", "2")); // 结果：false
}

五. 构造器引用和数组引用

5.1. 构造器引用

    与函数式接口相结合，自动与函数式接口中方法兼容，可以把构造器引用赋值给定义的方法。需要注意构造器参数列表要与接口中抽象方法的参数列表一致。格式：类名::new。使用示例：

// 实体类Employee
public class Employee {
	private Integer id;
	private String name;
	private Integer age;
	
	public Employee(){

	}

	public Employee(Integer id) {
		this.id = id;
	}

	public Employee(Integer id, Integer age) {
		this.id = id;
		this.age = age;
	}

	public Employee(int id, String name, int age) {
		this.id = id;
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "Employee{" +
				"id=" + id +
				", name='" + name + '\'' +
				", age=" + age +
				'}';
	}
}

使用构造器引用与函数式接口相结合：

public void test01(){
	// 引用无参构造器
	Supplier<Employee> supplier = Employee::new;
	System.out.println(supplier.get());
	// 引用有参构造器
	Function<Integer, Employee> function = Employee::new;
	System.out.println(function.apply(21));
	BiFunction<Integer, Integer, Employee> biFunction = Employee::new;
	System.out.println(biFunction.apply(8, 24));
}
  
输出结果：
  Employee{id=null, name='null', age=null}
  Employee{id=21, name='null', age=null}
  Employee{id=8, name='null', age=24}

5.2. 数组引用

数组引用的格式：type[]:new。

public void test01() {
    Function<Integer, String[]> function = String[]::new;
    String[] apply = function.apply(10);
    System.out.println(apply.length); // 结果：10
}

六. lambda 表达式的作用域

    lambda 表达式可以看作是匿名内部类实例化的对象，lambda 表达式对变量的访问限制和匿名内部类一样，因此 lambda 表达式可以访问局部变量、局部引用，静态变量，实例变量。

6.1. 访问局部变量

    在 lambda 表达式中规定只能引用标记了 final 的外层局部变量。我们不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。

public class TestFinalVariable {
    interface VarTestInterface {
        Integer change(String str);
    }

    public static void main(String[] args) {
        // 局部变量不使用final修饰
        Integer tempInt = 1;
        VarTestInterface var = (str -> Integer.valueOf(str + tempInt));
        // 再次修改，不符合隐式final定义
        tempInt = 2;
        Integer str = var.change("111") ;
        System.out.println(str);
    }
}

上面代码会出现编译错误，出现如下提示：

特殊情况下，局部变量也可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）。例如上面的代码确保 lambda 表达式后局部变量后面不做修改，就可以成功啦！

public class TestFinalVariable {
    interface VarTestInterface {
        Integer change(String str);
    }

    public static void main(String[] args) {
        // 局部变量不使用final修饰
        Integer tempInt = 1;
        VarTestInterface var = (str -> Integer.valueOf(str + tempInt));
        Integer str = var.change("111") ;
        System.out.println(str);
    }
}

6.2. 访问局部引用，静态变量，实例变量

    lambda 表达式不限制访问局部引用变量、静态变量、实例变量。代码测试都可正常执行，代码：

public class LambdaScopeTest {
    /**
     * 静态变量
     */
    private static String staticVar;

    /**
     * 实例变量
     */
    private String instanceVar;

    @FunctionalInterface
    interface VarChangeInterface {
        Integer change(String str);
    }

    /**
     * 测试引用变量
     */
    private void testReferenceVar() {
        ArrayList<String> list = new ArrayList<>();
        list.add("111");
        //访问外部引用局部引用变量
        VarChangeInterface varChangeInterface = ((str) -> Integer.valueOf(list.get(0)));
        //修改局部引用变量
        list.set(0, "222");
        Integer str = varChangeInterface.change("");
        System.out.println(str);
    }

    /**
     * 测试静态变量
     */
    void testStaticVar() {
        staticVar = "222";
        VarChangeInterface varChangeInterface = (str -> Integer.valueOf(str + staticVar));
        staticVar = "333";
        Integer str = varChangeInterface.change("111") ;
        System.out.println(str);
    }

    /**
     * 测试实例变量
     */
    void testInstanceVar() {
        instanceVar = "222";
        VarChangeInterface varChangeInterface = (str -> Integer.valueOf(str + instanceVar));
        instanceVar = "333";
        Integer str = varChangeInterface.change("111") ;
        System.out.println(str);
    }

    public static void main(String[] args) {
        new LambdaScopeTest().testReferenceVar();
        new LambdaScopeTest().testStaticVar();
        new LambdaScopeTest().testInstanceVar();
    }
}
// 运行结果：
222
111333
111333

lambda 表达式里不允许声明一个与局部变量同名的参数或者局部变量：

// 编程报错
Integer tempInt = 1;
VarTestInterface varTest01 = (tempInt -> Integer.valueOf(tempInt));
VarTestInterface varTest02 = (str -> {
	Integer tempInt = 1;
	Integer.valueOf(str);
});

6.3. 访问局部变量作限制的原因

    lambda 表达式不能访问非 final 修饰的局部变量的原因是，局部变量是保存在栈帧中的。而在Java 的线程模型中，栈帧中的局部变量是线程私有的，如果允许 lambda 表达式访问到栈帧中的变量地址（可改变的局部变量），则可能会导致线程私有的数据被并发访问，造成线程不安全问题。

    基于上述原因，对于引用类型的局部变量，因为 Java 是值传递的，又因为引用类型的指向内容是保存在堆中，是线程共享的，因此 lambda 表达式中可以修改引用类型的局部变量的内容，而不能修改该变量的引用。

    对于基本数据类型的变量，在 lambda 表达式中只是获取到该变量的副本，且局部变量是线程私有的，因此无法知道其他线程对该变量的修改，如果该变量不做 final 修饰，会造成数据不同步的问题。

    但是实例变量、静态变量不作限制，因为实例变量，静态变量是保存在堆中（Java8 之后），而堆是线程共享的。在 lambda 表达式内部可以知道实例变量、静态变量的变化。

七. 总结

优点：
1. 使代码更简洁，紧凑；
2. 可以使用并行流来并行处理，充分利用多核CPU的优势；
3. 有利于JIT编译器对代码进行优化。 

缺点：
1. 非并行计算情况下，其计算速度没有比传统的 for 循环快；
2. 不容易调试；
3. 若其他程序员没有学过 Lambda 表达式，代码不容易看懂。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1258468.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

使用paddledetection的记录

使用paddledetection的记录

首先在这里使用的是是paddle--detection2.7的版本。 成功进行训练 目录&#xff1a; 目录 数据集准备 配置文件的修改 使用的是BML的平台工具&#xff1a; !python -m pip install paddlepaddle-gpu2.5 -i https://mirror.baidu.com/pypi/simple --user %cd /home/aistudio…
阅读更多...
识别验证码

识别验证码

背景 需求是要爬取某网站的数据, 已有账号密码, 但这个网站需要登录, 登录需要输入验证码 验证码样式如下 调研了Tesseract框架, 识别效果不佳. 后来使用ddddocr, 能正确识别. https://github.com/sml2h3/ddddocr 代码如下 def ocr():response requests.get(http://xxx/get…
阅读更多...
Jenkins Pipeline应用实践

Jenkins Pipeline应用实践

Jenkins Pipeline是一种可编程的、可扩展的持续交付管道&#xff0c;允许您使用脚本来定义整个软件交付过程。 以下是使用Jenkins Pipeline创建和配置流水线的基本步骤。 Part 01. 创建一个Pipeline Job 在Jenkins中创建一个新的"Pipeline"类型的Job。 以下是在Je…
阅读更多...
【STM32F103】HC-SR04超声波测距模块详解（附工程文件）

【STM32F103】HC-SR04超声波测距模块详解（附工程文件）

前言&#xff1a; 使用的硬件&#xff1a;STM32F103C8T6&#xff0c;HC-SR04&#xff0c;ST-Link&#xff08;其他烧录器也可以&#xff09;&#xff0c;0.96寸OLED屏幕&#xff08;非必须&#xff0c;仅供显示测距结果&#xff0c;可以使用串口助手代替&#xff09;&#xff…
阅读更多...
rabbitMQ对消息不可达处理-备份交换机/备份队列

rabbitMQ对消息不可达处理-备份交换机/备份队列

生产者发送消息&#xff0c;在消息不可达指定队列时&#xff0c;可以借助扇出类型交换机&#xff08;之前写过消息回退的处理方案&#xff0c;扇出交换机处理的方案优先级高于消息回退&#xff09;处理不可达消息&#xff0c;然后放置一个备份队列&#xff0c;供消费者处理不可…
阅读更多...
Pytorch中的gather的理解和用法

Pytorch中的gather的理解和用法

Pytorch中的gather的理解和用法 这个Gather的用法花费了点时间&#xff0c;我相信很多人一开始不太懂。 跟着我简单理解。 首先样例是&#xff1a; tensor([[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])然后index: [[2, 1, 0]]然后执行的代码&#xff1a; tensor_0.gather(0…
阅读更多...
使用 SIEM 管理安全事件

使用 SIEM 管理安全事件

每家公司都必须处理检测、管理和解决安全事件&#xff0c;未能制定事件响应计划可能会对任何组织产生重大的影响&#xff0c;无论是在财务损失还是声誉损害方面。本文探讨了事件响应的重要性、检测和管理事件的关键要素&#xff0c;以及帮助组织处理安全事件的最佳实践。 安全…
阅读更多...
FLASK博客系列6——数据库之谜

FLASK博客系列6——数据库之谜

我们上一篇已经实现了简易博客界面&#xff0c;你还记得我们的博客数据是自己手动写的吗&#xff1f;但实际应用中&#xff0c;我们是不可能这样做的。大部分程序都需要保存数据&#xff0c;所以不可避免要使用数据库。我们这里为了简单方便快捷&#xff0c;使用了超级经典的SQ…
阅读更多...
如何使用内网穿透将Tomcat网页发布到公共互联网上【内网穿透】

如何使用内网穿透将Tomcat网页发布到公共互联网上【内网穿透】

文章目录 前言1.本地Tomcat网页搭建1.1 Tomcat安装1.2 配置环境变量1.3 环境配置1.4 Tomcat运行测试1.5 Cpolar安装和注册 2.本地网页发布2.1.Cpolar云端设置2.2 Cpolar本地设置 3.公网访问测试4.结语 前言 Tomcat作为一个轻量级的服务器&#xff0c;不仅名字很有趣&#xff0…
阅读更多...
Redis面试题：分布式锁相关问题

Redis面试题：分布式锁相关问题

目录 面试官&#xff1a;Redis的内存用完了会发生什么&#xff1f; 面试官&#xff1a;Redis分布式锁如何实现 ? 面试官&#xff1a;好的&#xff0c;那你如何控制Redis实现分布式锁有效时长呢&#xff1f; 面试官&#xff1a;好的&#xff0c;redisson实现的分布式锁是可重…
阅读更多...
现货黄金走势图下载与保存

现货黄金走势图下载与保存

MetaTrader 4 (MT4) 是一款在全球范围内广受欢迎的现货黄金交易软件&#xff0c;简单性和灵活性是其深受市场欢迎的原因。它的显示界面的主要部分由品种的走势图表组成&#xff0c;投资者可以在其中查看实时的行情走势。屏幕左上角是市场观察窗口&#xff0c;当中列出了平台所有…
阅读更多...
群晖NAS：docker（Container Manager）、npm安装Verdaccio并常见命令集合

群晖NAS：docker（Container Manager）、npm安装Verdaccio并常见命令集合

群晖NAS&#xff1a;docker&#xff08;Container Manager&#xff09;、npm安装Verdaccio并常见命令集合 自建 npm 资源库&#xff0c;使用Verdaccio。如果觉得麻烦&#xff0c;直接可以在外网注册 https://www.npmjs.com/ 网站。大同小异&#xff0c;自己搭建搭建方便局域网…
阅读更多...
如何进行有效的移动应用测试？

如何进行有效的移动应用测试？

1、识别关键功能: 对于移动应用测试&#xff0c;首先要了解应用的需求和功能规格&#xff0c;确定哪些功能是最关键的。 关键功能通常是用户最常用的功能&#xff0c;对应用的成功和用户体验至关重要。 2、设定测试目标和用例: 针对每个关键功能&#xff0c;设置具体的测试目…
阅读更多...
基于springboot+maven的个人理财管理系统

基于springboot+maven的个人理财管理系统

基于springbootmaven的个人理财管理系统,演示地址:个人理财系统登录界面 用户名:admin,密码&#xff1a;123456 共分为用户信息管理(用户信息&#xff0c;银行卡&#xff0c;个人征信)&#xff0c;理财产品管理(零钱理财&#xff0c;工资理财&#xff0c;期限理财&#xff0c…
阅读更多...
如何在本地安装部署WinSCP，并实现公网远程本地服务器

如何在本地安装部署WinSCP，并实现公网远程本地服务器

可视化文件编辑与SSH传输神器WinSCP如何公网远程本地服务器 文章目录 可视化文件编辑与SSH传输神器WinSCP如何公网远程本地服务器1. 简介2. 软件下载安装&#xff1a;3. SSH链接服务器4. WinSCP使用公网TCP地址链接本地服务器5. WinSCP使用固定公网TCP地址访问服务器 1. 简介 …
阅读更多...
有效实施的五条教学策略

有效实施的五条教学策略

作为老师&#xff0c;是否曾为如何提高教学质量而苦恼&#xff1f;也为如何引导学生而思考&#xff1f;如果你正面临这些困扰&#xff0c;那么这篇文章将对你有帮助。为你介绍五条教学策略&#xff0c;帮你实施教学&#xff0c;提高效果。 明确教学目标 你是否知道你的教学目标…
阅读更多...
3D数字孪生场景编辑器

3D数字孪生场景编辑器

在线工具推荐&#xff1a; 3D数字孪生场景编辑器 - GLTF/GLB材质纹理编辑器 - 3D模型在线转换 - Three.js AI自动纹理开发包 - YOLO 虚幻合成数据生成器 - 三维模型预览图生成器 数字孪生的强大功能来自于将真实世界的资产与真实世界的数据联系起来&#xff0c;因此您可以…
阅读更多...
代码块01-Java

代码块01-Java

代码块01 一、介绍二、语法三、好处举例 四、使用细节五、练习题1题2 一、介绍 代码块又称为初始化块&#xff0c;属于类中的成员[即是类的一部分]&#xff0c;类似于方法&#xff0c;将逻辑语句封装在方法体中&#xff0c;通过包围起来。 但和方法不同&#xff0c;没有方法名…
阅读更多...
ZKP15.1 Secure ZK Circuits via Formal Methods

ZKP15.1 Secure ZK Circuits via Formal Methods

ZKP学习笔记 ZK-Learning MOOC课程笔记 Lecture 15: Secure ZK Circuits via Formal Methods (Guest Lecturer: Yu Feng (UCSB & Veridise)) Motivation Bugs in blockchain software are extremely dangers and costly.Smart Contract Bugs, Blockchain Protocol Bugs,…
阅读更多...
OSError: symbolic link privilege not held报错解决

OSError: symbolic link privilege not held报错解决

本人情况介绍 本人在复现某个代码的时候&#xff0c;需要安装开源代码已经封装好的setup.py代码。具体安装的库具体如下。 fairseqpython3.6.0pytorch1.6.0File2ROUGE 在安装fairseq的时候遇见了如下问题。 Installing build dependencies … done Getting requirements to …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023