Archivo de la etiqueta: java

Compilar código Java desde la línea de comandos

Pues eso… probando con el código que he hecho con Java (desde el IntelliJ IDEA) he querido compilar el código a .exe, pero no sé cómo hacerlo… solo me he quedado en crear un fichero .jar y ese poder ejecutarlo con el «java» desde la línea de comandos.

Versión de Java instalado

Al intentar hacerlo me he topado con un par de problemas, al menos desde mi máquina con el Visual Studio 2019 instalado (aparte del Visual Studio 2022), aclaro esto porque se ve que el Visual Studio 2019 tiene instalada una versión del JDK más antigua, concretamente la versión 1.8.0_302 y el código que he usado en las pruebas con records y expresiones swicht necesita al menos el JDK 17 (JDK = Java Development Kit).

Para poder usar el código que he publicado en varios de los repositorios (y los gists) de GitHub, instalé el JDK 19 (el último a la hora de escribir esto y también cuando empecé a hacer las pruebas en noviembre), pero la versión del JDK que está primero en la variable PATH es la carpeta bin de la versión 1.8, por tanto, al usar cualquiera de los comandos de Java (java para ejecutar los .jar o javac para compilar el código) me daba error.

Cuando se instala el JDK (al menos desde Visual Studio) se crea una variable de entorno que se llama JAVA_HOME con el path del directorio donde está instalado el JDK de Java.
En mi equipo el path indicado es: C:\Program Files\Microsoft\jdk-11.0.12.7-hotspot. Que como te puedes imaginar es la versión 11 del JDK. Esa versión tampoco soporta las expresiones swicht ni los records (aunque sí los tipos genéricos).

Así que… la solución es instalar un JDK que soporte esas dos «cosillas» que necesito en mi código.

Instalar un nuevo JDK de Java

Como la última versión que hay actualmente es la 19, esa es la que descargué (desde el propio IDE de IntelliJ IDEA), pero que puedes descargar desde la página de OpenJDK.

A fecha de hoy (27 de noviembre) el último JDK de Java es el 19, pero también puedes descargar versiones anteriores, aunque… ¿para qué? si con el último te aseguras que lo tienes todo 😉
Quiero comentarte que desde esa página puedes descargar la versión del JDK para distintos sistemas operativos. En mi caso descargué el de Windows.

Si quieres usar otra versión anterior, por ejemplo, la implementación del Java SE 17 también valdría, puedes hacerlo desde los enlaces de la parte izquierda de la página del enlace que te he puesto en el párrafo anterior.

