Wat betekenen de 3 stippen na Stringin de volgende methode?
public void myMethod(String... strings){
// method body
}
Antwoord 1, autoriteit 100%
Het betekent dat nul of meer String-objecten (of een enkele array) kunnen worden doorgegeven als argument(en) voor die methode.
Zie de sectie “Willekeurig aantal argumenten” hier: http://java.sun.com/docs/books/tutorial/java/javaOO/arguments.html#varargs
In jouw voorbeeld zou je het als een van de volgende kunnen noemen:
myMethod(); // Likely useless, but possible
myMethod("one", "two", "three");
myMethod("solo");
myMethod(new String[]{"a", "b", "c"});
Belangrijke opmerking:De argumenten die op deze manier worden doorgegeven, zijn altijd een array – zelfs als er maar één is. Zorg ervoor dat je het op die manier behandelt in de body van de methode.
Belangrijke opmerking 2:Het argument dat de ...krijgt, moet het laatste zijn in de handtekening van de methode. Dus myMethod(int i, String... strings)is oké, maar myMethod(String... strings, int i)is niet oké.
Met dank aan Vash voor de verduidelijkingen in zijn commentaar.
Antwoord 2, autoriteit 12%
Die functie heet varargs, en het is een functie die in Java 5 is geïntroduceerd. Het betekent dat de functie meerdere String-argumenten kan ontvangen:
myMethod("foo", "bar");
myMethod("foo", "bar", "baz");
myMethod(new String[]{"foo", "var", "baz"}); // you can even pass an array
Dan kunt u de StringVar als array gebruiken:
public void myMethod(String... strings){
for(String whatever : strings){
// do what ever you want
}
// the code above is equivalent to
for( int i = 0; i < strings.length; i++){
// classical for. In this case you use strings[i]
}
}
Dit antwoord leent zwaar van Kiswa’s en Lorenzo’s … en ook vanuit Grafain’s Comments.
3, Autoriteit 2%
IT’s Varargs 🙂
De varargs kort voor argumenten voor variabele lengte is een functie waarmee de methode een variabele aantal argumenten (nul of meer) kan accepteren. Met varargs is het eenvoudig geworden om methoden te creëren die een variabel aantal argumenten nodig hebben. Het kenmerk van variabele argument is toegevoegd in Java 5.
syntaxis van varargs
Een vararg wordt geëffecticeerd door drie ellips (drie stippen) na het gegevenstype, het algemene formulier is
return_type method_name(data_type ... variableName){
}
nodig voor varargs
Voorafgaand aan Java 5, in het geval dat er behoefte aan variabel aantal argumenten, waren er twee manieren om het aan te pakken
Als het maximale aantal argumenten, kan een methode kan worden genomen, klein en bekend, dan kunnen overbelaste versies van de methode worden gecreëerd.
Als het maximale aantal argumenten een methode kan nemen was groot of / en onbekend, dan was de aanpak om die argumenten in een array te plaatsen en deze door te geven aan een methode die array als parameter neemt.
Deze 2 benaderingen waren foutgevoelig – elke keer een reeks parameters construeren en moeilijk te onderhouden – omdat de toevoeging van een nieuw argument kan resulteren in het schrijven van een nieuwe overbelaste methode.
Voordelen van varargs
Biedt een veel eenvoudigere optie.
Minder code omdat het niet nodig is om overbelaste methoden te schrijven.
Voorbeeld van 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
In het programma is te zien dat lengte hier wordt gebruikt om het aantal argumenten te vinden dat aan de methode is doorgegeven. Het is mogelijk omdat varargs impliciet worden doorgegeven als een array. Welke argumenten ook worden doorgegeven als varargs, ze worden opgeslagen in een array waarnaar wordt verwezen met de naam die aan varargs wordt gegeven. In dit programma is de arraynaam waarden.
Merk ook op dat de methode wordt aangeroepen met een ander aantal argumenten, eerst aanroepen met vier argumenten, dan drie argumenten en dan met argumenten nul. Al deze aanroepen worden afgehandeld door dezelfde methode die varargs vereist.
Beperking met varargs
Het is mogelijk om andere parameters met de varargs-parameter in een methode te hebben, maar in dat geval moet de varargs-parameter de laatste parameter zijn die door de methode is gedeclareerd.
void displayValues(int a, int b, int … values) // OK
void displayValues(int a, int b, int … values, int c) // compiler error
Een andere beperking met varargs is dat er maar één varargs-parameter mag zijn.
void displayValues(int a, int b, int … values, int … moreValues) // Compiler error
Varargs-methoden overbelasten
Het is mogelijk om een methode te overbelasten die de varargs parameter nodig heeft.
Varargs-methode kan worden overbelast door –
Typen van de vararg-parameter kunnen verschillen.
Door andere parameters toe te voegen.
Voorbeeld van overbelastingsmethode varargs
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 en dubbelzinnigheid bij overbelasting
In sommige gevallen kan de oproep dubbelzinnig zijn terwijl we de varargs-methode hebben overbelast.
Laten we een voorbeeld bekijken
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();
}
}
Als we in dit programma de methode displayData() aanroepen zonder enige parameter, wordt er een fout gegenereerd, omdat de compiler niet zeker weet of deze methode-aanroep voor displayData(String ... values)of displayData(int ... values)
Dezelfde manier als we overbelaste methoden hebben waarbij de ene de methode varargvan het ene type heeft en de andere methode één parameter en de parameter varargvan hetzelfde type, dan hebben we ook heb de dubbelzinnigheid –
Als Exp –
displayData(int ... values)en displayData(int a, int ... values)
Deze twee overbelaste methoden zullen altijd dubbelzinnig zijn.
4
Betabulabel, het is een voorbeeld van syntactische suiker, omdat het sowieso als array wordt geïmplementeerd (wat betekent niet dat het nutteloos is) – Ik geef de voorkeur aan een array om het duidelijk te houden, en verklaart ook methoden met arrays van gegeven type . Eerder een mening dan een antwoord.
5
Ook om wat licht te werpen, is het belangrijk om te weten dat Var-Arg-parameters beperkt zijn tot één en u kunt geen verschillende var-art params hebben. Dit is bijvoorbeeld Illigal:
public void myMethod(String... strings, int ... ints){
// method body
}
6
Zie het gewoon als het trefwoord paramsin C #, als u van die achtergrond komt 🙂
7
Een heel gebruikelijke manier om een duidelijk voorbeeld te zien van het gebruik van de drie stippen die het aanwezig is in een van de meest bekende methoden in Android Assynctask (dat vandaag niet te veel wordt gebruikt vanwege Rxjava, om nog maar te zwijgen van de Google Architection-componenten), kunt u duizenden voorbeelden vinden die op zoek zijn naar deze term, En de beste manier om te begrijpen en nooit meer de betekenis van de drie punten is dat ze een … twijfel hebben … net als in de gemeenschappelijke taal. Namelijk is het niet duidelijk het aantal parameters dat moet worden gepasseerd, zou 0 kunnen zijn, zou kunnen zijn 1 kan meer (een array) …
8
Toevoegen aan de andere goed geschreven antwoorden, een voordeel van varagrsIk vond nuttig, is dat wanneer ik een methode met array als parametertype noemt, het de pijn van het maken van een array neemt ; Voeg elementen toe en stuur het dan. In plaats daarvan kan ik de methode gewoon bellen met zoveel waarden als ik wil; van nul tot velen.
9
syntaxis:
(Triple Dot …) – & GT; Betekent dat we nul of meer objecten kunnen toevoegen in een argumenten of een reeks typeobject doorgeven.
public static void main(String[] args){}
public static void main(String... args){}
definitie:
1) Het object … argument is slechts een verwijzing naar een reeks objecten.
2) (‘String []’ of string …) Het kan om het even welk aantal stringobjecten aan te pakken. Intern gebruikt het een reeks referentietype-object.
i.e. Suppose we pass an Object array to the ... argument - will the resultant argument value be a two-dimensional array - because an Object[] is itself an Object:
3) Als je de methode met een enkel argument wilt aanroepen en het blijkt een array te zijn, moet je deze expliciet inpakken
another. method(new Object[]{array});
OR
method((Object)array), which will auto-wrap.
Toepassing:
Het wordt voornamelijk gebruikt wanneer het aantal argumenten dynamisch is (het aantal argumenten dat tijdens runtime bekend is) en bij het overschrijven.
Algemene regel– In de methode kunnen we elk type en elk aantal argumenten doorgeven. We kunnen geen object(…)-argumenten toevoegen voor specifieke argumenten.
d.w.z.
void m1(String ..., String s) this is a wrong approach give syntax error.
void m1(String s, String ...); This is a right approach. Must always give last order prefernces.
Antwoord 10
Allereerst is het een optionele parameter, coder is niet verplicht om de parameter door te geven in tegenstelling tot andere parameters
andere kenmerken:
- Het betekent nul of meerdere parameters van hetzelfde gegevenstype.
- Het moet de laatste parameter van de constructor of functie zijn.
- We kunnen slechts één parameter van dit type hebben in de respectievelijke constructor
of functie.
Voorbeeld 1:
public class quest1 {
public quest1(String... mynum) {
System.out.println("yee haa");
}
public static void main(String[] args) {
quest1 q=new quest1();
quest1 q1=new quest1("hello");
}
}
Voorbeeld 2:
public class quest1 {
public quest1(int... at) {
System.out.println("yee haa");
}
public quest1(String... at) {
System.out.println("yee haa");
}
public static void main(String[] args) {
quest1 q=new quest1("value");
quest1 q1=new quest1(1);
}
public void name(String ... s) {
}
}
uitvoer:
jaaaaa
jaaaaa