• 关于

    泛型函数

    的搜索结果

回答

new 是动态分配的, 都是动态绑定的,只是绑定的对象,有虚函数表的时候,虚函数表的函数指针指向的是具体动态创建的子类的函数而已。 编译器多态值得一般是是函数重载,泛型编程等。是代码层面的多态。######写得挺好######不错!######mark######个人感觉:在没用支持多态的话,所有的函数都是在编译器就进行了绑定,此时仅仅是根据指针的类型进行函数的绑定。也就是指针声明为什么类型,就在相应的类中绑定这个函数。但是当出现了多态性之后,因为 这个函数是虚函数,这时的函数绑定就不应该以指针或引用的声明为准,而应该在运行时,通过对象的vptr查找虚函数表,进而再确定应该调用那个函数。######挺好的

kun坤 2020-06-06 13:42:32 0 浏览量 回答数 0

回答

public static Criteria create(Class<?> clazz) { return new Criteria(clazz); }这是一个静态函数,函数名为create,返回为一个Criteria(它主要数据苦查询中用到),Class<?> clazz这是一个泛型Class类

蛮大人123 2019-12-02 02:15:54 0 浏览量 回答数 0

问题

想写OJ的判题核心,需要跟系统交互,不知道是使用C with class还是使用C++比较好?

a123456678 2019-12-01 20:10:08 950 浏览量 回答数 2

阿里云试用中心,为您提供0门槛上云实践机会!

0元试用32+款产品,最高免费12个月!拨打95187-1,咨询专业上云建议!

问题

Comparable接口的泛型

蛮大人123 2019-12-01 20:01:21 870 浏览量 回答数 1

回答

通过维基百科: Java和C#的早期版本不包含泛型(又称参数多态性)。 在这种情况下,使数组不变会排除有用的多态程序。例如,考虑编写一个对数组进行混洗的函数,或者使用Object.equals元素上的方法测试两个数组是否相等的函数。实现方式不依赖于存储在数组中的元素的确切类型,因此应该可以编写一个可在所有类型的数组上使用的函数。实现类型的功能很容易 boolean equalArrays (Object[] a1, Object[] a2); void shuffleArray(Object[] a); 但是,如果将数组类型视为不变的,则只能在类型完全相同的数组上调用这些函数Object[]。例如,无法将一组字符串混排。 因此,Java和C#都会协变地对待数组类型。例如,在C#中string[]是的子类型object[],在Java中String[]是的子类型Object[]。 这回答了问题:“为什么是数组协变的?”,或者更准确的说,“为什么是由协阵列的时候?” 当引入泛型时,出于Jon Skeet在此答案中指出的原因,有意地使它们无协变: 不,a List 不是List 。考虑一下您可以做什么List -您可以向其中添加任何动物...包括猫。现在,您可以在逻辑上将猫添加到一窝小狗中吗?绝对不。 // Illegal code - because otherwise life would be Bad List dogs = new List (); List animals = dogs; // Awooga awooga animals.add(new Cat()); Dog dog = dogs.get(0); // This should be safe, right? 突然,你有一只非常困惑的猫。 Wikipedia文章中描述的使数组协变的原始动机不适用于泛型,因为通配符使协方差(和相反方差)的表达成为可能,例如: boolean equalLists(List l1, List l2); void shuffleList(List<?> l); 问题来源于stack overflow

保持可爱mmm 2020-02-07 13:18:56 0 浏览量 回答数 0

问题

熟练的掌握Scala语言系列课程:报错

kun坤 2020-06-06 00:23:32 0 浏览量 回答数 1

问题

fastjson如何反序列化为泛型数组

蛮大人123 2019-12-01 20:13:53 1363 浏览量 回答数 1

问题

为什么c++程序员不改用go语言?

a123456678 2019-12-01 20:05:47 1344 浏览量 回答数 1

回答

这是因为他们两个都有相同的 JVM 签名。当运行时,泛型信息是会被擦除的。所以,运行时这两个函数是一样的签名。这不是 Kotlin 的问题,而是将他们编译成 Java 字节码的结果。这只是 Java 的流毒影响 Kotlin 执行的一种方式。

程序员诗人 2019-12-02 00:25:41 0 浏览量 回答数 0

问题

List <T> .Contains()很慢?

保持可爱mmm 2020-02-08 14:15:04 0 浏览量 回答数 1

回答

从原则上讲是这样的,void* 类型主要是用于泛型编程,可以让代码有更好的适应性,比如你写一个两个数相加的函数 如果你写一个整数加法int add(int a,int b);但是如果你想实现浮点数加法,那是不是还要写一个float add(float a,faloat b),是不是很麻烦,但是如果你写成void * add(void a,void b);就可以很好地解决这个问题

a123456678 2019-12-02 02:18:11 0 浏览量 回答数 0

问题

可视化比较 C++、Ruby 和 CoffeeScript 语言的复杂度

a123456678 2019-12-01 20:05:48 1324 浏览量 回答数 1

问题

JDK

琴瑟 2019-12-01 21:46:21 2216 浏览量 回答数 0

问题

反射---Java高级开发必须懂的?报错

爱吃鱼的程序员 2020-06-08 13:13:13 0 浏览量 回答数 1

回答

