1: Tabla (JTable):
1.Conceptos básicos:
Table (JTable) es un componente recién agregado de Swing. Se utiliza principalmente para mostrar datos en forma tabular. Proporciona un mecanismo simple para mostrar grandes bloques de datos.
2. Métodos de construcción comúnmente utilizados:
* JTable(): crea una instancia de JTable utilizando el modelo predeterminado del sistema.
* JTable(int numRows, int numColumns): crea una tabla vacía usando DefaultTableModel para especificar filas y columnas.
* JTable(Object[ ][ ] rowData,Object[ ][ ] columnNames): crea una tabla que muestra datos bidimensionales.
Las tablas se pueden crear directamente utilizando matrices de nombres de columnas de tabla y matrices de datos de tabla.
* JTable(TableModel dm): crea una instancia de JTable especificando el esquema de datos y el esquema de campo predeterminado.
Los objetos de la clase de modelo de datos generalmente se usan para guardar datos, y los modelos de tabla se crean a través de matrices de nombres de columnas de tabla y matrices de datos de tabla.
3. Métodos comúnmente utilizados:
4. Caso integral:
Código 1:
Copie el código de código de la siguiente manera:
la clase pública JTableDemo1 extiende JFrame {
//definir tabla
tabla JTable;
//Definir el panel de la barra de desplazamiento (para que la tabla sea desplazable)
JScrollPane panel de desplazamiento;
//Definir el objeto de la clase de modelo de datos (utilizado para guardar datos),
DefaultTableModel modelo de tabla;
pública JTableDemo1() {
súper();
setTitle("Modelo de tabla y tabla");
panel de desplazamiento = nuevo JScrollPane();
//Definir matriz de nombre de columna de tabla
String[] columnNames = { "A", "B", "C" };
//Definir la matriz de datos de la tabla
Cadena[][] tableValues = { { "A1", "B1","C1" }, { "A2", "B2","C2" },
{ "A3", "B3", "C3" }, { "A4", "B4", "C4" } };
//Crea un objeto de la clase de modelo de tabla especificando los nombres de las columnas de la tabla y los datos de la tabla
tableModel = new DefaultTableModel(tableValues, columnNames);
//Crea una tabla del modelo de tabla especificado
tabla = nueva JTable(tableModel);
// Establecer RowSorter (RowSorter se utiliza para ordenar y filtrar JTable).
table.setRowSorter(new TableRowSorter<DefaultTableModel>(tableModel));
scrollPane.setViewportView(tabla);
getContentPane().add(scrollPane, BorderLayout.CENTER);
establecerLímites(300, 200, 400, 300);
setVisible(verdadero);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
público estático vacío principal (String args []) {
nuevo JTableDemo1();
}
}
Captura de pantalla 1:
Código 2:
Copie el código de código de la siguiente manera:
importar java.awt.*;
importar javax.swing.*;
clase pública JTableDemo3 {
Marco JFrame;
Panel JPanel;
JScrollPane desplazamientoPane1, desplazamientoPane2, desplazamientoPane3;
JTable jtable1, jtable2, jtable3;
pública JTableDemo3() {
marco = nuevo JFrame("JTableDemo");
jtable1 = nueva JTable(8, 6);
final Object[] columnNames = { "Nombre", "Género", "Dirección particular", // Los nombres de las columnas se modifican mejor con final
"Número de teléfono", "Cumpleaños", "Trabajo", "Ingresos", "Estado civil", "Estado civil" };
Objeto[][] filaDatos = {
{ "ddd", "Hombre", "Nanjing, Jiangsu", "1378313210", "24/03/1985", "Estudiante", "Parásito",
"soltero", "no" },
{ "eee", "mujer", "Nanjing, Jiangsu", "13645181705", "xx/xx/1985", "tutor", "desconocido",
"Soltero", "Parece que no" },
{ "fff", "masculino", "Nanjing, Jiangsu", "13585331486", "08/12/1985", "vendedor de automóviles",
"No estoy seguro", "Soltero", "Sí" },
{ "ggg", "mujer", "Nanjing, Jiangsu", "81513779", "xx/xx/1986", "asistente de hotel",
"Determinado pero desconocido", "Soltero", "Sí" },
{ "hhh", "Hombre", "Nanjing, Jiangsu", "13651545936", "xx/xx/1985", "Estudiante", "En el exilio",
"Soltero", "No después de numerosas rupturas" } };
jtable2 = new JTable(rowData, columnNames);
jtable3 = new JTable(rowData, columnNames);
jtable3.setPreferredScrollableViewportSize(new Dimension(600, 100));//Establecer el tamaño de la tabla
jtable3.setRowHeight(30);//Establece la altura de cada fila en 20
jtable3.setRowHeight(0, 20);//Establece la altura de la fila 1 en 15
jtable3.setRowMargin(5);//Establece la distancia entre dos filas adyacentes de celdas
jtable3.setRowSelectionAllowed(true); // Establece si se puede seleccionar. El valor predeterminado es falso.
jtable3.setSelectionBackground(Color.white);//Establece el color de fondo de la fila seleccionada
jtable3.setSelectionForeground(Color.red);//Establece el color de primer plano de la fila seleccionada
jtable3.setGridColor(Color.red);//Establece el color de las líneas de la cuadrícula
jtable3.selectAll();//Seleccionar todas las filas
jtable3.setRowSelectionInterval(0, 2);//Establezca la fila de selección inicial, aquí las filas 1 a 3 están todas en el estado seleccionado
jtable3.clearSelection();//Cancelar selección
jtable3.setDragEnabled(false); // No entiendo esto
jtable3.setShowGrid(true); // Si se muestran las líneas de la cuadrícula
jtable3.setShowHorizontalLines(true); // Si se muestran líneas de cuadrícula horizontales
jtable3.setShowVerticalLines(true); // Si se muestran líneas de cuadrícula verticales
jtable3.setValueAt("tt", 0, 0);//Establece el valor de una determinada celda, este valor es un objeto
jtable3.doLayout();
jtable3.setBackground(Color.cian);
// Es mejor agregar JTable a JScrollPane para lograr el efecto de desplazamiento
scrollPane1 = nuevo JScrollPane(jtable1);
scrollPane2 = nuevo JScrollPane(jtable2);
scrollPane3 = nuevo JScrollPane(jtable3);
panel = nuevo JPanel(nuevo GridLayout(0, 1));
panel.setPreferredSize(nueva Dimensión(600, 400));
panel.setBackground(Color.negro);
panel.add(scrollPane1);
panel.add(scrollPane2);
panel.add(scrollPane3);
marco.setContentPane(panel);
marco.paquete();
frame.setVisible (verdadero);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
público estático vacío principal (String [] argumentos) {
nuevo JTableDemo3();
}
}
Captura de pantalla 2:
Dos: Árbol (JTree):
1.Conceptos básicos:
Árbol (JTree): control que muestra conjuntos de datos jerárquicos como esquemas.
2. Métodos de construcción comúnmente utilizados:
JTree(): Devuelve un JTree con el modelo de muestra.
JTree (valor de objeto []): devuelve un JTree que especifica cada elemento de la matriz como un nodo secundario del nuevo nodo raíz que no se muestra.
//Solo este constructor puede crear múltiples nodos raíz
JTree (valor de objeto []): devuelve un JTree que especifica cada elemento de la matriz como un nodo secundario del nuevo nodo raíz que no se muestra.
JTree (raíz de TreeNode): devuelve un JTree con el TreeNode especificado como raíz, que muestra el nodo raíz.
JTree (raíz de TreeNode, boolean asksAllowsChildren): devuelve un JTree con el TreeNode especificado como raíz.
Muestra el nodo raíz de una manera especificada y determina si el nodo es un nodo hoja. (Establezca verdadero para agregar nodos secundarios y luego agregue nodos secundarios).
3. Demostración del código:
Ejemplo 1:
Copie el código de código de la siguiente manera:
clase pública JTreeDemo1 {
JMarco f;
Caja de caja;
JÁrbol jÁrbol1,jÁrbol2;
público JTreeDemo1()
{
f = nuevo JFrame(" JTreeDemo1 ");
box = Box.createHorizontalBox(); //Crear objeto de clase Box
jTree1 = nuevo JTree();
jTree2 = nuevo JTree();
//Agregar claves/valores arbitrarios a este componente
jTree1.putClientProperty("JTree.lineStyle", "En ángulo");
//Añadir un panel de desplazamiento al contenedor Box
box.add(new JScrollPane(jTree1), BorderLayout.WEST);
box.add(nuevo JScrollPane(jTree2), BorderLayout.EAST);
f.getContentPane().add(cuadro, BorderLayout.CENTER);
f.setSize(300, 240);
//f.paquete();
f.setLocation(300, 200);
f.setVisible (verdadero);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
público estático vacío principal (String [] argumentos) {
nuevo JTreeDemo1();
}
}
Captura de pantalla 1:
Ejemplo 2:
Copie el código de código de la siguiente manera:
clase pública JTreeDemo2 {
JMarco f;
JPanel p;
JTree jTree1,jTree2,jTree3,jTree4,jTree5,jTree6,jTree7;
público JTreeDemo2() {
f = nuevo JFrame(" JTreeDemo2 ");
// Constructor: JTree()
jTree1 = nuevo JTree();
// Constructor: JTree(Valor del objeto[])
Objeto[] letras = { "a", "b", "c", "d", "e" };
jTree2 = nuevo JTree(letras);
// Constructor: JTree(raíz de TreeNode)(TreeNode vacío)
//Crea un árbol con nodos vacíos
DefaultMutableTreeNode nodo1 = new DefaultMutableTreeNode() // Definir nodos del árbol
jTree3 = new JTree(node1); // Utilice este nodo de árbol como parámetro para llamar al constructor JTree para crear un árbol con un nodo raíz
// Constructor: JTree(raíz de TreeNode) (igual que arriba, excepto que TreeNode no está vacío)
// Crea un árbol con un nodo raíz
DefaultMutableTreeNode nodo2 = nuevo DefaultMutableTreeNode(" Color ");
jTree4 = new JTree(node2); // Los nodos no se pueden colorear, el valor predeterminado es blanco con texto negro
jTree4.setBackground(Color.lightGray);
// Constructor: JTree(raíz de TreeNode, booleano
// AsksAllowsChildren) (igual que el anterior, pero TreeNode es diferente)
// Utilice la clase DefaultMutableTreeNode para crear primero un árbol con un nodo raíz, configúrelo para agregar nodos secundarios y luego agregue nodos secundarios.
Color DefaultMutableTreeNode = nuevo DefaultMutableTreeNode(" Color ",
verdadero);
DefaultMutableTreeNode gris = nuevo DefaultMutableTreeNode(" Gris ");
gray.add(new DefaultMutableTreeNode(" Gris claro "));
gray.add(new DefaultMutableTreeNode(" Gris oscuro "));
color.add(gris);
color.add(new DefaultMutableTreeNode(" Rojo "));
color.add(new DefaultMutableTreeNode(" Verde "));
jTree5 = nuevo JTree(color);
// Constructor: JTree(raíz de TreeNode) (igual que arriba, excepto que TreeNode no está vacío)
// Crea un árbol agregando nodos uno por uno
Biología DefaultMutableTreeNode = new DefaultMutableTreeNode(" Biología ");
DefaultMutableTreeNode animal = nuevo DefaultMutableTreeNode(" Animal ");
DefaultMutableTreeNode mamífero = nuevo DefaultMutableTreeNode(" Mamífero ");
DefaultMutableTreeNode caballo = nuevo DefaultMutableTreeNode(" Caballo ");
mamífero.add(caballo);
animal.add(mamífero);
biología.add(animal);
jTree6 = nuevo JTree(biología);
caballo.isLeaf();
caballo.isRoot();
//Constructor:JTree(TreeModel nuevoModelo)
// Use la clase DefaultMutableTreeNodel para definir un nodo y luego use este nodo como parámetro para definir un nodo usando DefaultTreeMode
// Crea un modelo de árbol y luego usa el constructor JTree para crear un árbol
DefaultMutableTreeNode raíz = nuevo DefaultMutableTreeNode(" Root1 ");
DefaultMutableTreeNode niño1 = nuevo DefaultMutableTreeNode(" Niño1 ");
DefaultMutableTreeNode niño11 = nuevo DefaultMutableTreeNode(" Niño11 ");
DefaultMutableTreeNode child111 = nuevo DefaultMutableTreeNode(
"Niño111");
root.add(niño1);
niño1.add(niño11);
niño11.add(niño111);
Modelo DefaultTreeModel = nuevo DefaultTreeModel(raíz);
jTree7 = nuevo JTree(modelo);
p = nuevo JPanel();
p.setLayout(nuevo BoxLayout(p, BoxLayout.X_AXIS));
p.setPreferredSize(nueva Dimensión(700, 400));
// JTree debe colocarse en JScrollPane
p.add(new JScrollPane(jTree1));
p.add(nuevo JScrollPane(jTree2));
p.add(nuevo JScrollPane(jTree3));
p.add(nuevo JScrollPane(jTree4));
p.add(nuevo JScrollPane(jTree5));
p.add(nuevo JScrollPane(jTree6));
p.add(nuevo JScrollPane(jTree7));
f.setContentPane(p);
f.paquete();
f.setLocation(300, 200);
f.setVisible (verdadero);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
público estático vacío principal (String [] argumentos) {
nuevo JTreeDemo2();
}
}
Captura de pantalla 2: