JAVA系列---函数式接口

函数式接口的定义

  1. 一个函数式接口有且仅有一个抽象方法(SAM，single abstract method)。对于接口来说抽象方法必须重写，默认方法可选重新，静态方法不可重新。
  2. Object 类中的 public abstract method 不会被视为单一的抽象方法。这些方法对于函数式接口来说，不被当成是抽象方法（虽然它们是抽象方法）。因为任何一个函数式接口的实现，默认都继承了Object类，包含了来自java.lang.Object里对这些抽象方法的实现。
  3. 函数式接口可以用@FunctionalInterface 注解进行修饰。但并不是必须用注解标注，一个接口只要满足只有一个抽象方法的条件就可以称为函数式接口。
    如果使用了此注解，再往接口中新增抽象方法，编译器就会报错，编译不通过。换句话说，@FunctionalInterface就是一个承诺，承诺该接口世世代代都只会存在这一个抽象方法。因此，凡是使用了这个注解的接口，开发者可放心大胆的使用lambda来实例化。当然误用@FunctionalInterface带来的后果也是极其惨重的：如果哪天你把这个注解去掉，再加一个抽象方法，则所有使用lambda实例化该接口的客户端代码将全部编译错误。所以当某接口只有一个抽象方法，但没有增加@FunctionalInterface，则代表该接口不承诺未来不增加抽象方法，所以建议不要用lambda来实例化，还是老老实实的用以前的方式比较稳妥。

函数式接口的示例

@FunctionalInterface
public interface HelloWorldService {void sayHello(String msg);default void doSomeWork1() {// Method body}default void doSomeWork2() {// Method body}static void printHello() {System.out.println("Hello");}@Overrideboolean equals(Object obj);}

函数式接口的用处

函数式接口带给我们最大的好处就是：可以使用极简的lambda表达式实例化接口。为什么这么说呢？我们或多或少使用过一些只有一个抽象方法的接口，比如 Runnable, ActionListener, Comparator …。比如，我们要用Comparator实现排序算法，我们的处理方式通常无外乎两种：

  • 规规矩矩的写一个实现Comparator接口的java类去封装排序逻辑。若业务需要多种排序方式，那就得写多个类提供多种实现，而这些实现往往只需使用一次
  • 另外一种聪明些的做法无外乎就是在需要的地方搞个匿名内部类。比如：
class Test { public static void main(String args[]) { List<Person> persons = new ArrayList<Person>();Collections.sort(persons, new Comparator<Person>(){@Overridepublic int compare(Person o1, Person o2) {return Integer.compare(o1.getAge(), o2.getAge());}});} 
}

匿名内部类实现的代码量没有多到哪里去，结构也还算清晰。不过如今脚本语言横行无阻，无不以其简洁的语法为杀手锏，俘获程序员的欢心。jdk开发者们应该是意识到了这一点，我们从上面Comparator的实现就可以得到验证。该接口在jdk8的实现增加了FunctionalInterface注解，代表Comparator是一个函数式接口，使用者可放心的通过lambda表达式来实例化。那我们来看看使用lambda实例化所需编写的代码：

Comparator<Person> comparator = (p1, p2) -> Integer.compare(p1.getAge(), p2.getAge());

lambda表达式

lambda这个名称是由美国数学家 Alonzo Church选择的，他在 1930 年代发展计算理论时需要一个希腊字母来表示函数抽象的运算符（λ）。所以其实没什么特殊意义，对于名称纠结症的可以放一放 了。

lambda表达式其实是快速创建函数式接口实例的语法糖； -> 就是lambda的语法标志。

lambda是什么

lambda表达式是实现函数式接口的一个快捷方式。下面这段代码是最直观的体现：

Runnable task = () -> System.out.println("i am coming...");

=号的前面是变量的声明，后面是一个lambda表达式。我们直接将lambda表达式赋值为Runnable类型的task变量，就意味着：lambda表达式是实现函数式接口的一个快捷方式。理解这一点是至关重要的。

lambda表达式语法

lambda表达式语法可抽象表示为：

(Type1 param1, Type2 param2, ..., TypeN paramN) -> {statment1;statment2;...return statmentN;
}

以Predicate判断年龄为例

Predicate<Person> predicate = (Person person) -> {Integer age = person.getAge();return age >= 18;
};

但上面的并不是我们常见的代码，那是因为我们常用的是极简风，以下是简化过程：参数类型省略-》参数占位省略-》返回语句省略。