在函数计算服务使用 Java 编程,需要定义一个 Java 函数作为入口。Java 运行环境根据是否支持 HTTP 触发器分为 普通函数入口 和 HTTP 触发器函数入口 两种函数入口,为函数设置 HTTP 触发器后的函数入口形式会不同,这是为了方便处理发来的 HTTP request 请求并允许用户返回自定义 HTTP header。其中 普通函数入口 又分为 处理函数入口 和 initializer入口。 本文对 普通函数入口 和 HTTP 触发器函数入口 进行详细介绍: 普通函数入口 处理函数入口 StreamRequestHandler PojoRequestHandler initializer 入口 HTTP 触发器函数入口 Java 代码打包 普通函数入口 处理函数入口 用户在使用 Java 编程时,必须要实现函数计算提供的接口类,对于普通函数入口目前有 2 个预定义接口可选择: StreamRequestHandler以流的方式接受调用输入event和返回执行结果,用户需要从inputStream中读取调用函数时的输入,处理完成后把函数执行结果写入到outputStream中来返回。 PojoRequestHandler通过泛型的方式,用户可以自定义输入和输出的类型,但是它们必须是POJO类型。 StreamRequestHandler 一个最简单的处理函数定义如下: package example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.StreamRequestHandler; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class HelloFC implements StreamRequestHandler { @Override public void handleRequest( InputStream inputStream, OutputStream outputStream, Context context) throws IOException { outputStream.write(new String("hello world").getBytes()); } } 1. 包名/类名 包名和类名可以是任意的,但是需要与创建函数时的 “Handler” 字段相对应:上面的例子包名是 “example”,类名是 “HelloFC”,那么创建函数时指定的 Handler 为 example.HelloFC::handleRequest,”Handler” 的格式为 {package}.{class}::{method}。 实现的接口 用户的代码中必须要实现函数计算预定义的接口。上面的例子中实现了StreamRequestHandler,其中的 inputStream 参数是调用函数时传入的数据,outputStream 用于返回函数的执行结果。 context参数 context 参数中包含一些函数的运行时信息(例如 request id/临时 AK 等)。其类型是 com.aliyun.fc.runtime.Context。 返回值 实现StreamRequestHandler接口的函数通过outputStream参数返回执行结果 引入接口库 其中用到的com.aliyun.fc.runtime这个包的依赖可以通过下面的 pom.xml 引用: com.aliyun.fc.runtime fc-java-core 1.3.0 通过 maven 仓库 可以获取fc-java-core最新的版本号。 在创建函数之前,用户需要将代码及其依赖的 fc-java-core 打包成 jar。关于如何打包,请参见 Java 代码打包。 打包成 jar 后就可以使用 Fun 或者控制台上传代码,以 Fun 为例: 在项目根目录创建一个 template.yml 的文件: ROSTemplateFormatVersion: '2015-09-01' Transform: 'Aliyun::Serverless-2018-04-03' Resources: FunDemo: Type: 'Aliyun::Serverless::Service' javademo: Type: 'Aliyun::Serverless::Function' Properties: Handler: example.HelloFC::handleRequest Runtime: java8 CodeUri: './example.jar' 这个 template.yml 的含义如下:声明一个名为 FunDemo 的 服务,并在这个服务下,再声明一个名为 javademo 的 函数,配置函数入口为 example.HelloFC::handleRequest,以及函数的 runtime 为 java8。并且,我们指定了 CodeUri 为 ./example.jar。在部署时,Fun 会将 CodeUri 指定的目录或文件打包上传。更多的配置规则 请参考。 示例代码包是示例中的 hello world 代码打包成的 jar 包,您可以直接使用 示例代码包 进行测试。 使用 Fun 部署: fun deploy 执行成功时,会看到相关日志: using region: cn-hangzhou using accountId: ***********3557 using accessKeyId: ***********r3Ra using timeout: 300 Waiting for service FunDemo to be deployed... Waiting for function javademo to be deployed... Waiting for packaging function javademo code... package function javademo code done function javademo deploy success service FunDemo deploy success 然后就可以登录控制台查看或直接调用了。 PojoRequestHandler 一个最简单的处理函数定义如下: // HelloFC.java package example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.PojoRequestHandler; public class HelloFC implements PojoRequestHandler<SimpleRequest, SimpleResponse> { @Override public SimpleResponse handleRequest(SimpleRequest request, Context context) { String message = "Hello, " + request.getFirstName() + " " + request.getLastName(); return new SimpleResponse(message); } } // SimpleRequest.java package example; public class SimpleRequest { String firstName; String lastName; public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this.lastName = lastName; } public SimpleRequest() {} public SimpleRequest(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } } // SimpleResponse.java package example; public class SimpleResponse { String message; public String getMessage() { return message; } public void setMessage(String message) { this.message = message; } public SimpleResponse() {} public SimpleResponse(String message) { this.message = message; } } 准备调用的输入文件: { "firstName": "FC", "lastName": "aliyun" } 使用 fcli 调用结果: invk hello-java -f /tmp/a.json {"message":"Hello, FC aliyun"} initializer 入口 无论您的函数使用流式输入还是通过泛型的方式自定义输入和输出,当需要在 Java runtime 中添加 initializer 接口时,都需在原有的基础上额外实现 initializer 预定义的接口。 initializer预定义接口如下: package com.aliyun.fc.runtime; import java.io.IOException; public interface FunctionInitializer { /** * The interface to handle a function compute initialize request * * @param context The function compute initialize environment context object. * @throws IOException IOException during I/O handling */ void initialize(Context context) throws IOException; } 一个简单的流式输入的函数和 initializer 结合的 demo 如下: package aliyun.serverless.test.example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.FunctionComputeLogger; import com.aliyun.fc.runtime.StreamRequestHandler; import com.aliyun.fc.runtime.FunctionInitializer; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class InitializerAndStreamRequest implements StreamRequestHandler, FunctionInitializer { @Override public void initialize(Context context) { FunctionComputeLogger logger = context.getLogger(); logger.debug(String.format("RequestID is %s %n", context.getRequestId())); } @Override public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException { FunctionComputeLogger logger = context.getLogger(); logger.debug(String.format("RequestID is %s %n", context.getRequestId())); output.write(new String("hello world!").getBytes()); output.flush(); } } 针对 InitializerAndStreamRequest 中新增加的 initialize 方法即是 initializer 接口,特性如下: 包名/类名 initializer 所属包名和类名和处理函数一致,都可以是任意的。”initializer” 的格式同为 {package}.{class}::{method},与 “handler” 不同的是 handler 中的 method 为 handleRequest,initializer 的 method 为 initialize。根据定义可知此示例的 initializer 为 aliyun.serverless.test.example.InitializerAndStreamRequest::initialize。 实现的接口 用户的代码中必须要实现函数计算预定义的接口。上面示例中 initializer 接口实现了FunctionInitializer,initializer 接口只有一个 context 参数。 context参数 context 参数中包含一些函数的运行时信息(例如 request id/临时 AK 等)。其类型是 com.aliyun.fc.runtime.Context。 返回值 实现FunctionInitializer接口的函数无返回结果。 泛型的方式输入的函数和 initializer 结合的 demo 如下: package aliyun.serverless.test.example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.PojoRequestHandler; import com.aliyun.fc.runtime.FunctionInitializer; import com.aliyun.fc.runtime.FunctionComputeLogger; public class InitializerAndPojoRequest implements FunctionInitializer,PojoRequestHandler<SimpleRequest, SimpleResponse> { @Override public void initialize(Context context) { FunctionComputeLogger logger = context.getLogger(); logger.debug(String.format("RequestID is %s %n", context.getRequestId())); } @Override public SimpleResponse handleRequest(SimpleRequest request, Context context) { FunctionComputeLogger logger = context.getLogger(); logger.debug(String.format("RequestID is %s %n", context.getRequestId())); String message = "Hello, " + request.getFirstName() + " " + request.getLastName(); return new SimpleResponse(message); } } HTTP 触发器函数入口 HTTP 触发器函数接口 HTTP 触发器的简单示例 HTTP 触发器支持传统web应用 关于 HTTP 触发器 的使用请参考:HTTP 触发器 HTTP 触发器函数接口 函数计算提供基于 Servlet 协议的 HTTP 触发器入口,具体接口形式如下: public interface HttpRequestHandler { /** * The entrance function of fc http trigger * @param request The servlet request * @param response The servlet response * @param context The fc context * @throws IOException If IO exception happened * @throws ServletException If servlet exception happened */ public void handleRequest(HttpServletRequest request, HttpServletResponse response, Context context) throws IOException, ServletException; } 使用 HTTP 触发器需将 fc-java-core 库版本升级到 1.3.0 及以上。 HTTP 触发器的简单示例 package com.aliyun.fc.example; import java.io.IOException; import java.io.OutputStream; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.HttpRequestHandler; public class Hello implements HttpRequestHandler { public void handleRequest(HttpServletRequest request, HttpServletResponse response, Context context) throws IOException, ServletException { String requestPath = (String) request.getAttribute("FC_REQUEST_PATH"); String requestURI = (String) request.getAttribute("FC_REQUEST_URI"); String requestClientIP = (String) request.getAttribute("FC_REQUEST_CLIENT_IP"); response.setStatus(200); response.setHeader("header1", "value1"); response.setHeader("header2", "value2"); String body = String.format("Path: %s\n Uri: %s\n IP: %s\n", requestPath, requestURI, requestClientIP); OutputStream out = response.getOutputStream(); out.write((body).getBytes()); out.flush(); out.close(); } } 1. HttpServletRequest 函数计算 HTTP 触发器的接口直接使用标准的 Servlet 协议。 用户的请求会封装成HttpServletRequest对象,用户请求参数、请求header等均可通过此对象获取。 除此之外,函数计算在HttpServletRequest中预封装了一些属性, 可通过 getAttribute 方法来获取, 具体包括: FC_REQUEST_PATH 获取请求的 Path FC_REQUEST_URI 获取请求的 URI FC_REQUEST_CLIENT_IP 获取请求的 ClientIP HttpServletResponse 用户可通过标准的HttpServletResponse协议对象来返回响应 header 和 body. context参数 context 参数中包含一些函数的运行时信息(例如 request id/临时 AK 等)。其类型是 com.aliyun.fc.runtime.Context。 HTTP 触发器支持传统web应用 基于 Servlet 协议的传统 web 应用能很方便的迁移到函数计算平台,目前支持的主流框架包括 Spring 、 SpringBoot 、 Struts2 等。以下示例如何通过函数计算提供的 fc-java-common 库来加载 web 应用. 打包您的 web 工程,生成 demo.war 包 上传 demo.war 包到 OSS,比如为 demo-bucket 下的 demo.war 创建函数,并设置函数初始化入口和函数入口。 函数示例代码如下: package com.aliyun.fc.example; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.FcAppLoader; import com.aliyun.fc.runtime.FunctionComputeLogger; import com.aliyun.fc.runtime.FunctionInitializer; import com.aliyun.fc.runtime.HttpRequestHandler; public class HelloWeb implements FunctionInitializer, HttpRequestHandler { private FcAppLoader fcAppLoader = new FcAppLoader(); private String ossEndPoint = "YourOSSEndPoint"; private String bucket = "YourOSSBucket"; private String key = "YourWarName"; private String userContextPath = "/2016-08-15/proxy/{YourServiceName}/{YourFunctionName}"; @Override public void initialize(Context context) throws IOException { FunctionComputeLogger fcLogger = context.getLogger(); fcAppLoader.setFCContext(context); // Load code from OSS fcAppLoader.loadCodeFromOSS(ossEndPoint, bucket, key); // Init webapp from code fcAppLoader.initApp(userContextPath, HelloWeb.class.getClassLoader()); } @Override public void handleRequest(HttpServletRequest request, HttpServletResponse response, Context context) throws IOException, ServletException { try { fcAppLoader.forward(request, response); } catch (Exception e) { e.printStackTrace(); } } } 引用 Maven 库 com.aliyun.fc.runtime fc-java-core 1.3.0 com.aliyun.fc.runtime fc-java-common 2.2.2 Java 代码打包 使用 maven 打包jar 使用 IDEA 打包jar 使用 maven 打包 jar 在 pom.xml 中添加 maven-assembly-plugin 插件 maven-assembly-plugin 3.1.0 jar-with-dependencies false make-assembly package single org.apache.maven.plugins maven-compiler-plugin 1.8 1.8 打包 mvn package 执行完毕后,生成的 jar 会被存放在 target 目录下。 使用 maven 打包 jar,并将依赖以 jar 的形式存放在 /lib 目录中 随着项目依赖的增加,jar 的体积会变得越来越大。而用户上传的 jar 或者 zip 代码,在执行前,首先会被解压缩,然后才会被加载、执行。因此在刚才的两种实现中,存在的一个问题是我们打包的 jar 中包含了大量的 class 文件,这无疑会增加解压缩的时间,进而增加函数的首次启动时间。 一个更好的实践是将第三方依赖以 jar 的形式,存放于 /lib 目录。 这里提供一种使用 maven-dependency-plugin 实现的方案: org.apache.maven.plugins maven-dependency-plugin copy-dependencies prepare-package copy-dependencies ${project.build.directory}/classes/lib runtime 执行完 mvn package,打包好的 jar 的目录结构为: /.class lib/*.jar 使用 IDEA 打包 jar 配置导出 jar 包的选项: java1 java2 java3 验证打包结果 rockuw-MBP:hello-java (master) $ ls -lrth total 6520 -rw-r--r-- 1 rockuw staff 3.2M Aug 31 21:03 hellofc.jar rockuw-MBP:hello-java (master) $ jar -tf hellofc.jar | head Picked up _JAVA_OPTIONS: -Duser.language=en META-INF/MANIFEST.MF example/ example/HelloFC.class example/SimpleRequest.class example/SimpleResponse.class META-INF/ META-INF// org/ org// org/apache/ 函数计算目前支持以下 Java 运行环境: OpenJDK 1.8.0 (runtime = java8) 对于 Java 运行环境的基本使用请参考Java 函数入口。以下将介绍 Java 运行环境相关特性: 使用 context 使用 logging 使用自定义的模块 异常处理 使用context context 是函数计算在运行时生成的一个对象,其中包含一些运行时的信息,用户在代码中可以使用这些信息。其定义如下,具体实现可以在 这里 找到: package com.aliyun.fc.runtime; public interface Context { public String getRequestId(); public Credentials getExecutionCredentials(); public FunctionParam getFunctionParam(); public FunctionComputeLogger getLogger(); } 可以看到 context 中包含了4个信息: RequestId: 本次调用请求的唯一 id,用户可以把它记录下来在出现问题的时候方便调查 FunctionParam: 当前调用的函数的一些基本信息如函数名/函数入口/函数内存/超时时间 ExecutionCredentials: 函数计算服务通过扮演用户提供的 服务角色获得的一组临时密钥,其有效时间是 5 分钟。用户可以在代码中使用它去访问相应的服务(例如 OSS),这就避免了用户把自己的 AK 信息写死在函数代码里。 Logger: 函数计算封装过的 logger,见下面的 使用logging 例如下面的代码使用临时密钥,向 OSS 中上传了一个文件: package example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.Credentials; import com.aliyun.fc.runtime.StreamRequestHandler; import com.aliyun.oss.OSSClient; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class HelloFC implements StreamRequestHandler { @Override public void handleRequest( InputStream inputStream, OutputStream outputStream, Context context) throws IOException { String endpoint = "oss-cn-shanghai.aliyuncs.com"; String bucketName = "my-bucket"; Credentials creds = context.getExecutionCredentials(); OSSClient client = new OSSClient( endpoint, creds.getAccessKeyId(), creds.getAccessKeySecret(), creds.getSecurityToken()); client.putObject(bucketName, "my-object", new ByteArrayInputStream(new String("hello").getBytes())); outputStream.write(new String("done").getBytes()); } } 使用logging 用户的函数通过 context.getLogger() 打印的内容会被收集到用户在创建 Service 时指定的 LogStore 中: package example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.StreamRequestHandler; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class HelloFC implements StreamRequestHandler { @Override public void handleRequest( InputStream inputStream, OutputStream outputStream, Context context) throws IOException { context.getLogger().info("hello world"); outputStream.write(new String("hello world").getBytes()); } } 上面的代码输出的日志内容是: message:2017-07-05T05:13:35.920Z a72df088-f738-cee3-e0fe-323ad89118e5 [INFO] hello world 使用 context.getLogger().warn 和 context.getLogger().error 分别可以打包 WARN/ERROR 级别的日志。 使用自定义的模块 如果用户需要使用自定义的模块,则需要在打包 jar 时,将它们与代码一起打包。以下演示如何将 OSS Java SDK 打包到项目中。 在 pom.xml 中添加 OSS java SDK: com.aliyun.fc.runtime fc-java-core 1.2.1 com.aliyun.oss aliyun-sdk-oss 2.6.1 执行通用打包流程 请参考 Java 代码打包 错误处理 用户的函数在执行过程如果抛出异常,那么函数计算会把异常捕获并将异常信息返回。例如下面的代码: package example; import com.aliyun.fc.runtime.Context; import com.aliyun.fc.runtime.StreamRequestHandler; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class HelloFC implements StreamRequestHandler { @Override public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context) throws IOException { throw new IOException("oops"); } } 调用时收到的响应为: invk hello-java -f /tmp/a.json { "errorMessage" : "oops", "errorType" : "java.io.IOException", "errorCause" : "oops", "stackTrace" : [ "example.HelloFC.handleRequest(HelloFC.java:15)" ] } Error: Request id: 45dd8d90-6b78-cce3-087c-8bf4ebc6c9af. Error type: UnhandledInvocationError 发生异常时,函数调用的响应的HTTP header中会包含X-Fc-Error-Type: UnhandledInvocationError。

