Gibt die Anzahl der variablen Argumente einer Methode in Java

Question

potenziell idiotisch Frage Vorsicht unter:

ich eine Methode, die die String.format() -Methode verwendet einen Text zu formatieren. Momentan erhält es zwei Parameter, also habe ich zwei "% s" -Parameter, um den gewünschten Text zu erzeugen.

Aber jemand könnte 3 Parameter oder 4 oder 100 mit meiner Methode verwenden möchten. Wie kann ich die Länge der übergebenen Parameter als varargs an die String.format() -Methode übergeben, so dass, falls 3 Parameter übergeben werden, 3 "% s" anstelle der aktuellen 2 davon vorhanden sind; oder 4 oder 100.

Wie können Sie die Anzahl der Parameter erhalten, die an die String.format() -Methode übergeben werden, sodass der darin enthaltene Text automatisch "% s" nach Bedarf hinzufügt? Weil die Argumente nur als reguläre Argumente übergeben werden, nicht als Arrays oder ähnliches. Wie erhalten Sie die Länge des Argumentarrays?

PS. Das ist wichtig - ich spreche nicht davon, die (String ... Argumente) zu erhalten - es gibt keine solche Sache - wenn jemand Ihre Methode aufruft, verwendet es tatsächliche Parameter, die "String ... arguments" steht nicht zur Verfügung und erhalte seine Länge.

Ich weiß, dies ist eine schlecht formulierte Frage, weil ich den Code nicht vor mir habe, um weiter zu erklären, aber das beschäftigt mich schon seit einiger Zeit - wie erhält man die Anzahl der Argumente, die man an a Methode?

Für diese so etwas wie:

String.format(SomeObject.SomeString, param1, param2,...,param 100) 

EDIT: Die SomeObject.SomeString wird wie folgt erklärt:

String SomeString = "Blah blah %s blah blah blah %s";

So hat es zwei Argumente, die in ihm fest einprogrammiert werden.

Wenn jemand es verwendet, wie passt man SomeObject.SomeString so an, dass es "weiß", wie viele Parameter an die String.format() -Methode übergeben wurden (so dass SomeObject.SomeString weiß, wie viele% s dynamisch hinzugefügt werden)?

Answer 1

Da die Argumente als nur reguläre Argumente, nicht als Arrays übergeben werden.

Nein, werden die Werte als Array übergeben, damit Sie

public String myVarags(String... args) { 
    String s = ""; 
    for(int i = 0;i < args.length; i++) 
     s += "%s "; 
    return String.format(s, args); 
} 

schreiben könnte es eine String mit einem %s für jedes Argument erzeugen und formatieren Sie den String mit den angegebenen Werten. Es wird auch eine sehr dumme und nutzlose Methode sein.

Die Varargs Notation ist nur syntaktischer Zucker, es ist ein Array zur Laufzeit.

Answer 2

Ich glaube nicht, was Sie fragen, ist möglich, weil Ihre SomeObject.SomeString ist nur ein Argument, es weiß nichts über die anderen Argumente.Was Sie tun können, ist Ihre Argumente in ein Array von varargs drehen und ein Verfahren auf SomeObject schaffen die richtige Zeichenfolge zu generieren:

String[] args = ... 
String.format(SomeObject.createSomeString(args.length), args); 

Answer 3

Es klingt wie Sie die Anzahl der Parameter zugreifen möchten, die in eine andere übergeben werden Methode, die einen Vararg als Parameter verwendet (String.format() Methode).

Es ist nicht möglich zu wissen, wie viele Argumente an eine Methode übergeben werden, wenn Sie den Code in der Methode nicht ändern können. Und der String Parameter hätte sicherlich keine Ahnung wie viele Parameter übergeben wurden. Es ist ein völlig separates Objekt.

Das einzige, was Sie tun können, ist eine Wrapper-Methode zu erstellen. Sie können die gleichen varargs nehmen und sie dann an die String.format() Methode weiterleiten, die alle Änderungen vornimmt, die Sie tun möchten.

Dann muss Code, der String.format() aufruft, stattdessen Ihre Wrapper-Methode aufrufen.

Beispiel:

public String StringFormatWrapper(String...args) { 
    //perform actions on the args 
    if (args.length > 1) 
     args[1] = "Hello World"; 

    //call the String.format() method 
    return String.format(args) 
} 

Wenn Sie Zugang zu nicht haben, was String.format() dann ruft, was man unmöglich machen wollen, ist.

Answer 4

Ich habe darüber ein bisschen mehr nachgedacht und ich habe eine Lösung dafür gefunden, und die Lösung ist sehr einfach. In der Tat habe ich es in 5 Minuten geschrieben.

Hier ist, wie es geht:

Hauptklasse:

public class Main { 

    SomeObject someObject = new SomeObject(); 

    public static void main(String[] args) { 

     Main main = new Main(); 
     main.formatString("a","b","c","D","efesfs"); 

    } 

    public void formatString(String...varargs){ 
     String formattedString = String.format(someObject.returnFormattedString(varargs.length), varargs); 
     System.out.println(formattedString); 
    } 
} 

Someobject KLASSE:

public class SomeObject { 

    public String someString = "Blah blah blah"; 

    public String returnFormattedString(int numberOfArguments){ 
     for (int i = 0; i<numberOfArguments; i++){ 
      someString += "%s"; 
     } 

     return someString; 
    } 
} 

Mit anderen Worten, ich Einwickeln, dass alle Sachen in einem Verfahren, das haben Zugriff auf wie viele Parameter als Argumente übergeben werden, und ich werde die Anzahl von ihnen (als varargs.length) an die Methode innerhalb der SomeObject-Klasse übergeben, die die Länge als eine int-Variable nimmt Wenn Sie eine for-Schleife verwenden, werden so viele "% s" wie nötig hinzugefügt.

Es funktioniert wie ein Charme.

Ich weiß, dass einige Leute mich kritisiert haben, dass das nicht "richtig" ist, "es ist nicht die richtige Frage" und so weiter, aber es hat zumindest eine einfache Lösung, so wie ich es hätte haben sollen "Unmöglich", Sie müssen den Bytecode zur Laufzeit oder etwas Verrücktes nicht abbrechen.