  1. 参数类型省略：因为编译器可以从上下文环境中推断出lambda表达式的参数类型

    (param1, param2, ..., paramN) -> {statment1;statment2;...return statmentN;
}

    Predicate<Person> predicate = (person) -> {Integer age = person.getAge();return age >= 18;
};

  2. 参数占位省略：参数占位省略存在两种情况，当无参时，必须使用小括号来占位；当有一个参数时，省略小括号即可，参数直接占位。

    param -> {statment1;statment2;...return statmentN;
}

    Predicate<Person> predicate = person -> {Integer age = person.getAge();return age >= 18;
};

  3. 表达式省略：当表达式只包含一条语句时，可以同时省略大括号和return关键字和语句结尾的分号。但需要注意的是三者必须同时省略或者同时不省略

    param -> statment;

    Predicate<Person> predicate = person -> person.getAge() >= 18

    Predicate<Person> predicate = person -> {return person.getAge() >= 18;}

lambda表达式与匿名类

lambda表达式与匿名类的异同集中体现在三点上：

  • lambda就是为了优化匿名内部类而生，lambda要比匿名类简洁的多得多；
  • lambda仅适用于函数式接口，匿名类不受限；
  • 在匿名类内部，this关键字指向该抽象类实例，而lambda内部this指向闭包实例。如果需要在内部通过this关键字访问实例，必须使用匿名类；

函数式接口的使用

函数式接口为lambda表达式和方法引用(用冒号::来进行方法的调用)提供目标类型。每个功能接口都有一个抽象方法，称为该功能接口的功能方法，lambda表达式的参数和返回类型与之匹配或适配。功能接口可以在多个上下文中提供目标类型，例如赋值上下文，方法调用或强制转换上下文：

// Assignment context
Predicate<String> p = String::isEmpty;// Method invocation context
stream.filter(e -> e.getSize() > 10)...// Cast context
stream.map((ToIntFunction) e -> e.getSize())...

函数式接口可以使用lambda表达式，方法引用或构造函数引用创建功能接口的实例。

函数式接口有哪些

函数式接口可以对现有的函数友好地支持lambda。

JDK1.8之前已有的函数式接口:

  • java.lang.Runnable
  • java.util.concurrent.Callable
  • java.security.PrivilegedAction
  • java.util.Comparator
  • java.io.FileFilter
  • java.nio.file.PathMatcher
  • java.lang.reflect.InvocationHandler
  • java.beans.PropertyChangeListener
  • java.awt.event.ActionListener
  • javax.swing.event.ChangeListener

JDK1.8新增加的函数接口:

  • java.util.function包
函数接口方法名形式化描述分类用途说明
SupplierT get();() -> T供给型提供一个结果
Consumervoid accept(T t)(T) -> void消费型消费一个输出
FunctionR apply(T t)(T) -> R映射型类型转换
Predicateboolean test(T t)(T) -> boolean预测型判断输入是否符合预期
OperatorT applyAsT(T t)(T) -> T映射型数据操纵

Predicate

接受一个输入参数，返回一个布尔值结果

/*** Represents a predicate (boolean-valued function) of one argument.* @param <T> the type of the input to the predicate* @since 1.8*/
@FunctionalInterface
public interface Predicate<T> {/*** Evaluates this predicate on the given argument.*/boolean test(T t);/*** Returns a composed predicate that represents a short-circuiting logical* AND of this predicate and another.  When evaluating the composed* predicate, if this predicate is {@code false}, then the {@code other}* predicate is not evaluated.*/default Predicate<T> and(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) && other.test(t);}/*** Returns a predicate that represents the logical negation of this* predicate.*/default Predicate<T> negate() {return (t) -> !test(t);}/*** Returns a composed predicate that represents a short-circuiting logical* OR of this predicate and another.  When evaluating the composed* predicate, if this predicate is {@code true}, then the {@code other}* predicate is not evaluated.*/default Predicate<T> or(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) || other.test(t);}/*** Returns a predicate that tests if two arguments are equal according* to {@link Objects#equals(Object, Object)}.*/static <T> Predicate<T> isEqual(Object targetRef) {return (null == targetRef)? Objects::isNull: object -> targetRef.equals(object);}
}