1934890530796658 2020-03-27 16:27:27 0 浏览量 回答数 0

回答

E[]表示该函数需要一个类型为的对象数组E。E是泛型类型。有关更多信息,请参见此处。 您无法将传送ArrayList给该方法,因为ArrayList并非是Array。它也已经是Collection,因此将其与ArrayList一起使用将毫无意义。 为什么要收藏?因为它实现了Collection接口。如果该方法旨在将数组转换为Collection,则可以看到如何将ArrayList转换为Array,以便可以将其发送通过,这是一个坏主意。 不过,如果您已经知道E 的具体含义(运行程序时它将是什么类型),您当然仍然可以将arraylist转换为数组并通过该方法发送它。

问问小秘 2020-02-14 10:58:33 0 浏览量 回答数 0

问题

使用SwiftUI从线框创建新的Viper模块

游客5akardh5cojhg 2019-12-23 18:37:51 0 浏览量 回答数 1

问题

有人可以将这个非常简洁的Java函数分解成更详细的示例吗?

montos 2020-03-25 21:47:09 2 浏览量 回答数 1

回答

一般来讲,我们用到“类1<类2>”这样的形式的Java语句,通常是希望将范围比较大的类1里面所包含的内容规范化成类2;举个简单的例子,我们通常会在创建集合的时候限定集合里面的内容的类型,如:List。这意味着这个List集合里的内容都是字符串类型,而不会是Long或其他,这样就会在我们操作这个集合的时候提供一些规范,我们在调用add函数的时候,就只能按照规范,传进去字符串类型的参数值。这样就使我们在使用的时候更加规范。至于你说的“类<类>”泛型是自身的情况在项目中比较少见,如果是List这样的,可以表示多维集合吧,不过到目前为止我并没有用过这样的东西。语法上是否有错,你可以通过在你的IDE中去试试就知道了,实践出真知,这比别人告诉你结果会更加深刻哦。希望我的回答对你有所帮助。

