Argumentos de la línea de comandos en Java: acceso y asignación a tipos de datos

En este tutorial, manejaremos los argumentos de la línea de comandos en Java. Accederemos a ellos y los leeremos, así como asignaremos los argumentos a los tipos de datos para alterar el flujo del código.

Introducción

Los argumentos de la línea de comandos (parámetros) son cadenas de texto que se utilizan para pasar información adicional a un programa cuando se ejecuta una aplicación a través de la interfaz de línea de comandos ( CLI) de un sistema operativo.

En este tutorial, accederemos a los argumentos (parámetros) pasados ​​al método principal de una aplicación Java y los leeremos. También los asignaremos a diferentes tipos de datos para que podamos manejarlos y alterar el flujo del código en función de la entrada.

Acceso a argumentos de línea de comandos

El punto de entrada para cada programa Java es el método main():

1
2
3
public static void main(String[] args) {
    // Do something
}

Los argumentos pasados ​​al programa cuando se inicializó se almacenan en la matriz args. Alternativamente, Java también admite un vararg en este lugar:

1
2
3
public static void main(String... args) {
    // Do something
}

Dicho esto, podemos acceder fácilmente a cada argumento pasado a este método. Comencemos imprimiéndolos, uno por uno:

1
2
3
4
5
6
public class Main {
public static void main(String[] args) {
    for (int i = 0; i < args.length; i++)
        System.out.println(String.format("Argument %d: %s", i, args[i]));
    }
}

Luego compilaremos este archivo .java:

1
javac Main.java

Después de lo cual, podemos ejecutarlo:

1
java Main Hello World

Esto resulta en:

1
2
Argument 0: Hello
Argument 1: World

Asignación de argumentos a tipos de datos

Los argumentos en sí mismos son una matriz de cadenas. Entonces, realmente, todo lo que pasamos es una Cadena. Sin embargo, también podemos convertir cadenas en diferentes tipos de datos:

1
java Main Hello 15 true 

Esto imprime:

1
2
3
Argument 0: Hello
Argument 1: 15
Argument 2: true

Digamos que queremos permitir que los usuarios impriman una cadena un número determinado de veces y tener una bandera que alterna un mensaje de registro que muestra el número de la iteración. Los argumentos provistos anteriormente imprimirían Hello 15 veces, con un mensaje de registro en cada instrucción print().

Vamos a hacer eso:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Main {
    public static void main(String[] args) {

        String s = "";
        int n = 0;
        boolean flag = false;

        try {
            s = args[0];
        } catch (Exception e) {
            System.out.println("The first argument must be present.");
            System.exit(1);
        }
        try {
            n = Integer.parseInt(args[1]);
        } catch (NumberFormatException e) {
            System.out.println("The second argument must be an integer.");
            System.exit(1);
        }

        try {
            flag = Boolean.parseBoolean(args[2]);
        } catch (Exception e) {
            System.out.println("The third argument must be parseable to boolean.");
            System.exit(1);
        }

        for (int i = 0; i < n; i++) {
            System.out.println(s);
            if (flag)
                System.out.println(String.format("Iteration %d", i));
        }
    }
}

Ahora, vamos a compilar el código de nuevo:

1
javac Main.java

Y luego, vamos a ejecutarlo sin argumentos:

1
java Main

Nos reciben con:

1
The first argument must be present.

Si proporcionamos los argumentos:

1
java Main Hello 5 true

Seremos recibidos con:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
Hello
Iteration 0
Hello
Iteration 1
Hello
Iteration 2
Hello
Iteration 3
Hello
Iteration 4

Configuración de argumentos en IDE

Esto supone que ejecuta el código a través de la línea de comandos, lo que no siempre es el caso. La mayoría de las personas usan IDE para trabajar en sus proyectos, que en su lugar tienen un conveniente botón "Ejecutar".

Afortunadamente, puede decirle al IDE que pase estos argumentos a la llamada de ejecución. Estos son ejemplos de cómo puede hacerlo con algunos IDE populares:

eclipse

En "Ejecutar"->"Ejecutar configuraciones":

Eclipse establece argumentos

####IntelliJ

En "Ejecutar"->"Editar configuraciones":

IntelliJ Setting arguments

Conclusión

En este artículo, echamos un vistazo a cómo podemos acceder a los argumentos de la línea de comandos pasados ​​a una aplicación Java cuando se ejecuta.

Luego, mapeamos los argumentos pasados ​​en diferentes tipos de datos y los manejamos en consecuencia. Con esto en mente, es fácil crear herramientas CLI simples y modificar el flujo de código en función de los argumentos pasados.