Qu'est-ce que “String args[]”? le paramètre principal de la méthode Java

Je suis juste de commencer à écrire des programmes en Java. Quel est le code Java suivant signifie?

public static void main(String[] args)

Qu'est-ce que String[] args?
Quand vous utilisez ces args?

Code Source et/ou les exemples qui sont privilégiées par rapport résumé des explications

InformationsquelleAutor freddiefujiwara | 2009-05-21

273

En Java args contient fournis arguments de ligne de commande comme un tableau de String objets.

En d'autres termes, si vous exécutez votre programme java MyProgram one two puis args contiendra ["one", "two"].

Si vous vouliez sortir le contenu de args, vous pouvez simplement parcourir en boucle comme ça...
```
public class ArgumentExample {
    public static void main(String[] args) {
        for(int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}
```
- A noter que args n'a pas nécessairement à être nommé args (vous pouvez l'appeler ce que vous voulez) - même si il est préférable de suivre la convention. Vous pouvez aussi voir String... args de temps en temps, ce qui est équivalent.
- args l'indexation commence à 0. (contrairement à C de vous donner le nom du programme)
- Est args garanti d'être séparés par un espace, indépendamment de l'OS?
- désolé je suis en retard et je n'ai pas de source, mais je crois fortement qu'ils sont. Il me semble que si java(.exe) est le traitement des arguments, pas le sous-jacent shell/terminal. Prendre -version par exemple, il est java -version et java.exe -version, mais pas java.exe /version (tente de charger la classe principale de .version). Juste mes 2 cents si jamais quelqu'un tombe sur ce.
- Eh bien, si vous étiez à exécuter le programme en tant java "one two" puis args[0] serait "one two" et pas args[0] == "\"one"/args[1] == "two\"".
- Qui ne peut pas être vrai, du moins pas sur les systèmes Unix. Il y a le shell passe des arguments au programme déjà divisée selon le shell de règles (les citations/s'échapper supprimé en conséquence). Il n'y a aucun moyen pour le programme (l'interprète de java dans ce cas) pour accéder à l'original non la ligne de commande, ni le souhait de le faire parce que ce serait confondre l'enfer hors de l'utilisateur.
- Peu en retard à la fête, mais je suis tout à fait certain que le système d'exploitation choisit de séparer les arguments par des espaces (et/ou des citations), et Java lui-même gère le - et la / en face de version de @la réponse de Luc. Si ce n'est le système d'exploitation, puis, éventuellement, l'invite de commande (sous Windows) ou tout ce qui est utilisé pour exécuter le programme, lit l'entrée de la donner et passe les arguments en conséquence.
InformationsquelleAutor Daniel Lew
98

Ceux qui sont pour les arguments de ligne de commande en Java.

En d'autres termes, si vous exécutez

java MyProgram un deux

Puis args contient:

[ "un", "deux" ]
```
public static void main(String [] args) {
    String one = args[0]; //=="one"
    String two = args[1]; //=="two"
}
```
La raison pour cela est de configurer votre application de fonctionner d'une manière particulière, ou de fournir quelques éléments d'information dont il a besoin.

Si vous êtes nouveau à Java, je recommande fortement la lecture par le biais de l'officiel d'Oracle Java^TM Tutoriels.

InformationsquelleAutor mR_fr0g
37

args contient les arguments de ligne de commande passés au programme Java lors de l'invocation. Par exemple, si j'invoque le programme comme suit:
```
$ java MyProg -f file.txt
```
Puis args sera un tableau contenant les chaînes de "-f" et "file.txt".

InformationsquelleAutor mipadi
14

La réponse suivante est basée sur ma compréhension & certains de test.

Qu'est-ce que String[] args?

Ans- >

String[] -> Comme Nous savons que c'est un simple tableau de chaînes.

args -> est le nom d'un tableau, il peut être n'importe quoi (par exemple, a, ar, argument, paramètre, paramètre) aucun problème avec le compilateur & exécuté & je l'ai testé en tant que bien.

E. g.

1)public static void main(String[] argument)

2)public static void main(String[] parametre)

Quand vous utilisez ces arguments?

Ans->

La fonction principale est conçu très intelligemment par les développeurs. Réel de la pensée est très profond.
Qui est essentiellement développé en tenant compte des C & C++ basé sur l'argument de ligne de Commande, mais aujourd'hui personne ne l'utilise plus.

Chose 1- Utilisateur peut entrer n'importe quel type de données à partir de la ligne de commande peut être le Numéro ou String & faut de l'accepter par le compilateur, ce qui type de données que nous devrions avoir à utiliser? voir la chose 2