蛮大人123 2019-12-02 02:19:56 0 浏览量 回答数 0

问题

使用泛型构造子类的实例

游客5ltrhvc3ievgs 2020-03-28 11:09:11 4 浏览量 回答数 1

回答

一、Lambda表达式 Lambda表达式可以说是Java 8最大的卖点,她将函数式编程引入了Java。Lambda允许把函数作为一个方法的参数,或者把代码看成数据。 一个Lambda表达式可以由用逗号分隔的参数列表、–>符号与函数体三部分表示。例如: Arrays.asList( "p", "k", "u","f", "o", "r","k").forEach( e -> System.out.println( e ) ); 1 Arrays.asList( "p", "k", "u","f", "o", "r","k").forEach( e -> System.out.println( e ) ); 为了使现有函数更好的支持Lambda表达式,Java 8引入了函数式接口的概念。函数式接口就是只有一个方法的普通接口。java.lang.Runnable与java.util.concurrent.Callable是函数式接口最典型的例子。为此,Java 8增加了一种特殊的注解@FunctionalInterface: 1 @FunctionalInterface2 public interface Functional {3 void method();4 }二、接口的默认方法与静态方法 我们可以在接口中定义默认方法,使用default关键字,并提供默认的实现。所有实现这个接口的类都会接受默认方法的实现,除非子类提供的自己的实现。例如: 1 public interface DefaultFunctionInterface {2 default String defaultFunction() {3 return "default function";4 }5 }我们还可以在接口中定义静态方法,使用static关键字,也可以提供实现。例如: 1 public interface StaticFunctionInterface {2 static String staticFunction() {3 return "static function";4 }5 }接口的默认方法和静态方法的引入,其实可以认为引入了C++中抽象类的理念,以后我们再也不用在每个实现类中都写重复的代码了。 三、方法引用 通常与Lambda表达式联合使用,可以直接引用已有Java类或对象的方法。一般有四种不同的方法引用: 构造器引用。语法是Class::new,或者更一般的Class< T >::new,要求构造器方法是没有参数; 静态方法引用。语法是Class::static_method,要求接受一个Class类型的参数; 特定类的任意对象方法引用。它的语法是Class::method。要求方法是没有参数的; 特定对象的方法引用,它的语法是instance::method。要求方法接受一个参数,与3不同的地方在于,3是在列表元素上分别调用方法,而4是在某个对象上调用方法,将列表元素作为参数传入; 四、重复注解 在Java 5中使用注解有一个限制,即相同的注解在同一位置只能声明一次。Java 8引入重复注解,这样相同的注解在同一地方也可以声明多次。重复注解机制本身需要用@Repeatable注解。Java 8在编译器层做了优化,相同注解会以集合的方式保存,因此底层的原理并没有变化。 五、扩展注解的支持 Java 8扩展了注解的上下文,几乎可以为任何东西添加注解,包括局部变量、泛型类、父类与接口的实现,连方法的异常也能添加注解。 六、Optional Java 8引入Optional类来防止空指针异常,Optional类最先是由Google的Guava项目引入的。Optional类实际上是个容器:它可以保存类型T的值,或者保存null。使用Optional类我们就不用显式进行空指针检查了。 七、Stream Stream API是把真正的函数式编程风格引入到Java中。其实简单来说可以把Stream理解为MapReduce,当然Google的MapReduce的灵感也是来自函数式编程。她其实是一连串支持连续、并行聚集操作的元素。从语法上看,也很像linux的管道、或者链式编程,代码写起来简洁明了,非常酷帅! 八、Date/Time API (JSR 310) Java 8新的Date-Time API (JSR 310)受Joda-Time的影响,提供了新的java.time包,可以用来替代 java.util.Date和java.util.Calendar。一般会用到Clock、LocaleDate、LocalTime、LocaleDateTime、ZonedDateTime、Duration这些类,对于时间日期的改进还是非常不错的。 九、JavaScript引擎Nashorn Nashorn允许在JVM上开发运行JavaScript应用,允许Java与JavaScript相互调用。 十、Base64 在Java 8中,Base64编码成为了Java类库的标准。Base64类同时还提供了对URL、MIME友好的编码器与解码器。 除了这十大新特性之外,还有另外的一些新特性: 更好的类型推测机制:Java 8在类型推测方面有了很大的提高,这就使代码更整洁,不需要太多的强制类型转换了。 编译器优化:Java 8将方法的参数名加入了字节码中,这样在运行时通过反射就能获取到参数名,只需要在编译时使用-parameters参数。 并行(parallel)数组:支持对数组进行并行处理,主要是parallelSort()方法,它可以在多核机器上极大提高数组排序的速度。 并发(Concurrency):在新增Stream机制与Lambda的基础之上,加入了一些新方法来支持聚集操作。 Nashorn引擎jjs:基于Nashorn引擎的命令行工具。它接受一些JavaScript源代码为参数,并且执行这些源代码。 类依赖分析器jdeps:可以显示Java类的包级别或类级别的依赖。 JVM的PermGen空间被移除:取代它的是Metaspace(JEP 122)。