示例

public static void main(String[] args) {Predicate<Person> predicate1 = (Person person) -> {Integer age = person.getAge();return age >= 18;};Predicate<Person> predicate2 = (Person person) -> {String name = person.getName();return name.startsWith("R");};Person rico = new Person();rico.setName("Rico");rico.setAge(16);System.out.println("Rico名字以R开头且年满18岁 : " + predicate1.and(predicate2).test(rico));System.out.println("Rico名字以R开头或年满18岁 : " +  predicate1.or(predicate2).test(rico));System.out.println("Rico名字不是以R开头 : " +  predicate1.negate().test(rico));
}
/*** outputRico名字以R开头且年满18岁 : falseRico名字以R开头或年满18岁 : trueRico名字不是以R开头 : true
*/

其它接口

接口方法描述
BiPredicateboolean test(T t, U u);接受两个参数的二元谓词;
DoublePredicateboolean test(double value);入参为double的谓词函数;
IntPredicateboolean test(int value);入参为int的谓词函数;
LongPredicateboolean test(long value);入参为long的谓词函数;

迷糊过程

@FunctionalInterface
public interface Predicate<T> {boolean test(T t);default Predicate<T> and(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) && other.test(t);}
}

使用：

Predicate<Integer> p = i -> i > 2;
System.out.println(p.and(i -> i < 10).test(5));

一开始不理解and方法的执行逻辑，and里面都已经调用过test方法了，为什么还能p.and.test, 原来and方法相当于二次函数式编程，and完毕之后其实相当于：

Predicate<Integer> p = i -> i > 2 && i < 10;
System.out.println(p.test(5));

函数式编程也不会改变java的核心：bean.method(param)，jvm只能将bean当参数，所以jvm其实还是将Lambda表达式的结果当成对象，由此表象上看似java支持了函数语句当参数。

Function

接受一个输入参数T，返回一个结果R

/*** Represents a function that accepts one argument and produces a result.* @param <T> the type of the input to the function* @param <R> the type of the result of the function* @since 1.8*/
@FunctionalInterface
public interface Function<T, R> {/*** Applies this function to the given argument.*/R apply(T t);/*** Returns a composed function that first applies the {@code before}* function to its input, and then applies this function to the result.* If evaluation of either function throws an exception, it is relayed to* the caller of the composed function.*/default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {Objects.requireNonNull(before);return (V v) -> apply(before.apply(v));}/*** Returns a composed function that first applies this function to* its input, and then applies the {@code after} function to the result.* If evaluation of either function throws an exception, it is relayed to* the caller of the composed function.*/default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {Objects.requireNonNull(after);return (T t) -> after.apply(apply(t));}/*** Returns a function that always returns its input argument.*/static <T> Function<T, T> identity() {return t -> t;}
}

方法表达式：

抽象方法：R=Function(T)
compose方法：V=Function(ParamFunction(T));
andThen方法：V=ParamFunction(Function(T));
identity方法：T=Function(T);

示例

public static void main(String[] args) {Function<Integer, Integer> func1 = x -> {return x + 1;};Function<Integer, Integer> func2 = y -> {return y * 7;};int x = 3, y = 5;System.out.println(func1.apply(x));System.out.println(func2.apply(y));System.out.println(func1.compose(func2).apply(x));System.out.println(func1.andThen(func2).apply(x));
}
/*** output4352228
*/

其它接口

