Java, 매개 변수의 점 3 개

Java, 매개 변수의 점 3 개

---

다음 방법에서 3 개의 점은 무엇을 의미합니까?

public void myMethod(String... strings){
    // method body
}

---

이는 0 개 이상의 String 객체 (또는 이들의 배열)가 해당 메서드의 인수로 전달 될 수 있음을 의미합니다.

http://java.sun.com/docs/books/tutorial/java/javaOO/arguments.html#varargs 에서 "임의의 인수 수"섹션을 참조하십시오.

귀하의 예에서 다음 중 하나로 부를 수 있습니다.

myMethod(); // Likely useless, but possible
myMethod("one", "two", "three");
myMethod("solo");
myMethod(new String[]{"a", "b", "c"});

중요 참고 : 이 방식으로 전달 된 인수는 항상 배열입니다. 하나만있는 경우에도 마찬가지입니다. 메소드 본문에서 그렇게 처리해야합니다.

중요 참고 2 : 를 가져 오는 인수 ...는 메서드 서명의 마지막 인수 여야합니다. 그래서 myMethod(int i, String... strings)괜찮지 만 myMethod(String... strings, int i)괜찮지 않습니다.

그의 의견에 대한 설명에 대해 Vash에게 감사드립니다.

---

이 기능은 varargs 라고 하며 Java 5에 도입 된 기능입니다. 이는 함수가 여러 String인수를 받을 수 있음을 의미합니다 .

myMethod("foo", "bar");
myMethod("foo", "bar", "baz");
myMethod(new String[]{"foo", "var", "baz"}); // you can even pass an array

그런 다음 Stringvar를 배열로 사용할 수 있습니다 .

public void myMethod(String... strings){
    for(String whatever : strings){
        // do what ever you want
    }

    // the code above is is equivalent to
    for( int i = 0; i < strings.length; i++){
        // classical for. In this case you use strings[i]
    }
}

이 답변은 kiswa와 Lorenzo의 ... 그리고 Graphain의 의견에서 많이 빌 렸습니다.

---

Varargs입니다 :)

가변 길이 인수의 줄임말 인 varargs는 메서드가 가변 개수의 인수 (0 개 이상)를 허용 할 수있는 기능입니다. varargs를 사용하면 가변 개수의 인수를 받아야하는 메서드를 만드는 것이 간단 해졌습니다. 변수 인수 기능이 Java 5에 추가되었습니다.

varargs 구문

vararg는 데이터 유형 뒤에 세 개의 줄임표 (세 개의 점)로 보호되며 일반적인 형식은 다음과 같습니다.

return_type method_name(data_type ... variableName){
}  

varargs 필요

Java 5 이전에는 가변 개수의 인수가 필요한 경우이를 처리하는 두 가지 방법이있었습니다.

메서드가 취할 수있는 인수의 최대 수가 적고 알려진 경우 메서드의 오버로드 된 버전이 생성 될 수 있습니다. 메소드가 취할 수있는 인수의 최대 수가 크거나 알 수없는 경우 접근 방식은 해당 인수를 배열에 넣고 배열을 매개 변수로 취하는 메소드에 전달하는 것입니다. 이 두 가지 접근 방식은 오류가 발생하기 쉬웠습니다. 매번 매개 변수 배열을 구성하고 유지 관리가 어려웠습니다. 새 인수를 추가하면 새 오버로드 된 메서드가 작성 될 수 있기 때문입니다.

varargs의 장점

훨씬 더 간단한 옵션을 제공합니다. 오버로드 된 메서드를 작성할 필요가 없으므로 코드가 적습니다.

varargs의 예

public class VarargsExample {
 public void displayData(String ... values){
  System.out.println("Number of arguments passed " + values.length);
  for(String s : values){
   System.out.println(s + " ");
  }
 }

 public static void main(String[] args) {
  VarargsExample vObj = new VarargsExample();
  // four args
  vObj.displayData("var", "args", "are", "passed");
  //three args
  vObj.displayData("Three", "args", "passed");
  // no-arg
  vObj.displayData();
 }
}
Output

Number of arguments passed 4
var 
args 
are 
passed 
Number of arguments passed 3
Three 
args 
passed 
Number of arguments passed 0

It can be seen from the program that length is used here to find the number of arguments passed to the method. It is possible because varargs are implicitly passed as an array. Whatever arguments are passed as varargs are stored in an array which is referred by the name given to varargs. In this program array name is values. Also note that method is called with different number of argument, first call with four arguments, then three arguments and then with zero arguments. All these calls are handled by the same method which takes varargs.

Restriction with varargs

It is possible to have other parameters with varargs parameter in a method, however in that case, varargs parameter must be the last parameter declared by the method.