auto_answer 2019-12-02 01:55:13 0 浏览量 回答数 0

回答

诸如List<T>等泛型集合类,直接提供了sort()方法用于将集合中的元素进行排序。 但是,其前提是集合中存放的是可直接排序的基本类型,如List<int>, List<double>,如果 我们定义了一个自定义类型 Class MyClass,并创建一个自定义类型的集合如List<MyClass>, 那么无参的sort()方法就不可用了,因为不知道如何排序了。这时就需要借助: IComparer 和 IComparable 首先,我们来看一下c#泛型List提供的Sort方法: 泛型List类的Sort方法有四种形式,分别是 1,不带有任何参数的Sort方法----Sort(); 2,带有比较器参数的Sort方法 ----Sort(IComparer<T>) 3,带有比较代理方法参数的Sort方法----Sort(Comparison<(Of <(T>)>)) 4,带有比较器参数,可以指定排序范围的Sort方法----Sort(Int32, Int32 IComparer(T)) 【解析:】第一种方法 使用这种方法不是对List中的任何元素对象都可以进行排序,List中的元素对象必须继承IComparable接口,并且要实现IComparable接口中的CompareTo()方法,在CompareTo()方法中要自己实现对象的比较规则。 例如,Int32和Double都是实现了IComparable接口并重载了CompareTo方法的结构。(注:int和double都是Int32和Double的别名(alias)) 【解析:】第二种方法 2,带有比较器参数的Sort方法 ----Sort(IComparer<T>), 1)创建一个额外的比较器类:其实就相当于将排序功能中的比较操作,留个使用者来完成。这个比较操作必须在实现了IComparer接口的自定义比较类中完成;如: class myComparer:IComparer<MyClass> 2)制定比较规则实现比较方法:因为接口中有一个用于比较的重载函数Compare,所在在比较器类中我们必须实现它,完成自己希望的比较。所谓自己希望的比较就是说自己实现自定义对象的比较规则,例如你知道自定义类MyClass中哪个属性适合用来排序,那么就选择这个属性作为整个自定义类对象的排序属性,如该类中有年龄,学号,入学日期等属性,你可以选择年龄属性作为排序属性。如: public class myComparer:IComparer<MyClass> { //实现按年龄升序排列 public int Compare(MyClass x, MyClass y) { return (x.age.CompareTo(y.age)); //age代表年龄属性是整型,即其已支持CompareTo方法 } } 3)使用比较器的排序方法调用:然后,在自定义类型的集合如List<MyClass> myList,上就可以进行sort排序了,如 myList.Sort(new myComparer()); 【解析:】第三种方法 3,带有比较代理方法参数的Sort方法----Sort(Comparison<(Of <(T>)>)) Comparison<(Of <(T>)>是一种泛型委托。所以,需要编写一个对象排序比较的方法,对List中的元素对象没有特殊的要求,但在比较方法中需要实现 对象比较规则,这个方法实现后,就可以把这方名字作为参数委托给List的Sort方法,Sort方法在排序时会执行这个方法对List中的对象进行比较 需要编写一个对象排序比较的方法,对List中的元素对象没有特殊的要求,但在比较方法中需要实现对象比较规则,这个方法实现后,就可以把这方名字作为参 数委托给List的Sort方法,Sort方法在排序时会执行这个方法对List中的对象进行比较 【解析:】第四种方法 4,带有比较器参数,可以指定排序范围的Sort方法----Sort(Int32, Int32 IComparer(T)) 对于第四排序方法,实际是第二种比较器排序的一个扩展,在指定排序比较器的同时,指定排序范围,即List中准备排序的开始元素索引和结束元素索引