接口方法描述
BiFunctionR apply(T t, U u);接受两个参数，返回一个值，代表一个二元函数；
DoubleFunctionR apply(double value);只处理double类型的一元函数；
IntFunctionR apply(int value);只处理int参数的一元函数；
LongFunctionR apply(long value);只处理long参数的一元函数；
ToDoubleFunctiondouble applyAsDouble(T value);返回double的一元函数；
ToDoubleBiFunctiondouble applyAsDouble(T t, U u);返回double的二元函数；
ToIntFunctionint applyAsInt(T value);返回int的一元函数；
ToIntBiFunctionint applyAsInt(T t, U u);返回int的二元函数；
ToLongFunctionlong applyAsLong(T value);返回long的一元函数；
ToLongBiFunctionlong applyAsLong(T t, U u);返回long的二元函数；
DoubleToIntFunctionint applyAsInt(double value);接受double返回int的一元函数；
DoubleToLongFunctionlong applyAsLong(double value);接受double返回long的一元函数；
IntToDoubleFunctiondouble applyAsDouble(int value);接受int返回double的一元函数；
IntToLongFunctionlong applyAsLong(int value);接受int返回long的一元函数；
LongToDoubleFunctiondouble applyAsDouble(long value);接受long返回double的一元函数；
LongToIntFunctionint applyAsInt(long value);接受long返回int的一元函数；

Consumer

接受一个输入参数，没有返回值

/*** Represents an operation that accepts a single input argument and returns no* result. Unlike most other functional interfaces, {@code Consumer} is expected* to operate via side-effects.*  * @param <T> the type of the input to the operation*  * @since 1.8*/
@FunctionalInterface
public interface Consumer<T> {/*** Performs this operation on the given argument.*/void accept(T t);/*** Returns a composed {@code Consumer} that performs, in sequence, this* operation followed by the {@code after} operation. If performing either* operation throws an exception, it is relayed to the caller of the* composed operation.  If performing this operation throws an exception,* the {@code after} operation will not be performed.*/default Consumer<T> andThen(Consumer<? super T> after) {Objects.requireNonNull(after);return (T t) -> { accept(t); after.accept(t); };}
}

示例

public static void main(String[] args) {Person rico = new Person();rico.setName("Rico");rico.setAge(16);Consumer<Person> consumer = person -> System.out.println(person);consumer.accept(rico);
}/*** output{"age":16,"name":"Rico"}
*/

其它接口

接口函数描述
BiConsumervoid accept(T t, U u);接受两个参数
DoubleConsumervoid accept(double value);接受一个double参数
IntConsumervoid accept(int value);接受一个int参数
LongConsumervoid accept(long value);接受一个long参数
ObjDoubleConsumervoid accept(T t, double value);接受一个泛型参数一个double参数
ObjIntConsumervoid accept(T t, int value);接受一个泛型参数一个int参数

Supplier

不需要任何参数，返回一个值

/*** Represents a supplier of results.** @param <T> the type of results supplied by this supplier** @since 1.8*/
@FunctionalInterface
public interface Supplier<T> {/*** Gets a result.*/T get();
}

示例

public static void main(String[] args) {Person rico = new Person();rico.setName("Rico");rico.setAge(16);Supplier<Person> supplier = () -> rico;System.out.println("supplier : " + supplier.get());
}
/*** outputsupplier : {"age":16,"name":"Rico"}
*/

其它接口

接口函数描述
BooleanSupplierboolean getAsBoolean();返回boolean
DoubleSupplierdouble getAsDouble();返回double
IntSupplierint getAsInt();返回int
LongSupplierlong getAsLong();返回long

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

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

相关文章

java技术专家面试指南100问【java学习+面试宝典】（四）

java技术专家面试指南100问【java学习+面试宝典】（四）

如何避免“伪共享”&#xff1f; 字节填充&#xff08;创建变量时&#xff0c;使用字段对其进行填充&#xff0c;避免多个变量被分派到同一个缓存行里&#xff09;。JDK8提供了一个Contended注解来解决伪共享。 Netty 的应用场景了解么&#xff1f; Netty 主要用来做网络通信…
阅读更多...
数据结构学习笔记-树

数据结构学习笔记-树

1.树的存储结构 &#xff08;1&#xff09;双亲表示法 顺序存储结点数据&#xff0c;结点中保存父节点在数组中的下标。 优点&#xff1a;找父节点方便&#xff1b;缺点&#xff1a;找孩子不方便 #define MAX_TREE_SIZE 100 //树中最多结点数 typedef struct{ //树的…
阅读更多...
微信小程序点击打开关联企业微信客服

微信小程序点击打开关联企业微信客服

