Java 和 Scala 如何调用变参

Java 和 Scala 都支持变参方法, 写在最后的位置上，最基本的调用方式也都是一样的，一个个罗列过去。也可以传入数组参数，因为变参本质上就是一个数组，就是把 ... 开始位置到最后一个参数都收纳到数组中去，所以变参之所以要放在最后的位置上，且一个方法中最多只能有一个变参类型。

这里主要是对比 Scala 对变参方法的调用，基本调用法当然是没问题的，但是在传入数组作为变参的参数列表与 Java 相对时就稍有变化了。

另外提一下，如果想传入 List 作为变参列表，而不是整体作为变参的第一个元素就是调用集合的 toArray() 方法转换成一个数组传入。

下面看 Java 中对变参方法的调用，参数列表和数组

public class JavaVarArgs {
 public static void main(String[] args) {
  foo("a", "b", "c");
  foo(new String[]{"d", "e"});
 }

 public static void foo(String...params) {
  System.out.println(params + " : " + params.length);
  for(String s: params) {
   System.out.println(s);
  }
 }
}

从输出结果能够很明白的看出变参 params 实际上就是一个数组

[Ljava.lang.String;@3f91beef : 3
a
b
c
[Ljava.lang.String;@1a6c5a9e : 2
d
e

我们知道 Scala 和 Java 之间可以互相调用，现在写一段 Scala 代码来调用 foo() 方法

object ScalaVarArgs {

 def main(args: Array[String]) {
  JavaVarArgs.foo("a", "b", "c")

//  JavaVarArgs.foo(Array[String]("d", "e"))
 }
}

JavaVarArgs.foo("a", "b", "c") 调用没问题

而 JavaVarArgs.foo(Array[String]("d", "e")) 会有编译问题

Type mismatch: expected String, actual Array[String]

Java 在调用变参方法时可以直接传入相应类型的数组，而 Scala 确不允许这么做了，因它试图把 Array[String] 整体作为一个元素传递给 foo() 方法，而 foo() 要求的元素类型是字符串，所以编译不过。

而 Scala 这时该如何使得与 Java 调用变参方法时的行为一致呢，那就是在调用时再附加说明：是要把数组中的元素逐个传递级变参，写法

JavaVarArgs.foo(Array[String]("d", "e") :_*)

这样的调用输出就是

[Ljava.lang.String;@7a718e31 : 2
d
e

如果从上面的例子说来，我们的运气还不错，因为编译器告诉了你出现了什么问题。最麻烦的问题总是在能编译，但运行时诡异的情况。

因为在我本人实际中遭遇到的情形是变参类型是 Object 的方法，形如

 public static void foo(Object...params) {
  System.out.println(params + " : " + params.length);
  for(Object o: params) {
    System.out.println(o);
  }
 }

上面把参数改为 Object...params, 不会改变 Java 传数组调用它的行为，但却增加了 Scala 调用它时的排错难度。

在 Scala 中使用 foo(Array[String]("d", "e") 调用并没有编译错误，加入上面的调试代码才发现，不管传入多大的数组，总是输出像

[Ljava.lang.Object;@7814d044 : 1
[Ljava.lang.String;@ea25c1

说方法只接收到了一个元素，类型被识别为形参的类型，不过进一步遍历变参，发现第一个元素是一个字符串数组，所以 Scala 把 Array[String]("d", "e") 整体作为 params 的第一个元素传给了 foo() 方法。写成

foo(Array[String]("d", "e") : _*)

是为了把数组拆散了传给 foo() 方法。

起初以为是 Scala 调用 Java 的变参方法需要这么做，后来重新用 Scala 实现下变参方法

def foo(params: AnyRef*) {
  println(params + " : " + params.length)
  for (s <- params) {
   println(s)
  }
 }

用 Scala 代码来调用它，传入数组，如果不想整体作为一个元素时也必须加上 : _* 参数说明，同样的：

foo(Array[String]("d", "e") :_*)

在写这篇之前，我所认定的这是 Scala 调用变参方法的一个缺陷，: _* 似乎是一种默认行为，现在认为这恰恰是 Scala 的一个灵活性所在。Scala 提供了两种方式来传递数组给变参，而为何 Java 不让数组整体作为变参的一个元素呢，不过 Scala 放开这一特性，当变参为 Object... params 确实放大了 Bug 的出现机率。

以上就是Java 和 Scala 如何调用变参的详细内容，更多关于Java 和 Scala 调用变参的资料请关注我们其它相关文章！

赞 (0)

相关推荐

  • java可变参数当做数组处理的方法示例

    本文实例讲述了java可变参数当做数组处理的方法.分享给大家供大家参考,具体如下: java可变参数当做数组处理 ava1.5增加了新特性:可变参数:适用于参数个数不确定,类型确定的情况,java把可变参数当做数组处理. 注意:可变参数必须位于最后一项. 原因:当可变参数个数多余一个时,必将有一个不是最后一项,所以只支持有一个可变参数.因为参数个数不定,所以当其后边还有相同类型参数时,java无法区分传入的参数属于前一个可变参数还是后边的参数,所以只能让可变参数位于最后一项. 可变参数的特点:

  • Java数组传递及可变参数操作实例详解

    本文实例讲述了Java数组传递及可变参数操作.分享给大家供大家参考,具体如下: 方法可以操作传递和返回基本数据类型,但是方法中也可用来传递和返回数组.如果要向方法中传递一个数组,则方法的接收参数处必须是符合其类型的数组.而且数组属于引用数据类型,所以在把数组传递进方法之后,如果方法对数组本身做了任何修改,修改结果都是会保存下来的. 向方法中传递数组 在java中,所有对象都是通过引用进行操作的.而数组也是一种对象,当把数组作为参数传递给方法时,传递的实际上就是数组对象的引用.在方法中对数组的所有

  • 浅谈Java中的可变参数

    可变参数 可变参数就是一个方法可以接收任意多个参数!例如:fun().fun(1).fun(1,1).fun(1,1,1).你可能认为这是方法重载,但这不是重载,你想想重载能重载多少个方法,而fun()方法是可以传递任何个数的参数,你能重载这么多个方法么? 2.1 定义可变参数方法 public voidfun(int- arr) {} 上面方法fun()的参数类型为int-,其中"-"不是省略号,而是定义参数类型的方式.参数arr就是可变参数类型.你可以把上面代码理解为:public

  • Scala可变参数列表，命名参数和参数缺省详解

    重复参数 Scala在定义函数时允许指定最后一个参数可以重复(变长参数),从而允许函数调用者使用变长参数列表来调用该函数,Scala中使用"*"来指明该参数为重复参数.例如: scala> def echo (args: String *) = | for (arg <- args) println(arg) echo: (args: String*)Unit scala> echo() scala> echo ("One") One sca

  • java7 简化变参方法调用实例方法

    这是所有修改里最简单的一个,只是去掉了方法签名中同时出现变参和泛型时才会出现的类型警告信息. 换句话说,除非你写代码时习惯使用类型为T的不定数量参数,并且要用它们创建集合,否则你就可以进入下一节了.如果你想要写下面这种代码,那就继续阅读本节: public static <T> Collection<T> doSomething(T... entries) { ... } 还在?很好.这到底是怎么回事? 变参方法是指参数列表末尾是数量不定但类型相同的参数方法.但你可能还不知道变参方

  • Java Varargs 可变参数用法详解

    Java1.5 提供了一个叫varargs的新功能,就是可变长度的参数. "Varargs"是 "variable number of arguments"的意思.有时候也被简单的称为 "variable arguments". 定义实参个数可变的方法:只要在一个形参的"类型"与"参数名"之间加上三个连续的"."(即"...",英文里的句中省略号),就可以让它和不确定

  • Java 和 Scala 如何调用变参

    Java 和 Scala 都支持变参方法, 写在最后的位置上,最基本的调用方式也都是一样的,一个个罗列过去.也可以传入数组参数,因为变参本质上就是一个数组,就是把 ... 开始位置到最后一个参数都收纳到数组中去,所以变参之所以要放在最后的位置上,且一个方法中最多只能有一个变参类型. 这里主要是对比 Scala 对变参方法的调用,基本调用法当然是没问题的,但是在传入数组作为变参的参数列表与 Java 相对时就稍有变化了. 另外提一下,如果想传入 List 作为变参列表,而不是整体作为变参的第一个元

  • 基于Scala和Java方法的相互调用

    目录 在Java中调用Scala的方法呢? 1.首先是静态方法 2. JAVA中调用Scala的方法 3.Scala中的非静态方法 4.Java中的调用 scala中调用java方法报错 在Scala中调用java的方法,很简单,直接导入传递参数就可以进行调用了. 在Java中调用Scala的方法呢? 经过测试,也是很简单,静态方法直接传递参数,就可以调用了,非静态的方法,使用对象也可以调用方法 具体如下: 1.首先是静态方法 object ScalaObjectDemo extends App

  • Java和Scala集合间的相互转换方式

    目录 Java和Scala集合间的相互转换 scala与java互转 Java与Scala的集合对比 一.Java集合 1.Collection=>Set接口 2.Collection=>List接口 3.Map接口 二.Scala集合 1.Seq 2.Set 3.Map Java和Scala集合间的相互转换 在scala中,调用一个java的方法,通常需要传递相应的参数.下面是scala与java互转换对应表 Iterator <=> java.util.Iterator Ite

  • java与scala数组及集合的基本操作对比

    目录 java与scala数组及集合的操作 scala数组基本操作 对应java代码 scala可变数组ArrayBuffer java 相应 ArrayList操作 scala 的数组遍历 java数组的遍历 scala数组与java数组对比 源码上 java与scala数组及集合的操作 这篇博客介绍了scala的数组 + 可变数组的基本使用,及其与java数组的区别 scala数组基本操作 def main(args: Array[String]): Unit = { //new一个大小不变

  • Java与Scala创建List与Map的实现方式

    目录 Java与Scala创建List与Map Java自定义map与scala map对比 1. 背景 2. java代码 Java与Scala创建List与Map //Java List<String> languages = new ArrayList<>(); Map<String, Class> mapFields = new HashMap(); //Scala val languages = new util.ArrayList[String] val m

  • 浅析Java和Scala中的Future

    浅析Java和Scala中的Future

    随着CPU的核数的增加,异步编程模型在并发领域中的得到了越来越多的应用,由于Scala是一门函数式语言,天然的支持异步编程模型,今天主要来看一下Java和Scala中的Futrue,带你走入异步编程的大门. Future 很多同学可能会有疑问,Futrue跟异步编程有什么关系?从Future的表面意思是未来,一个Future对象可以看出一个将来得到的结果,这就和异步执行的概念很像,你只管自己去执行,只要将最终的结果传达给我就行,线程不必一直暂停等待结果,可以在具体异步任务执行的时候去执行其他操作

  • Java多线程实现异步调用的方法

    在JAVA平台,实现异步调用的角色有如下三个角色:调用者 提货单   真实数据 一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭提货单来获取真正的数据. 去蛋糕店买蛋糕,不需要等蛋糕做出来(假设现做要很长时间),只需要领个提货单就可以了(去干别的事情),等到蛋糕做好了,再拿提货单取蛋糕就可以了. public class Main { public static void main(String[] args) { System.out.println("ma

  • java编程中实现调用js方法分析

    本文实例讲述了java编程中实现调用js方法.分享给大家供大家参考,具体如下: /* * 加载脚本引擎,并在java中调用js方法 */ public void test2() { ScriptEngineManager manager = new ScriptEngineManager(); ScriptEngine engine = manager.getEngineByName("javascript"); try { String str="2&1"

  • java中利用反射调用另一类的private方法的简单实例

    我们知道,Java应用程序不能访问持久化类的private方法,但Hibernate没有这个限制,它能够访问各种级别的方法,如private, default, protected, public. Hibernate是如何实现该功能的呢?答案是利用JAVA的反射机制,如下: import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class ReflectDemo {

  • 通过java反射机制动态调用某方法的总结(推荐)

    如下: public Object invokeMethod(String className, String methodName, Object[] args) throws Exception{ Class ownerClass = Class.forName(className); Object owner = ownerClass.newInstance(); Class[] argsClass = new Class[args.length]; for (int i = 0, j =

随机推荐