LENGUAJE DE
PROGRAMACION II
JAVA SWING
UNIDAD II – COMPONENTES AVANZADOS
COMPONENTES AVANZADOS DE JAVA
SWING
Los componentes avanzados de Java Swing son herramientas poderosas
que permiten crear interfaces de usuario más sofisticadas y ricas en
funcionalidades. Estos componentes van más allá de los elementos básicos
y ofrecen soluciones especializadas para tareas más complejas.
Algunos de los componentes avanzados más destacados son: JTable,
JInternalFrame y los Layouts.
JTABLE EN JAVA SWING
El JTable es un componente avanzado de Java Swing que se utiliza para
mostrar datos en forma de tabla. Puedes utilizarlo para representar
grandes conjuntos de datos en filas y columnas, permitiendo al usuario
interactuar con los datos de forma efectiva.
JTABLE EN JAVA SWING
Ejemplo:
import [Link].*;
import [Link];
public class EjemploJTable {
public static void main(String[] args) {
JFrame ventana = new JFrame("Ejemplo JTable");
[Link](JFrame.EXIT_ON_CLOSE);
[Link](400, 300);
Object[][] data = {
{"Juan", "Pérez", 30},
{"María", "Gómez", 25},
{"Pedro", "López", 28}
};
String[] columnNames = {"Nombre", "Apellido", "Edad"};
DefaultTableModel model = new DefaultTableModel(data, columnNames);
JTable table = new JTable(model);
JScrollPane scrollPane = new JScrollPane(table);
[Link]().add(scrollPane);
[Link](true);
}
}
JTABLE EN JAVA SWING
En este ejemplo, se importa la clase JTable, JScrollPane, DefaultTableModel y JFrame de [Link] para utilizarlas en el código. Luego, se crea una
instancia de JFrame llamada ventana que representa la ventana principal de la aplicación.
Después, se definen los datos para la tabla en un array bidimensional data, y los encabezados de las columnas en un array de strings columnNames.
A continuación, se crea un DefaultTableModel llamado model utilizando los datos y encabezados definidos anteriormente. El DefaultTableModel es
una implementación predeterminada de la interfaz TableModel, que proporciona los datos para la tabla.
Luego, se crea un JTable llamado table utilizando el modelo de tabla model.
Después, se agrega el JTable a un JScrollPane llamado scrollPane. Esto es necesario para agregar barras de desplazamiento si el contenido de la tabla
excede el espacio visible.
Finalmente, se agrega el JScrollPane a la ventana principal utilizando el método getContentPane().add(scrollPane) para añadirlo al panel de contenido
de la ventana.
Al ejecutar este código, se abrirá una ventana con un JTable que muestra los datos definidos en el array data con los encabezados de columna
especificados en columnNames. Si los datos exceden el espacio visible del JTable, aparecerán barras de desplazamiento para permitir al usuario
desplazarse por el contenido de la tabla.
Con el JTable, puedes realizar diversas acciones, como agregar, eliminar o editar filas, ordenar los datos por columna, y personalizar la apariencia y el
comportamiento de las celdas. Esto hace que el JTable sea una herramienta valiosa para mostrar datos tabulares en tus aplicaciones Java Swing.
JTABLE EN JAVA SWING
En un JTable, puedes ajustar y personalizar el tamaño de las columnas para
que se adapten al contenido o para establecer tamaños fijos. Hay varias
formas de lograr esto:
Tamaño automático basado en el contenido:
Para ajustar automáticamente el tamaño de las columnas según su
contenido, puedes utilizar el método packColumn() de la clase JTable. Esto
ajustará el tamaño de cada columna para que el contenido se ajuste
perfectamente sin cortarse.
JTABLE EN JAVA SWING
Ejemplo:
import [Link].*;
import [Link];
public class EjemploJTable {
public static void main(String[] args) {
JFrame ventana = new JFrame("Ejemplo JTable");
[Link](JFrame.EXIT_ON_CLOSE);
[Link](400, 300);
Object[][] data = {
{"Juan", "Pérez", 30},
{"María", "Gómez", 25},
{"Pedro", "López", 28}
};
String[] columnNames = {"Nombre", "Apellido", "Edad"};
DefaultTableModel model = new DefaultTableModel(data, columnNames);
JTable table = new JTable(model);
// Ajustar automáticamente el tamaño de las columnas
for (int columnIndex = 0; columnIndex < [Link](); columnIndex++) {
[Link]().getColumn(columnIndex).pack();
}
JScrollPane scrollPane = new JScrollPane(table);
[Link]().add(scrollPane);
[Link](true);
}
}
JTABLE EN JAVA SWING
Tamaño fijo de columnas:
Si deseas establecer un tamaño fijo para alguna o todas las columnas,
puedes utilizar el método setPreferredWidth() de la clase TableColumn.
Esto te permite especificar un ancho fijo en píxeles para una columna
específica.
JTABLE EN JAVA SWING
Ejemplo:
//…
// Crear el JTable con el modelo de tabla
JTable table = new JTable(model);
// Establecer un tamaño fijo para la primera columna (por ejemplo, 150 píxeles)
[Link]().getColumn(0).setPreferredWidth(150);
// Agregar el JTable a un JScrollPane para agregar barras de desplazamiento
JScrollPane scrollPane = new JScrollPane(table);
// Agregar el JScrollPane a la ventana
[Link]().add(scrollPane);
// Hacer visible la ventana
[Link](true);
JTABLE EN JAVA SWING
Con estas opciones, puedes ajustar y personalizar el tamaño de las
columnas en un JTable según tus necesidades y preferencias. Si tienes
contenido que puede ser muy largo y quieres asegurarte de que todo sea
visible, el tamaño automático basado en el contenido es una excelente
opción. Si prefieres un diseño más controlado con tamaños fijos, puedes
establecer manualmente el tamaño de las columnas que desees.
JTABLE EN JAVA SWING (ordenar)
Para ordenar los datos de un JTable en Java Swing, puedes utilizar un
objeto TableRowSorter. El TableRowSorter es una clase que permite aplicar
el ordenamiento a las filas de un TableModel asociado al JTable. Puedes
ordenar los datos en función de una o varias columnas en orden
ascendente o descendente.
JTABLE EN JAVA SWING (ordenar)
Ejemplo: import [Link].*;
import [Link];
import [Link];
public class EjemploOrdenarJTable {
public static void main(String[] args) {
JFrame ventana = new JFrame("Ejemplo Ordenar JTable");
[Link](JFrame.EXIT_ON_CLOSE);
[Link](400, 300);
Object[][] data = {
{"Juan", "Pérez", 30},
{"María", "Gómez", 25},
{"Pedro", "López", 28},
{"Laura", "Martínez", 22}
};
String[] columnNames = {"Nombre", "Apellido", "Edad"};
DefaultTableModel model = new DefaultTableModel(data, columnNames);
JTable table = new JTable(model);
// Crear un TableRowSorter y asociarlo al JTable
TableRowSorter<DefaultTableModel> sorter = new TableRowSorter<>(model);
[Link](sorter);
// Ordenar los datos en orden ascendente según la columna "Edad"
[Link](2);
JScrollPane scrollPane = new JScrollPane(table);
[Link]().add(scrollPane);
[Link](true);
}
}
JTABLE EN JAVA SWING (ordenar)
En este ejemplo, después de crear el JTable y su modelo, se crea un TableRowSorter llamado
sorter y se asocia con el modelo del JTable mediante [Link](sorter);.
Luego, utilizamos el método toggleSortOrder(int column) para ordenar los datos por la columna
especificada en orden ascendente. En este caso, estamos ordenando por la columna "Edad"
(índice 2, ya que los índices comienzan en 0).
El resultado será un JTable con los datos ordenados por la columna "Edad" en orden ascendente.
Si deseas ordenar en orden descendente, simplemente llama nuevamente al método
toggleSortOrder(int column).
Con este enfoque, puedes implementar fácilmente el ordenamiento de datos en tus JTable para
mejorar la experiencia del usuario y proporcionar una visualización más organizada de los datos.
JTABLE EN JAVA SWING (filtrar)
Para filtrar los datos de un JTable en Java Swing, puedes utilizar un objeto
RowFilter. El RowFilter es una clase que te permite definir reglas para
filtrar las filas que se mostrarán en el JTable. Puedes filtrar los datos en
función de los valores de una o varias columnas, utilizando diferentes
criterios de comparación.
JTABLE EN JAVA SWING (filtrar)
Ejemplo: import [Link].*;
import [Link];
import [Link];
import [Link];
public class EjemploFiltrarJTable {
public static void main(String[] args) {
JFrame ventana = new JFrame("Ejemplo Filtrar JTable");
[Link](JFrame.EXIT_ON_CLOSE);
[Link](400, 300);
Object[][] data = {
{"Juan", "Pérez", 30},
{"María", "Gómez", 25},
{"Pedro", "López", 28},
{"Laura", "Martínez", 22}
};
String[] columnNames = {"Nombre", "Apellido", "Edad"};
DefaultTableModel model = new DefaultTableModel(data, columnNames);
JTable table = new JTable(model);
// Crear un TableRowSorter y asociarlo al JTable
TableRowSorter<DefaultTableModel> sorter = new TableRowSorter<>(model);
[Link](sorter);
// Crear un filtro para mostrar solo las filas donde la edad es mayor o igual a 25
RowFilter<DefaultTableModel, Object> filtroEdad = RowFilter
.numberFilter([Link], 24, 2);
// Aplicar el filtro al TableRowSorter
[Link](filtroEdad);
JScrollPane scrollPane = new JScrollPane(table);
[Link]().add(scrollPane);
[Link](true);
}
}
JTABLE EN JAVA SWING (filtrar)
En este ejemplo, después de crear el JTable y su modelo, se crea un TableRowSorter llamado sorter y se
asocia con el modelo del JTable mediante [Link](sorter);.
Luego, creamos un RowFilter llamado filtroEdad que filtra las filas donde el valor de la columna "Edad" es
mayor o igual a 25. Utilizamos el método numberFilter(ComparisonType type, int value, int index) para crear
el filtro, especificando que queremos comparar valores numéricos en la columna "Edad" (índice 2) y mostrar
solo las filas donde el valor sea mayor que 24 (es decir, mayor o igual a 25).
Finalmente, aplicamos el filtro al TableRowSorter mediante [Link](filtroEdad);.
El resultado será un JTable con los datos filtrados, mostrando solo las filas donde la edad es mayor o igual a
25.
Con este enfoque, puedes implementar fácilmente el filtrado de datos en tus JTable para mostrar solo la
información relevante para el usuario, lo que puede mejorar la experiencia y facilitar la navegación de
grandes conjuntos de datos.
JINTERNALFRAME EN JAVA SWING
El JInternalFrame en Java Swing es un componente que se utiliza para
crear ventanas internas dentro de una ventana principal, también
conocidas como ventanas secundarias o subventanas. Los JInternalFrames
son útiles cuando deseas organizar múltiples vistas o módulos dentro de
una sola interfaz, lo que te permite tener varias áreas de trabajo dentro de
una misma aplicación.
JINTERNALFRAME EN JAVA SWING
Ejemplo: import [Link].*;
public class EjemploJInternalFrame {
public static void main(String[] args) {
// Crear una nueva ventana JFrame
JFrame ventanaPrincipal = new JFrame("Ejemplo JInternalFrame");
[Link](JFrame.EXIT_ON_CLOSE);
[Link](500, 400);
// Crear un JDesktopPane para manejar los JInternalFrames
JDesktopPane desktopPane = new JDesktopPane();
// Crear un JInternalFrame
JInternalFrame internalFrame = new JInternalFrame("Ventana Interna", true, true, true, true);
[Link](200, 150);
[Link](true);
// Agregar contenido al JInternalFrame
JLabel etiqueta = new JLabel("¡Hola, soy un JInternalFrame!");
[Link](etiqueta);
// Agregar el JInternalFrame al JDesktopPane
[Link](internalFrame);
// Agregar el JDesktopPane a la ventana principal
[Link](desktopPane);
// Hacer visible la ventana principal
[Link](true);
}
}
JINTERNALFRAME EN JAVA SWING
En este ejemplo, se importa la clase JFrame, JDesktopPane, JInternalFrame y JLabel de [Link] para utilizarlas en el código. Luego, se
crea una instancia de JFrame llamada ventanaPrincipal que representa la ventana principal de la aplicación.
Después, se crea un JDesktopPane llamado desktopPane, que actuará como el contenedor de los JInternalFrames.
A continuación, se crea un JInternalFrame llamado internalFrame con el título "Ventana Interna" y con la capacidad de ser redimensionado,
cerrado, minimizado y maximizado. Se establece su tamaño y visibilidad.
Luego, se crea un JLabel llamado etiqueta, que contendrá el contenido que se mostrará dentro del JInternalFrame.
Después, se agrega el JLabel al JInternalFrame utilizando el método add().
Luego, se agrega el JInternalFrame al JDesktopPane mediante el método add() del desktopPane.
Finalmente, se agrega el JDesktopPane a la ventana principal utilizando el método add() del ventanaPrincipal, para que actúe como el área
donde se mostrarán los JInternalFrames.
Al ejecutar este código, se abrirá una ventana principal con un JDesktopPane que actúa como un contenedor para JInternalFrames. En este
ejemplo, verás un JInternalFrame con la etiqueta "¡Hola, soy un JInternalFrame!".
Los JInternalFrames ofrecen una forma útil de organizar y manejar múltiples ventanas internas dentro de una ventana principal, lo que
permite crear aplicaciones con múltiples áreas de trabajo y mejorar la experiencia de usuario al mantener la interfaz ordenada y
organizada.
LAYOUTS EN JAVA SWING
Los Layouts en Java Swing son administradores de diseño que controlan
cómo los componentes se colocan y se ajustan dentro de un contenedor,
como un JPanel o un JFrame. Los Layouts permiten crear interfaces gráficas
flexibles y responsivas, asegurándose de que los componentes se vean
correctamente en diferentes tamaños de pantalla y respetando las
preferencias del usuario. Java Swing proporciona varios tipos de Layouts,
cada uno con sus propias características y formas de organizar los
componentes.
LAYOUTS EN JAVA SWING
BorderLayout:
El BorderLayout es un administrador de diseño que organiza los
componentes en cinco áreas: norte, sur, este, oeste y centro. Los
componentes que se agregan en el centro ocuparán el espacio restante
después de colocar los componentes en las otras áreas.
LAYOUTS EN JAVA SWING
Ejemplo de BorderLayout:
import [Link].*;
public class EjemploBorderLayout {
public static void main(String[] args) {
JFrame ventana = new JFrame("Ejemplo BorderLayout");
[Link](JFrame.EXIT_ON_CLOSE);
[Link](300, 200);
JButton botonNorte = new JButton("Norte");
JButton botonSur = new JButton("Sur");
JButton botonEste = new JButton("Este");
JButton botonOeste = new JButton("Oeste");
JButton botonCentro = new JButton("Centro");
[Link](botonNorte, [Link]);
[Link](botonSur, [Link]);
[Link](botonEste, [Link]);
[Link](botonOeste, [Link]);
[Link](botonCentro, [Link]);
[Link](true);
}
}
LAYOUTS EN JAVA SWING
FlowLayout:
El FlowLayout es un administrador de diseño que coloca los componentes
en una sola fila o columna, ajustando su tamaño automáticamente según
el espacio disponible.
LAYOUTS EN JAVA SWING
Ejemplo de FlowLayout:
import [Link].*;
public class EjemploFlowLayout {
public static void main(String[] args) {
JFrame ventana = new JFrame("Ejemplo FlowLayout");
[Link](JFrame.EXIT_ON_CLOSE);
[Link](300, 200);
JPanel panel = new JPanel();
[Link](new FlowLayout());
JButton boton1 = new JButton("Botón 1");
JButton boton2 = new JButton("Botón 2");
JButton boton3 = new JButton("Botón 3");
[Link](boton1);
[Link](boton2);
[Link](boton3);
[Link](panel);
[Link](true);
}
}
LAYOUTS EN JAVA SWING
GridLayout :
El GridLayout es un administrador de diseño que organiza los
componentes en una cuadrícula de filas y columnas.
LAYOUTS EN JAVA SWING
Ejemplo de GridLayout :
import [Link].*;
public class EjemploGridLayout {
public static void main(String[] args) {
JFrame ventana = new JFrame("Ejemplo GridLayout");
[Link](JFrame.EXIT_ON_CLOSE);
[Link](300, 200);
JPanel panel = new JPanel();
[Link](new GridLayout(2, 3));
JButton boton1 = new JButton("Botón 1");
JButton boton2 = new JButton("Botón 2");
JButton boton3 = new JButton("Botón 3");
JButton boton4 = new JButton("Botón 4");
JButton boton5 = new JButton("Botón 5");
JButton boton6 = new JButton("Botón 6");
[Link](boton1);
[Link](boton2);
[Link](boton3);
[Link](boton4);
[Link](boton5);
[Link](boton6);
[Link](panel);
[Link](true);
}
}
LAYOUTS EN JAVA SWING
Estos son solo algunos ejemplos de cómo utilizar diferentes Layouts en Java
Swing. Con estos administradores de diseño, puedes crear interfaces gráficas más
flexibles y organizadas, proporcionando una experiencia de usuario mejorada en
tus aplicaciones Java Swing.
CONCLUSIÓN
En conclusión, los componentes avanzados de Java Swing, como el JTable,
JInternalFrame y los diferentes Layouts, son herramientas esenciales para el desarrollo de
interfaces gráficas sofisticadas y altamente funcionales en aplicaciones Java. El JTable
permite mostrar y manipular datos tabulares de manera eficiente, mientras que el
JInternalFrame posibilita organizar múltiples vistas o módulos dentro de una sola ventana
principal, mejorando la organización y experiencia del usuario. Por otro lado, los Layouts
brindan un control preciso sobre cómo los componentes se distribuyen y adaptan a
diferentes tamaños de pantalla, garantizando una presentación óptima y responsiva.
Dominar estos componentes avanzados amplía las capacidades de desarrollo, permitiendo
crear aplicaciones más potentes y con una interfaz de usuario atractiva y amigable. Su
combinación estratégica y correcta uso facilita la creación de aplicaciones profesionales y
eficientes que respondan a las necesidades específicas de los usuarios y mejoren la
experiencia general en entornos de escritorio Java.