wx.openCustomerServiceChat({extInfo: {url: https://work.weixin.qq.com/kfid/kfc****},corpId: *****,})
阅读更多...
磁盘性能概述与磁盘调度算法

磁盘性能概述与磁盘调度算法

目录 1. 磁盘性能概述 1. 数据传输速率 2. 寻道时间 3. 旋转延迟 4. 平均访问时间 2. 早期的磁盘调度算法 1. FIFO&#xff08;First-In-First-Out&#xff09;调度算法 2. SSTF&#xff08;Shortest Seek Time First&#xff09;调度算法 3. SCAN&#xff08;Elevator…
阅读更多...
Dubbo3 服务原生支持 http 访问，兼具高性能与易用性

Dubbo3 服务原生支持 http 访问，兼具高性能与易用性

作者&#xff1a;刘军 作为一款 rpc 框架&#xff0c;Dubbo 的优势是后端服务的高性能的通信、面向接口的易用性&#xff0c;而它带来的弊端则是 rpc 接口的测试与前端流量接入成本较高&#xff0c;我们需要专门的工具或协议转换才能实现后端服务调用。这个现状在 Dubbo3 中得…
阅读更多...
SVN 报错Error: Unable to connect to a repository at URL解决方法

SVN 报错Error: Unable to connect to a repository at URL解决方法

1. 报错背景&#xff1a; 使用ssh 用svn拉取仓库代码时&#xff0c;出现如下报错&#xff1a; Can’t create session: Unable to connect to a repository at URL svn://127.0.0.1 …. Can’t connect to host ‘127.0.0.1’: Connection refused at C:/Program Files/Git/mi…
阅读更多...
蓝牙耳机怎么连接电脑？轻松实现无线连接

蓝牙耳机怎么连接电脑？轻松实现无线连接

蓝牙耳机已经成为许多人生活中不可或缺的一部分&#xff0c;不仅可以方便地连接手机&#xff0c;还能轻松连接电脑&#xff0c;让我们在工作和娱乐时享受无线的自由。然而&#xff0c;对于一些用户来说&#xff0c;将蓝牙耳机与电脑连接可能会遇到一些问题。本文将介绍蓝牙耳机…
阅读更多...
从大型语言模型到大脑语言理解：探索话语理解的神经机制

从大型语言模型到大脑语言理解：探索话语理解的神经机制

随着科技的飞速发展&#xff0c;人工智能领域取得了令人瞩目的成就。在这其中&#xff0c;大型语言模型&#xff08;LLMs&#xff09;以其卓越的性能和广泛的应用前景&#xff0c;成为了当前研究的热点。然而&#xff0c;尽管LLMs在文本生成、语言翻译等领域展现出了惊人的能力…
阅读更多...
镭速如何做到数据同步文件及文件夹的ACL属性？

镭速如何做到数据同步文件及文件夹的ACL属性？

数据文件同步时&#xff0c;除了要同步文件的内容&#xff0c;还要对文件的属性做同步。权限属性作为一个重要的文件属性&#xff0c;是属性同步的重中之重&#xff0c;控制着不同用户与用户组对文件和文件夹的访问权限。不同的操作系统有着自己不同的权限控制机制&#xff0c;…
阅读更多...
2786. 访问数组中的位置使分数最大 Medium

2786. 访问数组中的位置使分数最大 Medium

给你一个下标从 0 开始的整数数组 nums 和一个正整数 x 。 你 一开始 在数组的位置 0 处&#xff0c;你可以按照下述规则访问数组中的其他位置&#xff1a; 如果你当前在位置 i &#xff0c;那么你可以移动到满足 i < j 的 任意 位置 j 。 对于你访问的位置 i &#xff0c;…
阅读更多...
C++ C_style string overview and basic Input funcitons

C++ C_style string overview and basic Input funcitons

write in advance 最近在做题&#xff0c;遇到一个简单的将console的输入输出到文件中的简单题目&#xff0c;没有写出来。悔恨当初没有踏实地总结string 相关的 I/O 以及与文件的操作。这篇文章旨在记录基础的字符I/O, 简单常用的文件I/O操作函数。 当然&#xff0c;你会说C…
阅读更多...
第2章 Rust初体验6/8：Option枚举及其变体：能避免空指针异常问题：猜骰子冷热游戏

第2章 Rust初体验6/8：Option枚举及其变体：能避免空指针异常问题：猜骰子冷热游戏

讲动人的故事，写懂人的代码 2.6 故事4: 一直让玩家不断猜 我们全班要一起用三种语言来写第4个故事啦。这可能是我们所有故事中最复杂的一个了。不过别担心，贾克强已经把这个故事的需求都用投影仪展示出来了。 程序会提示玩家猜两个骰子的点数之和。如果玩家第一次输入点数之…
阅读更多...
gitlab克隆本地切换p分支

gitlab克隆本地切换p分支

使用 git clone 命令克隆远端仓库时&#xff0c;默认情况下只会克隆远端仓库的 master 分支。如果你需要克隆其他分支&#xff0c;需要在克隆仓库后手动检出相应的分支。例如&#xff0c;如果你想克隆并检出名为 p 的分支&#xff0c;可以这样做&#xff1a; 克隆仓库&#xf…
阅读更多...
Spring Boot整合发送QQ邮箱功能

Spring Boot整合发送QQ邮箱功能

1. 创建Spring Boot项目 使用Spring Initializr&#xff08;https://start.spring.io/&#xff09;创建一个新的Spring Boot项目&#xff0c;并添加spring-boot-starter-mail依赖。 2. 添加配置 在application.properties或application.yml文件中添加QQ邮箱的SMTP配置。这里…
阅读更多...
byzer 笔记总结

byzer 笔记总结

1.总览&#xff08;简单了解&#xff09; 1.1 数据挖掘的定义 基于大数据技术&#xff0c;针对有价值是业务场景&#xff0c;对数据中台沉淀的大量数据进行探索&#xff0c;分析。寻找数据与数据之间潜藏的关系&#xff0c;转化为自动化的算法模型&#xff0c;从而获取有价值的…
阅读更多...
python-jenkins调用流水线设置“丢弃旧的构建”(discard old builds)

python-jenkins调用流水线设置“丢弃旧的构建”(discard old builds)

背景 Jenkins任务执行&#xff0c;随之构建次数增多&#xff0c;构建日志所占磁盘大小不断增大&#xff0c;需要配置清除策略。 而 discard old builds 就是配置丢弃旧的构建&#xff1b;若是我们使用python-jenkins 调用修改配置该如何设置&#xff1f; 调用设置 这里是按…
阅读更多...
在远程服务器上安装虚拟环境

在远程服务器上安装虚拟环境

一、Anaconda环境安装 先下载Anaconda Linux版&#xff0c;并将其重命名为anaconda2020.sh wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-2020.07-Linux-x86_64.sh --header"User-Agent: Mozilla/5.0 (Windows NT 6.0) AppleWebKit/537.11 (K…
阅读更多...
C++ static关键字详解

C++ static关键字详解

背景 前段时间初步整理了C中static的相关知识点&#xff0c;以此做个记录。 在C中&#xff0c;static关键字是常见的修饰符。从大方向上static分为两类&#xff1a; 1.类或结构体外的static 2.类或结构体内的static 因此&#xff0c;本文内容的划分如下&#xff1a; 接下来会…
阅读更多...
Day07-06_13【CT】LeetCode手撕—1. 两数之和

Day07-06_13【CT】LeetCode手撕—1. 两数之和

目录 题目1-思路2- 实现⭐1. 两数之和——题解思路 3- ACM实现 题目 原题连接&#xff1a;1. 两数之和 1-思路 哈希表 利用哈希表存储 key 数组元素值 ——> value 数组下标遍历数组 2- 实现 ⭐1. 两数之和——题解思路 class Solution {public int[] twoSum(int[] nums…
阅读更多...
Linux实验八：流式套接字编程

Linux实验八：流式套接字编程

目录 一、实验目的二、实验内容三、实验环境四、参考代码五、实验步骤步骤1. 编辑源代码blockserver.c和blockclient.c步骤2. 编译源代码blockserver.c和blockclient.c步骤3. 运行可执行程序blockserver和blockclient 六、实验结果七、实验总结 一、实验目的 1、深入理解 TCP/…
阅读更多...
最新文章

Copyright @ 2022~2023