Para usarlo, te descargas el zip, lo extraes en una carpeta (normalmente en la carpeta .jdks del directorio de %USERPROFILE% (la carpeta predeterminada del usuario de Windows).

En mi caso, ahí tengo el JDK 19 (instalado por IntelliJ IDEA) y el JDK 17 que me lo descargué para comprobar que con esa versión también funciona.

Lo que hice a continuación es añadir variables de entorno para acceder fácilmente a esos directorios, concretamente he creado dos variables de entorno, una para el JDK 19 y otra para el JDK 17.

Para hacer esto, abre las opciones avanzadas del sistema (Advanced System Settings) y acceder a las variables de entorno (Environment Variables).
Para acceder, pulsa con el botón secundario en This PC > Settings y en el panel derecho (estoy usando Windows 11) pulsa en Advanced System Settings o bien en buscar escribe «Advanced System Settings» o desde la línea de comandos (o desde run) escribe control sysdm.cpl y selecciona la ficha «Advanced»

Una vez tengas las variables de entorno (ver la figura 1), pulsa en el botón New de la parte superior y en el cuadro de diálogo escribe JAVA_HOME19 y en el path escribe el directorio en el que está ese JDK, en mi caso escribí %USERPROFILE%\.jdks\openjdk-19.0.1 y después se puso el path que corresponde.

Figura 1. Las variables de entorno

No es necesario que pongas los dos paths a los dos JDK, yo solo los he puesto para comprobar que la versión 17 también servía.

Una vez que tengas esto, abre la terminal o la línea de comandos y escribe %JAVA_HOME19%\bin\java --version para comprobar la versión del JDK de Java instalado.

Microsoft Windows [Version 10.0.22000.1281]
(c) Microsoft Corporation. All rights reserved.

C:\Users\Guille>%JAVA_HOME19%\bin\java --version
openjdk 19.0.1 2022-10-18
OpenJDK Runtime Environment (build 19.0.1+10-21)
OpenJDK 64-Bit Server VM (build 19.0.1+10-21, mixed mode, sharing)

Puedes escribir tanto java --version como java -version, el resultado prácticamente es el mismo, pero no igual; además de que -version se muestra en el stream de error y –version en el stream de salida.

Te aclaro que todo esto es por si el Java que tienes instalado es anterior a la versión 17, cosa que ocurrirá si tienes Visual Studio instalado y has indicado que quieres crear aplicaciones de Xamarin o .NET MAUI que instalan los JDK de Java.

En cualquier caso, antes de ahcer todo lo aquí explicado, comprueba con java -version (sin indicar ningún path y con un solo guión, ya que las versiones anteriores no reconocen el parámetro --version) qué versión tienes y si es la 17 o superior, pues… ¡todo hecho!

En mi caso me muestra esto, así que, necesito instalar un JDK más reciente.

Microsoft Windows [Version 10.0.22000.1281]
(c) Microsoft Corporation. All rights reserved.

C:\Users\Guille>java -version
openjdk version "1.8.0_302"
OpenJDK Runtime Environment (Temurin)(build 1.8.0_302-b08)
OpenJDK 64-Bit Server VM (Temurin)(build 25.302-b08, mixed mode)

Al compilar el código te explicaré para qué he creado la variable de entorno %JAVA_HOME19%, ya que no he querido añadir el path al directorio bin del JDK en la variable de entorno PATH para que no afecte a lo que Visual Studio necesita.

El código de prueba

Para esto que te comentaré en este post, voy a usar el código publicado en el gist Evaluar.java (gist = trozo de código publicado en GitHub).

En ese código, utilizo la expresión switch (no confundir con la sentencia switch) y los records con tipos genéricos para simular una tuple de 2 valores, (tuple = una estructura de datos que consiste en múltiples partes).

Nota:
En el lenguaje Java no existe el «tipo tuple» aunque hay implementaciones que, si lo tienen, como por ejemplo JavaTuples de Maven (en esta página puedes ver algunos ejemplos de JavaTuples), pero no en el JDK oficial (al menos a día de hoy).

Como en mi código necesitaba que una función devolviese dos valores, lo simulé con un record de tipo genérico. Este es el código:

/**                                                                             
 * Tuple de dos valores para usar al buscar un operador y la posición del mismo.
 *                                                                              
 * @param operador Un valor del tipo T1.                                        
 * @param position Un valor del tipo T2.                                        
 * @param <T1> El tipo (por referencia) del primer parámetro.                   
 * @param <T2> El tipo (por referencia) del segundo parámetro.                  
 */                                                                              
record TuplePair<T1, T2>(T1 operador, T2 position) {                            
}

Compilar el código JAVA y crear el fichero .jar

Descarga el fichero ese de prueba, en el que utilizo 3 clases (2 clases y un record) ambos definidos dentro de la clase Evaluar (fichero Evaluar.java) y cópialo en cualquier carpeta de tu equipo.

Todo lo que aquí te explico también serviría si la clase ConsoleColor está definida en un fichero independiente, aunque el record (TuplePair) debe estar definido dentro de la clase Evaluar, ya que se accede directamente a los campos privados del record en vez de a métodos públicos. Esos campos privados son accesibles desde la clase Evaluar porque el record está definido «dentro» de esa clase.

Compilar el código con javac

Para compilar el código usamos javac indicando los ficheros .java a compilar, opcionalmente le podemos indicar en qué directorio queremos que se creen los ficheros compilados (con extensión .class) y la codificación de esos ficheros, por ejemplo:

%JAVA_HOME19%\bin\javac -d .\ -encoding UTF-8 *.java

En este caso, los ficheros .java están en la misma carpeta desde la que se ejecuta javac.exe y le indicamos que la carpeta para los ficheros .class generados sean en la misma carpeta, (en realidad ese comando u opción -d lo podríamos haber obviado) y que el enconding de los ficheros es UTF-8.

Si el código de los ficheros .java está en otra carpeta, por ejemplo, la carpeta src dentro del directorio actual, y queremos que los ficheros .class se guarden en la carpeta actual, podríamos escribir:

%JAVA_HOME19%\bin\javac -d .\ -encoding UTF-8 .\src\*.java

Crear y usar el .jar ejecutable

Una vez generados los ficheros .class nos toca usar el comando jar.exe para crear un fichero .jar.

Por ejemplo:

%JAVA_HOME19%\bin\jar cf evaluar.jar *.class

Este comando crea el fichero .jar pero sin indicar dónde encontrar el método main.

Para probar el código compilado tendríamos que hacerlo de esta forma:

%JAVA_HOME19%\bin\java -cp evaluar.jar Evaluar 25+(2*3)+5!

Con esto le estamos indicando que utilice el fichero evaluar.jar, que el método main está en la clase Evaluar y por último los parámetros que queremos pasarle al programa.

Otra forma de usar el código compilado (sin necesidad de que el fichero .jar esté presente, aunque sí los ficheros .class) es:

%JAVA_HOME19%\bin\java Evaluar 25+(2*3)+5!

Aquí le indicamos que use el el método main de la clase Evaluar y pase los parámetros indicados como argumentos del programa.

Crear y usar el .jar con un manifiesto que indica dónde encontrar el método main

Pero lo mejor es crear un fichero de manifiesto donde se le indique al comando jar.exe dónde está (o cuál es) el método main que queremos usar.

Para ello creamos un fichero de texto con el siguiente contenido:

Main-Class: Evaluar

Después de Main-Class: indicaremos el nombre de la clase en la que está definido el método main. Recuerda que el nombre de la clase distingue entre mayúsculas y minúsculas.

Esto lo podemos crear directamente desde la línea de comandos escribiendo lo siguiente:

echo Main-Class: Evaluar > manifiesto.txt

Una vez que tenemos ese fichero del manifiesto, podemos crear el fichero .jar de esta forma:

%JAVA_HOME19%\bin\jar cvmf manifiesto.txt evaluar.jar *.class

Y para usarlo tendríamos que hacerlo de esta otra:

%JAVA_HOME19%\bin\java -jar evaluar.jar 25+(2*3)+5!

Si esto último lo hacemos con un .jar sin manifiesto obtendríamos el siguiente error:

no main manifest attribute, in evaluar.jar

Nota:
El nombre del fichero manifiesto puede ser el que quieras y con la extensión que quieras. Aunque el nombre recomendado es MANIFEST.MF.

De hecho, si abres un fichero .jar (que en realidad es como un fichero comprimido) puedes ver que la estructura en la que se incluye una carpeta llamada META-INF con el manifiesto, incluso si no indicamos un manifiesto esa carpeta y el correspondiente fichero MANIFEST.MF se crea, aunque sin indicar qué clase contiene el método main.

El contenido del MANIFEST.MF, del .jar que hemos generado, sería este si se ha indicado dónde está el método main):