Chose 2- Chaîne est le type de données qui prend en charge tous les types de données primitifs, comme int, long, float, double, byte, tir, char en Java. Vous pouvez analyser facilement dans n'importe quel type de données primitif.

E. g Le programme suivant est compilé & exécuté & je l'ai testé en tant que bien.

Si l'entrée est -> 1 1
```
//one class needs to have a main() method
public class HelloWorld
{
  //arguments are passed using the text field below this editor
  public static void main(String[] parameter)
  {    
System.out.println(parameter[0] + parameter[1]); //Output is 11

//Comment out below code in case of String
    System.out.println(Integer.parseInt(parameter[0]) + Integer.parseInt(parameter[1])); //Output is 2
    System.out.println(Float.parseFloat(parameter[0]) + Float.parseFloat(parameter[1])); //Output is 2.0    
    System.out.println(Long.parseLong(parameter[0]) + Long.parseLong(parameter[1])); //Output is 2    
    System.out.println(Double.parseDouble(parameter[0]) + Double.parseDouble(parameter[1])); //Output is 2.0    

  }
}
```
InformationsquelleAutor Ajinkya
12

String [] args est aussi la façon de déclarer un tableau de Chaînes de caractères en Java.

Dans cette méthode, la signature, le tableau args sera rempli avec des valeurs lorsque la méthode est appelée (comme les autres exemples ici montrent). Puisque vous êtes en train d'apprendre, il faut comprendre que ce args tableau est tout comme si vous l'avez créée vous-même dans une méthode, comme ceci:
```
public void foo() {
    String [] args = new String[2];
    args[0] = "hello";
    args[1] = "every";

    System.out.println("Output: " + args[0] + args[1]);

    //etc... the usage of 'args' here and in the main method is identical
}
```
InformationsquelleAutor Cuga
11

Je voudrais briser
```
public static void main(String args[])
```
dans les pièces.

"public" signifie que main() peut être appelée à partir de n'importe où.

"statique" signifie que main() n'appartient pas à un objet spécifique

"void" signifie que main() ne retourne pas de valeur

"principal" est le nom d'une fonction. main() est spécial car c'est le début du programme.

"String[]" moyen d'un tableau de Chaîne de caractères.

"args" est le nom de la Chaîne[] (dans le corps de la fonction main()). "args" n'est pas spécial; vous pouvez le nommer rien d'autre, et le programme fonctionne de la même.
- String[] args est une collection de Chaînes de caractères séparées par un espace, qui peut être saisie dans le programme sur le terminal. Plus souvent que pas, le débutant ne va pas utiliser cette variable, mais il est toujours là au cas où.
InformationsquelleAutor Jaimin Patel
9

Même tho OP est seulement de parler, à propos de la String[] args, je veux donner un exemple complet de l' public static void main(String[] args).

Public : est un Modificateur D'Accès, qui définit qui peut accéder à cette Méthode. Public signifie que cette Méthode sera accessible par n'importe quelle Classe(Si d'autres Classes sont en mesure d'accéder à cette Classe.).

Static : est un mot-clé qui identifie la classe de chose. Cela signifie que la Méthode donnée ou variable n'est pas exemple, mais de la Classe. Il peut être consulté sans la création de l'instance d'une Classe.

Void : est utilisé pour définir le Type de Retour de la Méthode. Il définit ce que la méthode peut retourner. Nulle signifie que la Méthode ne retourne aucune valeur.

main: est le nom de la Méthode. Cette Méthode nom est recherché par la JVM comme un point de départ pour une application avec une seule signature.

String[] args : est le paramètre à la Méthode main.

Si vous regardez dans les JDK code source (jdk-src\j2se\src\share\bin\java.c):
```
/* Get the application's main method */
mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
                   "([Ljava/lang/String;)V");
...
{    /* Make sure the main method is public */
...
mods = (*env)->CallIntMethod(env, obj, mid);
if ((mods & 1) == 0) { /* if (!Modifier.isPublic(mods)) ... */
    message = "Main method not public.";
    messageDest = JNI_TRUE;
    goto leave;
...
```
Vous pouvez voir que le méthode de démarrage en java doit être nommé main et doit avoir la signature spécifique public static void main(String[] args)

Le code nous dit aussi que le public static void main(String[] args) n'est pas fixe, si vous modifiez le code dans (jdk-src\j2se\src\share\bin\java.c) à une autre signature, cela fonctionne, mais en changeant cela vous donnera d'autres problèmes possibles en raison de la java spécifications

Offtopic: Ça fait 7 ans depuis l'OP posé cette question, je pense que l'OP peut répondre à sa propre question maintenant.

InformationsquelleAutor Igoranze
8