行者武松 2019-12-02 01:17:43 0 浏览量 回答数 0

回答

Kotlin的简介 Kotlin是由JetBrains公司(IDEA开发者)所开发的编程语言,其名称来自于开发团队附近的科特林岛。 多平台开发 JVM :Android; Server-Side Javascript:前端 Native(beta) :开发原生应用 windows、macos、linux Swift与Kotlin非常像 http://nilhcem.com/swift-is-like-kotlin/ kotlin发展历程 image.png java发展历程 image.png JVM语言的原理 image.png JVM规范与java规范是相互独立的 只要生成的编译文件匹配JVM字节码规范,任何语言都可以由JVM编译运行. Kotlin也是一种JVM语言,完全兼容java,可以与java相互调用;Kotlin语言的设计受到Java、C#、JavaScript、Scala、Groovy等语言的启发 kotlin的特性 下面不会罗列kotlin中具体的语法,会介绍我认为比较重要的特性,以及特性背后的东西。 类型推断 空类型设计 函数式编程 类型推断 image.png 类型推断是指编程语言中在编译期自动推导出值的数据类型。推断类型的能力让很多编程任务变得容易,让程序员可以忽略类型标注的同时仍然允许类型检查。 在开发环境中,我们往往写出表达式,然后可以用快捷键来生成变量声明,往往都是很准的,这说明了编译器其实是可以很准确的推断出来类型的。编程语言所具备的类型推断能力可以把类型声明的任务由开发者转到了编译器. java中声明变量的方式是类型写在最前面,后面跟着变量名,这就迫使开发者在声明变量时就要先思考变量的类型要定义成什么,而在一些情况下比如使用集合、泛型类型的变量,定义类型就会变得比较繁琐。 Kotlin中声明变量,类型可以省略,或者放到变量名后面,这可以降低类型的权重,从必选变为可选,降低开发者思维负担。java10中也引入了类型推断。 Javascript中声明变量也是用关键字var,但是还是有本质区别的,Kotlin中的类型推断并不是变成动态类型、弱类型,类型仍然是在编译期就已经决定了的,Kotlin仍然是静态类型、强类型的编程语言。javascript由于是弱类型语言,同一个变量可以不经过强制类型转换就被赋不同数据类型的值, 编程语言的一个趋势就是抽象程度越来越高,编译器做更多的事情。 空类型设计 空类型的由来 image.png 托尼·霍尔(Tony Hoare),图灵奖得主 托尼·霍尔是ALGOL语言的设计者,该语言在编程语言发展历史上非常重要,对其他编程语言产生重大影响,大多数近代编程语言(包括C语言)皆使用类似ALGOL的语法。他在一次大会上讨论了null应用的设计: “我把 null 引用称为自己的十亿美元错误。它的发明是在1965 年,那时我用一个面向对象语言( ALGOL W )设计了第一个全面的引用类型系统。我加入了null引用设计,仅仅是因为实现起来非常容易。它导致了数不清的错误、漏洞和系统崩溃,可能在之后 40 年中造成了十亿美元的损失。” null引用存在的问题 以java为例,看null引用的设计到底存在哪些问题 空指针问题NPE 编译时不能对空指针做出检查,运行时访问null对象就会出现错误,这个就是工程中常见的空指针异常。 null本身没有语义,会存在歧义 值未被初始化 值不存在 也许表示一种状态 逻辑上有漏洞 Java中,null可以赋值给任何引用,比如赋值给String类型变量,String a = null,但是null并不是String类型: a instanceof String 返回的是false,这个其实是有些矛盾的。所以当持有一个String类型的变量,就存在两种情况,null或者真正的String. 解决NPE的方式 防御式代码 在访问对象前判空,但会有冗余代码;会规避问题,而隐藏真正的问题 抛出异常给调用方处理 方法中传参传入的空值、无效值,抛出受检查异常给上层调用方 增加注解 Android中可以增加@NonNull注解,编译时做额外检查 空状态对象设计模式 空状态对象是一个实现接口但是不做任何业务逻辑的对象,可以取代判空检查;这样的空状态对象也可以在数据不可用的时候提供默认的行为 java8 Optional类 java8中引入了Optional类,来解决广泛存在的null引用问题.官方javadoc文档介绍 A container object which may or may not contain a non-null value. If a value is present, isPresent() will return true and get() will return the value. Additional methods that depend on the presence or absence of a contained value are provided, such as orElse() (return a default value if value not present) and ifPresent() (execute a block of code if the value is present). 来看一下是如何实现的。 举一个访问对象读取熟悉的例子 java 8 之前 : image.png java 8: image.png 总结: 1.用Optional还是会比较繁琐,这个也说明了设计一个替代null的方案还是比较难的。 optional的耗时大约是普通判空的数十倍,主要是涉及泛型、使用时多创键了一个对象的创建;数据比较大时,会造成性能损失。 java8 引入Optional的意义在于提示调用者,用特殊类型包装的变量可能为空,在使用取出时需要判断 Kotlin的空类型设计 Kotlin中引入了可空类型和不可空类型的区分,可以区分一个引用可以容纳null,还是不能容纳null。 String vs String? String 类型表示变量不能为空,String?则表示变量可以为空 String?含义是String or null.这两种是不同的类型. 比如: var a:String = “abc” //ok var a:String = null //不允许 var b :String? = null //ok a=b // 不允许 String?类型的值不能给String类型的值赋值 这样就将类型分成了可空类型和不可能类型,每一个类型都有这样的处理;Kotlin中访问非空类型变量永远不会出现空指针异常。 同样上面的例子,采用Kotlin去写,就会简洁很多 image.png 编程范式-函数式编程 编程范式是什么? 编程范式是程序员看待程序和写程序的观点 主要的类型 非结构化编程 结构化编程 面向对象编程 命令式编程 函数式编程 这些类型并不是彼此互斥的,而是按照不同的维度做的划分,一种编程语言可能都支持多个编程范式 非结构化编程 第一代的高级语言往往是非结构化编程 比如 BASIC语言 每一行的代码前面都有一个数字作为行号,通常使用GOTO的跳跃指令来实现判断和循环. 看一下下面这段代码是做什么的: image.png 实际上做的是:程序在屏幕上显示数字 1 到 10 及其对应的平方 采用这种方式写程序,大量的使用goto实现逻辑的跳转,代码一长,可读性和维护性就比较差了,形成“面条式代码” 结构化编程 采用顺序、分支、循环结构来表达,禁用或者少用GOTO; 并用子程序来组织代码,采用自顶向下的方式来写程序 代表语言是C语言 实现同样的逻辑: image.png 可见采用结构化编程,代码的逻辑会更清晰。 面向对象编程 思想: 将计算机程序视为一组对象的集合,而每个对象都可以接收其他对象发过来的消息,并处理这些消息,计算机程序的执行就是一系列消息在各个对象之间传递。 特性: 封装性、继承性、多态性。 命令式编程 把计算机程序视为一系列的命令集合 主要思想是关注计算机执行的步骤,即一步一步告诉计算机先做什么再做什么。 “先做这,再做那”,强调“怎么做” 实现: 用变量来储存数据,用语句来执行指令,改变变量状态。 基本所有的常见的编程语言都具有此范式 函数式编程 声明式语法,描述要什么,而不是怎么做 类似于SQL语句 语言: kotlin swift python javascript scala 函数是第一等公民 可以赋值给变量,可作为参数传入另一个函数,也可作为函数的返回值 纯函数 y=f(x) 只要输入相同,返回值不变 没有副作用:不修改函数的外部状态 举个栗子 公司部门要进行outing,去哪里是个问题,要考虑多个因素,比如花费、距离、天数等等,有多个备选地点进行选择。 定义一个数据类: image.png 要进行筛选了,分别用sql,kotlin,java来实现 找出花费低于2000元的outing地点信息 SQL image.png Kotlin image.png java 7 image.png 可见kotin的写法还是比较接近于sql的思想的,声明式的写法,而不管具体如何实现;其中的:place->place.money<2000 就是函数,可以作为参数传递给fliter这个高阶函数;而且这个函数没有副作用,不改变外部状态。 再来一个复杂一点的: 找出花费低于5000元,时间不多于4天,按照距离排序的outing地点名称 SQL image.png Kotlin: image.png java 7 image.png 由此可见用kotlin的函数式写法,会更简洁,逻辑也更清晰,这段代码的目标一目了然,这种清晰在于实现了业务逻辑与控制逻辑的分离,业务逻辑就是由函数实现的,比如place->place.money<500,而控制逻辑是由filter,sorterBy等高阶函数实现的。 而java的传统写法是基于对数据的操作,避免不了遍历的操作,业务逻辑与控制逻辑交织在了一起,这段代码的目的就不是那么容易清晰看到的了。 总结 kotlin是实用的现代编程语言,吸收了众多编程语言的优点,支持类型推断、空类型安全、函数式编程、DSL等特性,非常值得学习和使用。