void displayValues(int a, int b, int … values) // OK
   void displayValues(int a, int b, int … values, int c) // compiler error

Another restriction with varargs is that there must be only one varargs parameter.

void displayValues(int a, int b, int … values, int … moreValues) // Compiler error

Overloading varargs Methods

It is possible to overload a method that takes varargs parameter. Varargs method can be overloaded by -

Types of its vararg parameter can be different. By adding other parameters. Example of overloading varargs method

public class OverloadingVarargsExp {
 // Method which has string vararg parameter
 public void displayData(String ... values){
  System.out.println("Number of arguments passed " + values.length);
  for(String s : values){
   System.out.println(s + " ");
  }
 }

 // Method which has int vararg parameter
 public void displayData(int ... values){
  System.out.println("Number of arguments passed " + values.length);
  for(int i : values){
   System.out.println(i + " ");
  }
 }

 // Method with int vararg and one more string parameter
 public void displayData(String a, int ... values){
  System.out.println(" a " + a);
  System.out.println("Number of arguments passed " + values.length);
  for(int i : values){
   System.out.println(i + " ");
  }
 }

 public static void main(String[] args) {
  OverloadingVarargsExp vObj = new OverloadingVarargsExp();
  // four string args
  vObj.displayData("var", "args", "are", "passed");

  // two int args
  vObj.displayData(10, 20);

  // One String param and two int args
  vObj.displayData("Test", 20, 30);
 }
}
Output

Number of arguments passed 4
var 
args 
are 
passed 

Number of arguments passed 2
10 
20

 a Test
Number of arguments passed 2
20 
30 

Varargs and overloading ambiguity

In some cases call may be ambiguous while we have overloaded varargs method. Let's see an example

public class OverloadingVarargsExp {
 // Method which has string vararg parameter
 public void displayData(String ... values){
  System.out.println("Number of arguments passed " + values.length);
  for(String s : values){
   System.out.println(s + " ");
  }
 }

 // Method which has int vararg parameter
 public void displayData(int ... values){
  System.out.println("Number of arguments passed " + values.length);
  for(int i : values){
   System.out.println(i + " ");
  }
 }

 public static void main(String[] args) {
  OverloadingVarargsExp vObj = new OverloadingVarargsExp();
  // four string args
  vObj.displayData("var", "args", "are", "passed");

  // two int args
  vObj.displayData(10, 20);

  // This call is ambiguous
  vObj.displayData();
 }
}

In this program when we make a call to displayData() method without any parameter it throws error, because compiler is not sure whether this method call is for displayData(String ... values) or displayData(int ... values)

Same way if we have overloaded methods where one has the vararg method of one type and another method has one parameter and vararg parameter of the same type, then also we have the ambiguity - As Exp - displayData(int ... values) and displayData(int a, int ... values)

These two overloaded methods will always have ambiguity.

---

This is the Java way to pass varargs (variable number arguments).

If you are familiar with C, this is similar to the ... syntax used it the printf function:

int printf(const char * format, ...);

but in a type safe fashion: every argument has to comply with the specified type (in your sample, they should be all String).

This is a simple sample of how you can use varargs:

class VarargSample {

   public static void PrintMultipleStrings(String... strings) {
      for( String s : strings ) {
          System.out.println(s);
      }
   }

   public static void main(String... args) {
      PrintMultipleStrings("Hello", "world");
   }
}

The ... argument is actually an array, so you could pass a String[] as the parameter.

---

Arguably, it is an example of syntactic sugar, since it is implemented as an array anyways (which doesn't mean it's useless) - I prefer passing an array to keep it clear, and also declare methods with arrays of given type. Rather an opinion than an answer, though.

---

Just think of it as the keyword params in C#, if you are coming from that background :)

---

Also to shed some light, it is important to know that var-arg parameters are limited to one and you can't have several var-art params. For example this is illigal:

public void myMethod(String... strings, int ... ints){
// method body
}

---

A really common way to see a clear example of the use of the three dots it is present in one of the most famous methods in android AsyncTask ( that today is not used too much because of RXJAVA, not to mention the Google Architecture components), you can find thousands of examples searching for this term, and the best way to understand and never forget anymore the meaning of the three dots is that they express a ...doubt... just like in the common language. Namely it is not clear the number of parameters that have to be passed, could be 0, could be 1 could be more( an array)...

---

String... is the same as String[]

import java.lang.*;

        public class MyClassTest {

        //public static void main(String... args) { 

        public static void main(String[] args) {
        for(String str: args) {
        System.out.println(str);

        }
        }
        }

참고URL : https://stackoverflow.com/questions/3158730/java-3-dots-in-parameters