Lorsque vous avez terminé votre code, vous pourrez le transformer en un fichier avec l'extension .java, qui peut être exécuté par un double-clic, mais aussi tout au long d'une console (terminal sur mac, cmd.exe sur windows) qui permet à l'utilisateur de faire beaucoup de choses. Une chose est qu'ils peuvent voir des messages sur la console (le Système.out.imprimer ou d'un Système.out.println) qu'ils ne peuvent pas voir si ils double-cliquez sur. Une autre chose qu'ils peuvent faire est de spécifier les paramètres, donc, normalement, vous devez utiliser la ligne de
```
java -jar MyCode.jar
```
après naviguer dans le dossier du programme avec
```
cd C:My/Code/Location
```
sur windows ou
```
cd My/Code/Location
```
sur Mac (notez que mac est moins maladroit) pour exécuter du code, mais de spécifier les paramètres que vous utiliseriez
```
java -jar MyCode.jar parameter1 parameter2
```
Ces paramètres sont enregistrés dans le tableau args, que vous pouvez utiliser dans votre programme que vous souhaitez afin de permettre à l'utilisateur de contrôler les paramètres spéciaux tels que ce fichier pour l'utiliser ou de la quantité de mémoire que le programme peut avoir. Si vous voulez savoir comment utiliser un tableau, vous pouvez probablement trouver un sujet sur ce site ou tout simplement une recherche sur google. Notez que le nombre de paramètres peut être utilisé.

InformationsquelleAutor Zac
7

Je pense que c'est assez bien couvert par les réponses ci-dessus que String args[] est tout simplement un tableau des arguments de chaîne vous pouvez passer votre demande lorsque vous l'exécutez. Pour la fin, je pourrais ajouter que c'est aussi valable pour définir la méthode de paramètre passé à la main méthode comme une variable d'argument (varargs) de type Chaîne de caractères:

public static void main (String... args)

En d'autres termes, la main méthode doit accepter soit un tableau de chaînes (String args[]) ou varargs (String... args) comme un argument de méthode. Et il n'y a pas de magie avec le nom args soit. Vous pouvez aussi bien écrire arguments ou même freddiefujiwara comme illustré ci-dessous.e.gs.:

public static void main (String[] arguments)

public static void main (String[] freddiefujiwara)

InformationsquelleAutor sedeh
6

Quand une classe java est exécuté à partir de la console, la méthode principale est ce qui est appelé. Pour ce faire, la définition de cette méthode doit être
```
public static void main(String [])
```
Le fait que ce tableau de chaînes est appelé args est une convention, mais n'est pas strictement nécessaire. Vous renseigner ce tableau à la ligne de commande whne vous appelez votre programme
```
java MyClass a b c
```
Ceux-ci sont couramment utilisés pour définir les options de votre programme, par exemple les fichiers à l'écriture ou à la lecture.

InformationsquelleAutor shsteimer
6

dans
public static void main(String args[])
args est un tableau de la console de l'argument de ligne dont le type de données String.
dans ce tableau, vous pouvez stocker différents arguments de la chaîne, en invoquant à la ligne de commande comme indiqué ci-dessous:
java myProgram Shaan Royal
puis Shaan et Royal seront stockées dans le tableau comme
arg[0]="Shaan";
arg[1]="Royale";
vous pouvez le faire manuellement aussi à l'intérieur du programme, lorsque vous ne les appelez pas à la ligne de commande.

InformationsquelleAutor Shaan Royal
6

Explication simple dans un langage simple.

La principale méthode attend de nous fournir quelques arguments lorsque nous dirigeons notre JVM pour le nom de la classe. Cela signifie que, supposons que votre nom de fichier est Try.java maintenant pour exécuter cette commande vous invite à écrire "javac Try.java" pour compiler suivi par "java Essayer" à exécuter. Supposons maintenant qu'au lieu d'écrire simplement "java Essayer", vous écrivez "java Essayez 1". Ici vous avez passé un argument "1". Ce seront prises par votre méthode main, même si vous ne l'utilisez pas dans votre code.

Si vous voulez vérifier si votre méthode principale est effectivement l'argument "1" ou pas. Simplement, à l'intérieur de votre méthode principale tapez la commande suivante:
```
for(int i = 0; i < args.length; i++) {
        System.out.println("Argument is: "+args[i]);
    }
```
InformationsquelleAutor Jatin Lalwani
3

Le style dataType[] arrayRefVar est préféré. Le style dataType arrayRefVar[] vient du langage C/C++ et a été adopté en Java pour accueillir les programmeurs C/C++.

InformationsquelleAutor Gerald

En plus de tous les commentaires précédents.

public static void main(String[] args)

peut être écrite comme

 public static void main(String...arg)

 public static void main(String...strings)

InformationsquelleAutor Rahul Anand

Vous devez vous connecter pour publier un commentaire.