Manifest-Version: 1.0
Main-Class: Evaluar
Created-By: 19.0.1 (Oracle Corporation)

Además de esa carpeta se incluyen todos los .class que se hayan generado (un .class por cada clase incluida en el código).

Y esto ha sido todo amigos… espero que te sirva…

Nos vemos.
Guillermo

Evaluar expresiones (código en Java y C#)

Pues eso… Sí, has leído bien el título: en Java. Y no en JavaScript (aparte de en C#).

Y es que hace unos días, empecé a estudiar esto de Java a raíz que mi hijo David está haciendo un curso de Java (back-end) y era por si le echaba una mano en algunos conceptos, ya que lo que él estudio en su día fue COBOL, algo de Pascal y algo de Visual Basic 6, y claro… los conceptos de POO y esas cosas, como que no las tiene claras.

Y para poder ayudarle (si es que así me lo hace saber), me puse a «trastear» en Java, y de camino he aprendido entre otras cosas, que hay diferencias, algunos grandes, en comparación con C# que es lo más parecido, (con Visual Basic ni te cuento).

Algunas de esas diferencias son a favor de Java, y la mayoría, a favor de C# o si lo prefieres a favor de .NET, seguramente porque lo conozco más.

Pero sea como sea, y peleándome un poco con el código y el IDE, que por cierto estoy usando uno que me parece muy bueno y es gratis: IntelliJ IDEA (Community Edition) de JetBrains, he conseguido hacer algo más o menos operativo y que me está enseñando algunas de esas cosas que ni siquiera sabía que C# las tenía y otras que al parecer C# tiene porque Java las tenía.

Lo que más he echado en falta son las «tuplas», aunque en este código de evaluar expresiones aritméticas he solventado con records, más que nada porque en algunas funciones necesitaba devolver dos valores (seguramente en Java habrá otra forma de hacerlo, pero no la he encontrado). Otra cosa que he echado en falta en Java es las estructuras (tipos de datos definibles, pero por valor).

 

No te voy a explicar «paso a paso» el código ni nada de eso (al menos por ahora), simplemente te voy a decir lo que este evaluador sabe hacer (creo que lo hace bien) y el código lo podrás ver en el repositorio de GitHub.

Quiero comentarte que primero hice una versión usando records para hacer las operaciones de suma, restas, multiplicación y división (basándome en un ejemplo de la documentación de Java), y el último es usando tipos double que además de esas cuatro operaciones hace un par de ellas más: módulo y factorial.

El enlace de GitHub o, mejor dicho, los enlaces son para el código basado en el tipo double, en esos repositorios tienes los enlaces al código fuente que usa los records, tanto para Java como para C#.

 

Lo que hace el evaluador de expresiones

  • Evalúa expresiones entre paréntesis (con varios niveles de anidación).
  • Evalúa primero los operadores multiplicativos (* y x para multiplicar, / y : para dividir y % para el módulo) y después los operadores aditivos (+ para sumar, – para restar).
  • La expresión puede tener espacios, pero al evaluarla se quitan, por tanto: «1 5 * 2» se convierte en «15*2».
  • Si hay un paréntesis de apertura precedido por un dígito o de un paréntesis de cierre, se considera una multiplicación y se pone el signo *.
  • Si hay un paréntesis de cierre seguido de un dígito o de un paréntesis de apertura, se considera una multiplicación y se pone el signo *.
  • Evalúa factoriales (usando el carácter «!»), tanto de números enteros positivos (naturales) como números negativos con parte decimal.
  • El valor de la factorial para números no naturales se calcula usando la función gamma basada en un código adaptado de un ejemplo de StackOverflow.

 

El código de Java y C# en GitHub

Estos son los enlaces del código fuente que tengo publicado en GitHub:

EvaluarExpresiones-java y EvaluarExpresiones-csharp.

Espero que te sea de utilidad.

Nos vemos.
Guillermo