问问小秘 2020-04-30 16:33:40 0 浏览量 回答数 0

回答

个人觉得比较运行速度其实没啥意义, 因为两种语言都是生成 JVM 的字节码, 依赖 JVM 这个虚拟平台来跑代码. 除非 Scalac (scala的编译器) 有重大 bug, 生成的字节码执行让人无法接受, 否则基本上不会相差太多. 再说, scala 都到大版本2了, 这种概率实在是不大.相比较与 Java, 在下觉得 Scala 最主要的有以下两点优势:•FP 泛型支持 如果用多了 Spring 中大量的 template 接口, 你就会觉得 FP 其实还是蛮好用的.而这仅仅是 FP 好处的冰山一角.函数其实就是一个 input -> output (scala 也是这么表示一个函数的), 没有任何副作用, 与状态无关, 由于这种特性, 所以函数式的编程范式在分布式领域有很多好处 对于函数式编程,我的知识实在是皮毛, 但可以这么说, FP 相对与 OO 有哪些优势, Scala 对于 Java 差不多就有哪些优势.正因为 FP 有如此多的优势, 所以 Java8 才引入了 FP. 从某种程度上来说, Java 认可了 Scala 的做法.•类型系统支持 如果说 Java 是一种类型安全的语言, 那么毫无疑问, Scala 的类型更加安全, 从某种程度上说, Scala 的类型是图灵完备的, 而 Java 不是. 我的一位好朋友在这方面研究的比较深( http://hongjiang.info/scala/ ), 而我对与 Scala 的类型系统的理解, 也还是皮毛.正是以上这两点大优势, 造成了 Scala 比 Java 更加安全, 同时又具备灵活性, 想象力.•其他语言层面上的优势在 Java 中, 你是否有时很想继承多个 AbstractClass 呢? 对不起, Java 只支持单继承在 Scala 中, 你可以进行 mixin (Java 8 也开始引入 default method 了呢)在 Java 中, 想要一个 singleton ? 要么在 static block 中做, 要么利用 Enum 的单例特性完成, 或者其他更纠结的方法.在 Scala 中, 只要声明为 object, 即为单例.在 Java 中, 想要延迟加载一个单例? double check吧在 Scala 中, 只要在 object 中将变量修饰为 lazy 即可在 Java 中, 想要对集合进行一些操作? 使用一层一层的 for 循环吧在 Scala 中, 使用 collection 的一些集合操作, 即可获得如写SQL般的享受.在 Java 中, 在并发中想对Future进行回调? 对不起, Future 不是 Listenable (无法支持回调), 除非你使用额外的工具(如 guava, spring)在 Scala 中, 本来就主张异步编程, future 和 promise 的配合让人非常愉快.在 Java 中, 要透明扩展一个第三方库的类怎么办? 包装, 再加一层.在 Scala 中, 有强大的 implicit 机制让你更优雅的做到这一点, 同时还能保证类型安全(比起 Ruby 的 monkey patch, 要安全得多)•Scala 的表达力很强, 相同功能的代码, 用 Java 和 Scala 的行数不可同日而语.这些单单是语言层面上的优势, 除此之外, Scala 还能无缝结合 Java尽管罗列了如此多的好处, 但 Scala 有如下劣势:•语法复杂, 学习曲线非常高•国内 Scala 程序员很难找 (目前 Scala 的影响力也在缓慢扩大, 比如 Scala 社区中的明星 Spark 的流行也在慢慢拉动 Scala 的流行, 如同 rails 之于 ruby)•社区, 生态还比较小, Scala 风格的库还非常少(但可以和 Java 很容易的斜街很多时候弥补了这一点)对于程序员来说: Scala 很难学, 但值得学 对于企业来说: Scala 是过滤优秀(好学)程序员(Geek)的好滤斗.

蛮大人123 2019-12-02 01:55:25 0 浏览量 回答数 0

问题

Go语言编程有哪些利与弊?编程时如何判断是否应该用Go?

有只黑白猫 2020-01-06 13:37:29 15 浏览量 回答数 1

问题

Java基础

游客pklijor6gytpx 2019-12-01 22:02:53 69 浏览量 回答数 1

问题

Scala调用Java 泛型函数:报错

kun坤 2020-06-14 09:59:45 0 浏览量 回答数 1

回答

使用通用方法的解决方案 将通用方法定义为 public static <T> List<T> convertGeneric(List<List<Object>> dataframe, Function<Object, T> converter) 也就是说,第一个参数是您的对象集合,第二个参数是您提供从Object到目标类的转换函数。该方法返回一个List 。(请注意, 之后static需要声明一个通用方法。 该方法的实现可以是 List<T> result = new ArrayList<>(); for (List<Object> objects : dataframe) { for (Object object : objects) { T t = converter.apply(object); result.add(t); } } return result; } 或使用流的另一个: public static <T> List<T> convertGeneric(List<List<Object>> dataframe, Function<Object, T> converter) { return dataframe.stream() .flatMap(Collection::stream) // get the objects from the inner list .map(converter) // convert object to T .collect(Collectors.toList()); // put everything in a new list } 转换功能可以实现为lambda,例如 Function<Object, Foo> fooLambda = object -> { Foo foo = new Foo(); // logic for mapping obj to foo return foo; }; 和转换List<List<Object>>到List<Foo>变为: List<Foo> fooList = GenericMethodConverter.convertGeneric(dataFrame, fooLambda); 我认为您为这个问题而苦苦挣扎的原因是,您试图在通用方法中进行所有操作(抽象和具体部分)。您已经知道,泛型方法随后需要其他信息才能使用哪种具体实现(在您的版本中,将转换的目标类型作为第二个参数传递)。在上述解决方案中,通用方法需要转换函数Function<Object,T>,即将对象映射到目标类型T的函数。通用方法将此函数应用于所有对象,并将结果放入返回的列表中。用于映射的具体实现object为Foo作为从而reifying通用lambda表达式被供给T到Foo。可以根据需要添加其他转换功能。 另一种方法 这是使用面向对象/类而不是静态方法的解决方案: 定义一个抽象基类GenericConverter,其中包含要遍历列表的迭代,并声明一个抽象方法如何将an转换Object为目标类型: public abstract class GenericConverter<T> { public List<T> convertGenerically(List<List<Object>> dataFrame) { List<T> tList = new ArrayList<>(); for (List<Object> objectList : dataFrame) { for (Object obj : objectList) { T t = convert(obj); tList.add(t); } } return tList; } protected abstract T convert(Object obj); } 为每个目标类添加一个实现,例如,转换Object为Foo: public class FooConverter extends GenericConverter<Foo> { @Override protected Foo convert(Object obj) { Foo foo = new Foo(); // logic for mapping obj to foo return foo; } } 然后Objects通过调用实现类的方法来转换: List<Foo> foos = fooConverter.convertGenerically(dataFrame); 回答来源:Stack Overflow

montos 2020-03-24 17:52:36 0 浏览量 回答数 0

回答

Go 当 Gophers 回顾 2019 年时,他们可能会记得尝试提案的传奇故事。Go 开发人员兼作家 Jon Bodner 解释说: 关于 Go 的最常见的抱怨之一是错误处理太冗长。因此,在 6 月初,Go 核心开发人员建议添加一个名为 try 的新内置函数。GitHub 的 issue 现在已打开,以讨论此新功能。一个月之内,有将近 800 条评论,其中大多数是负面的。反对这项新功能的人们感到,这种改变使代码过于“不可思议”,并掩盖了逻辑流程。审查反馈后,Go 小组将提案标记为已完成,并于 7 月 16 日关闭。 这个过程值得注意的不是功能的失败,而是,正如 Bodner 所描述的那样,“过程发生的方式:提出了一个功能,讨论受到尊重,但许多人认为更改与 Go 的风格不一致。最后,管理语言的人决定尊重多数意见。这就是开发人员谈论社区时的意思。” 2020 年应该使 Go 的 Contracts 规范更加清晰,这就是众所周知的 Generics 提案。 根据 Bodner 的说法,“ Go 似乎将使用一种与其他语言略有不同的方法来实现泛型,但它很适合 Go 的习惯用法。” 希望它将使 Go 保持其惯用的风格,同时添加开发人员发现在其他语言中有用的功能。 该回答来自:徐九

剑曼红尘 2020-03-06 10:39:08 0 浏览量 回答数 0

问题

2020年热门编程语言的发展方向

珍宝珠 2020-02-17 17:58:58 3889 浏览量 回答数 3
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 企业建站模板