可变参数列表-Java SE5新特性(转)-阿里云开发者社区

开发者社区> 开发与运维> 正文
登录阅读全文

可变参数列表-Java SE5新特性(转)

简介: Java1.5增加了新特性:可变参数:适用于参数个数不确定,类型确定的情况,java把可变参数当做数组处理。注意:可变参数必须位于最后一项。当可变参数个数多于一个时,必将有一个不是最后一项,所以只支持有一个可变参数。

Java1.5增加了新特性:
可变参数:
适用于参数个数不确定,类型确定的情况,java把可变参数当做数组处理。
注意:可变参数必须位于最后一项
当可变参数个数多于一个时,必将有一个不是最后一项,所以只支持有一个可变参数
因为参数个数不定,所以当其后边还有相同类型参数时,java无法区分传入的参数属于前一个可变参数还是后边的参数,所以只能让可变参数位于最后一项。

可变参数的特点:
(1)只能出现在参数列表的最后;
(2)...位于变量类型和变量名之间,前后有无空格都可以;
(3)调用可变参数的方法时,编译器为该可变参数隐含创建一个数组,在方法体中以数组的形式访问可变参数。


1.可变参数列表的简单实现
当调用方法时,方法的参数个数或类型未知时,称其为可变参数列表。在以前的Java代码中,可以使用Object数组来实现这样的功能。因为,所有的类都是直接或间接继承于Object类。
 
VarArgs.java
package sample;
 
class A1{}
 
public class VarArgs {
       static void printArray(Object[] args){
              for(Object obj:args)
                     System.out.print(obj+" ");
              System.out.println();
       }
 
       public static void main(String[] args){
              printArray(new Object[]{
                     new Integer(47),new Float(3.14),new Double(11.11)
              });
              printArray(new Object[]{"one","two","three"});
              printArray(new Object[]{new A1(),new A1(),new A1()});
       }
}
 
结果:
47 3.14 11.11
one two three
sample.A1@a90653 sample.A1@de6ced sample.A1@c17164
 
这里printArray方法使用Object数组作为参数,并使用foreach语法遍历数组,打印每个对象。
 
2.Java SE5实现可变参数列表
同样的方法,参数可以这样定义,(Object…args),这样达到同样的效果。
 
NewVarArgs.java
package sample;
 
class A{}
 
public class NewVarArgs {
       static void printArray(Object...args){
              for(Object obj:args)
                     System.out.print(obj+" ");
              System.out.println();
       }
 
       public static void main(String[] args){
              printArray(new Integer(47),new Float(3.14),new Double(11.11));
              printArray(47,3.14,11.11);
              printArray("one","two","three");
              printArray(new A(),new A(),new A());
              printArray((Object[])new Integer[]{1,2,3,4});
              printArray();
       }
}
 
结果:
47 3.14 11.11
47 3.14 11.11
one two three
sample.A@a90653 sample.A@de6ced sample.A@c17164
1 2 3 4
 
这里没有显式的使用数组作为参数,但编译器实际上会为你填充数组。所以同样可以使用foreach语法来遍历之。
注意倒数第二行,编译器已经发现它是一个数组,所以不会在其上执行任何转换。最后一行表明,可以传递零个参数
也可以指定所有可变参数的类型,下面的程序指定所有可变参数都必须是String。
 
OptionalArguments.java
package sample;
 
public class OptionalArguments {
       static void f(String...trailing){
              for(String s:trailing)
                     System.out.print(s+" ");
              System.out.println();
       }
 
       public static void main(String[] args){
              f("one");
              f("two","three");
              f();
       }
}
 
结果:
one
two three
 
可以在可变参数列表中同时使用原始类型与包装类
 
AutoboxingVarargs.java
package sample;
 
public class AutoboxingVarargs {
       public static void f(Integer...args){
              for(Integer i:args)
                     System.out.print(i+" ");
              System.out.println();
       }
 
       public static void main(String[] args){
              f(new Integer(1),new Integer(2));
              f(3,4,5,6,7,8,9);
              f(10,new Integer(11),12);
       }
}
 
结果:
1 2
3 4 5 6 7 8 9
10 11 12
 
3.可变参数列表的重载(Overloading)
(1)只支持不同类型参数的可变参数进行重载;
(2)不支持参数出现非可变参数和可变参数混合的情况;
如果出现重载的情况,则编译器会自动调用最适合的方法匹配之。
 
OverloadingVarargs.java
package sample;
 
public class OverloadingVarargs {
       static void f(Character...args){
              System.out.print("first ");
              for(Character c:args)
                     System.out.print(c+" ");
              System.out.println();
       }
 
       static void f(Integer...args){
              System.out.print("second ");
              for(Integer i:args)
                     System.out.print(i+" ");
              System.out.println();
       }
     
       static void f(Long...args){
              System.out.print("third ");
              for(Long l:args)
                     System.out.print(l+" ");
              System.out.println();
       }
     
       static void f(Double...args){
              System.out.print("forth ");
              for(Double d:args)
                     System.out.print(d+" ");
              System.out.println();
       }
     
       public static void main(String[] args){
              f('a','b','c');
              f(1);
              f(2,1);
              f(0.1);
              f(0l);

       }
}
 
结果:
first a b c
second 1
second 2 1
forth 0.1
third 0
 
但下面的情况是不允许的,即某个方法中增加一个非可变参数。
 
OverloadingVarargs2.java
package sample;
 
public class OverloadingVarargs2 {
       static void f(float i,Character...args){
              System.out.println("first");
       }
 
       static void f(Character...args){
              System.out.println("second");
       }
     
       public static void main(String[] args){
              f(1,'a');
              f('a','b');//The method f(float, Character[]) is ambiguous for the type OverloadingVarargs2
       }
}
 
但可以这样解决问题。
package sample;
 
public class OverloadingVarargs2 {
       static void f(float i,Character...args){
              System.out.println("first");
       }
 
       static void f(char c,Character...args){
              System.out.println("second");
       }
     
       public static void main(String[] args){
              f(1,'a');
              f('a','b');
       }
}
使用可变参数时重载的方法必须保持一致的参数形式

http://www.blogjava.net/Carter0618/archive/2007/08/19/137889.html

import java.util.Arrays;
import java.util.List;

/*2015-9-15*/
public class VariableParameter {
    public static void main(String[] args) {
        VariableParameter vp = new VariableParameter();
        vp.process("p1", "p2", "p3");
    }

    public void process(String... parameters) {
        List<String> list = Arrays.asList(parameters);
        for (String parameter : list) {
            System.out.println(parameter);
        }
    }

}

输出:

p1
p2
p3

 

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享: