Los imports son bastante comunes en Java, de hecho cuando aprendes a programar en Java, se usan mucho para trabajar con las bibliotecas y las funcionalidades que ya están definidas dentro de los paquetes estándar del lenguaje. Aún así, muchos desconocen el import java.util.* que tiene unos usos bastantes particulares y con el que puedes lograr un excelente código.
¿Qué es import java.util.*?
Ese pequeño asterisco que aparece al final de import java.util.* te ayudará a importar todas las clases que pertenecen al paquete java.util. En caso de que no lo recuerdes, este paquete es uno de los más usados en Java, ya que contiene muchas clases que permiten trabajar con colecciones, fechas, utilidades de sistema, y más. Cuando usas este import, el código tiene acceso a todas estas clases sin necesidad de escribir cada una de ellas de manera individual.
Por ejemplo, en lugar de tener que escribir algo como esto:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Date;
Podrías simplemente escribir:
import java.util.*;
Te resultará más práctico, sobre todo si vas a trabajar en un proyecto pequeño o cuando necesites varias clases de este paquete.
¿Por qué usar import java.util.*?
Ventajas
- Ahorras tiempo: Como te dije, al usar el import con el asterisco, se simplifica el código y ahorras tiempo. No necesitas preocuparte por especificar cada clase que vas a usar dentro del paquete java.util.
- Práctico en proyectos pequeños: Si estás trabajando en un proyecto pequeño y no te importa hacer una importación masiva de clases, te conviene más este enfoque.
- Facilita la escritura: No tienes que recordar todas las clases que necesitas importar del paquete java.util, lo cual es útil especialmente cuando no trabajas con un IDE avanzado.
Desventajas
Posibles conflictos: Un riesgo es que, al importar todas las clases de java.util, puedes encontrarte con conflictos de nombres.
- Por ejemplo, si también tienes importado otro paquete que contiene clases con el mismo nombre, como java.awt.List y java.util.List, Java no sabrá cuál utilizar y lanzará un error de compilación.
Poco rendimiento en proyectos grandes: Aunque no tiene mucho impacto en el rendimiento de la compilación, en proyectos más grandes, usar import java.util.* puede ralentizarla, ya que el compilador debe verificar todas las clases del paquete, aunque no las vayas a usar.
Poca legibilidad de código: Cuando otros desarrolladores leen tu código, un import java.util.* puede hacer que no sea claro de inmediato qué clases específicas estás utilizando del paquete. Esto puede dificultar la comprensión del código y aumentar la probabilidad de errores en proyectos grandes.
¿Cuándo usar import java.util.*?
Te recomiendo usarlo solo en estos escenarios:
- Proyectos pequeños o scripts: Si estás escribiendo un programa pequeño o un script y necesitas acceder a varias clases de java.util, el uso del asterisco puede ser rápido y conveniente.
- Prueba rápida: Cuando estás en una fase de prototipado o pruebas rápidas, y no te importa ser tan específico con los imports.
Recuerda, en proyectos grandes no uses el asterisco. Mejor especifica cada clase que necesitas, así como te lo muestro aquí:
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
Importar de una clase específica: ¿qué pasa con el uso de import en Java?
Usa también el import estático para importar los métodos y atributos estáticos de una clase, pero sin tener que prefijar el nombre de la clase cada vez que los utilizas:
Sería algo así:
import static java.lang.Math.*;
import static java.lang.System.out;
Así logras un código limpio y sin tener que usar el nombre de la clase todo el tiempo:
double resultado = sqrt(16); // En lugar de Math.sqrt(16)
out.println("Resultado: " + resultado); // En lugar de System.out.println("Resultado: " + resultado)
¿Qué pasa si no usamos import?
Es muy simple, cuando no lo usas el compilador de Java no sabe dónde encontrar las clases y te lanzará un error. Así que tendrás que especificar el nombre completo de la clase, incluyendo el paquete, cada vez que la uses.
Por ejemplo, si quieres utilizar una clase de java.util, tendrías que escribir:
java.util.ArrayList<String> lista = new java.util.ArrayList<>();
Como ves, tu código se vuelve más largo y difícil de leer.
Importar subpaquetes: ¿cuál es la diferencia?
Es importante entender que cuando usas import java.util.*, solo estas importando las clases que se encuentran dentro del paquete java.util.
En caso de que tengas que usar clases que se encuentran en un subpaquete de java.util, como java.util.stream.Collectors, no bastará con usar import java.util.*.
Vas a tener que importar explícitamente el subpaquete o la clase específica:
import java.util.stream.Collectors;
No te quedes solo con la teoría. Con el Bootcamp de Java Full Stack de KeepCoding aprenderás desde lo básico hasta la creación de aplicaciones completas, y te enseñaremos las mejores prácticas para escribir código de forma profesional. ¡No esperes más para dar el siguiente paso en tu carrera de desarrollo de software!
