1: Tabela (JTable):
1. Conceitos básicos:
Tabela (JTable) é um componente recém-adicionado do Swing. É usado principalmente para exibir dados em formato tabular. Ele fornece um mecanismo simples para exibir grandes blocos de dados.
2. Métodos de construção comumente usados:
* JTable(): Crie uma instância JTable usando o modelo padrão do sistema.
* JTable(int numRows, int numColumns): Crie uma tabela vazia usando DefaultTableModel para especificar linhas e colunas.
* JTable(Object[ ][ ] rowData,Object[ ][ ] columnNames): Crie uma tabela que exibe dados bidimensionais.
As tabelas podem ser criadas diretamente usando matrizes de nomes de colunas de tabelas e matrizes de dados de tabelas.
* JTable (TableModel dm): Crie uma instância JTable especificando o esquema de dados e o esquema de campo padrão.
Os objetos da classe de modelo de dados geralmente são usados para salvar dados, e os modelos de tabela são criados por meio de matrizes de nomes de colunas de tabelas e matrizes de dados de tabelas.
3. Métodos comumente usados:
4. Caso abrangente:
Código 1:
Copie o código do código da seguinte forma:
classe pública JTableDemo1 estende JFrame {
//define a tabela
Tabela JTable;
//Define o painel da barra de rolagem (para tornar a tabela rolável)
JScrollPane scrollPane;
//Defina o objeto da classe do modelo de dados (usado para salvar dados),
DefaultTableModel tableModel;
public JTableDemo1() {
super();
setTitle("Modelo de tabela e tabela");
scrollPane = novo JScrollPane();
//Define o array do nome da coluna da tabela
String[] nomescoluna = { "A", "B", "C" };
//Define o array de dados da tabela
String[][] valorestabela= { { "A1", "B1","C1" }, { "A2", "B2","C2" },
{ "A3", "B3", "C3" }, { "A4", "B4", "C4" } };
//Cria um objeto da classe do modelo de tabela especificando os nomes das colunas da tabela e os dados da tabela
tableModel = new DefaultTableModel(tableValues, columnNames);
//Cria uma tabela do modelo de tabela especificado
tabela = new JTable(modelotabela);
//Definir RowSorter (RowSorter é usado para fornecer classificação e filtragem de JTable).
table.setRowSorter(new TableRowSorter<DefaultTableModel>(tableModel));
scrollPane.setViewportView(tabela);
getContentPane().add(scrollPane, BorderLayout.CENTER);
setBounds(300, 200, 400, 300);
setVisible(verdadeiro);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main(String args[]) {
novo JTableDemo1();
}
}
Captura de tela 1:
Código 2:
Copie o código do código da seguinte forma:
importar java.awt.*;
importar javax.swing.*;
classe pública JTableDemo3 {
Quadro JFrame;
Painel JPanel;
JScrollPane scrollPane1, scrollPane2, scrollPane3;
JTable jtable1, jtable2, jtable3;
public JTableDemo3() {
frame = new JFrame("JTableDemo");
jtabela1 = nova JTabela(8, 6);
final Object[] columnNames = { "Name", "Gender", "Home Address", // Os nomes das colunas são melhor modificados com final
“Número de telefone”, “Aniversário”, “Emprego”, “Renda”, “Estado civil”, “Situação de relacionamento” };
Objeto[][] dadosdalinha = {
{ "ddd", "Masculino", "Nanjing, Jiangsu", "1378313210", "24/03/1985", "Estudante", "Parasita",
"Solteiro", "Não" },
{ "eee", "feminino", "Nanjing, Jiangsu", "13645181705", "xx/xx/1985", "tutor", "desconhecido",
"Solteiro", "Parece que não" },
{ "fff", "masculino", "Nanjing, Jiangsu", "13585331486", "08/12/1985", "vendedor de carros",
"Inseguro", "Solteiro", "Sim" },
{ "ggg", "feminino", "Nanjing, Jiangsu", "81513779", "xx/xx/1986", "atendente de hotel",
"Determinado mas desconhecido", "Solteiro", "Sim" },
{ "hhh", "Masculino", "Nanjing, Jiangsu", "13651545936", "xx/xx/1985", "Estudante", "No exílio",
"Solteiro", "Não depois de vários rompimentos" } };
jtable2 = new JTable(rowData, columnNames);
jtable3 = new JTable(rowData, columnNames);
jtable3.setPreferredScrollableViewportSize(new Dimension(600, 100));//Define o tamanho da tabela
jtable3.setRowHeight(30); //Define a altura de cada linha como 20
jtable3.setRowHeight(0, 20); // Define a altura da linha 1 para 15
jtable3.setRowMargin(5);//Define a distância entre duas linhas adjacentes de células
jtable3.setRowSelectionAllowed(true); // Define se pode ser selecionado O padrão é falso.
jtable3.setSelectionBackground(Color.white); //Define a cor de fundo da linha selecionada
jtable3.setSelectionForeground(Color.red);//Define a cor de primeiro plano da linha selecionada
jtable3.setGridColor(Color.red); //Definir a cor das linhas da grade
jtable3.selectAll();//Seleciona todas as linhas
jtable3.setRowSelectionInterval(0, 2);//Define a linha de seleção inicial, aqui as linhas 1 a 3 estão todas no estado selecionado
jtable3.clearSelection();//Cancelar seleção
jtable3.setDragEnabled(false); // Não entendi isso
jtable3.setShowGrid(true); // Se deseja exibir linhas de grade
jtable3.setShowHorizontalLines(true); // Se deseja exibir linhas de grade horizontais
jtable3.setShowVerticalLines(true); // Se deseja exibir linhas de grade verticais
jtable3.setValueAt("tt", 0, 0);//Define o valor de uma determinada célula, este valor é um objeto
jtable3.doLayout();
jtable3.setBackground(Color.ciano);
// JTable é melhor adicionado ao JScrollPane para obter efeito de rolagem
scrollPane1 = novo JScrollPane(jtable1);
scrollPane2 = novo JScrollPane(jtable2);
scrollPane3 = novo JScrollPane(jtable3);
painel = novo JPanel(novo GridLayout(0, 1));
painel.setPreferredSize(nova Dimensão(600, 400));
painel.setBackground(Color.preto);
painel.add(scrollPane1);
painel.add(scrollPane2);
painel.add(scrollPane3);
frame.setContentPane(painel);
frame.pack();
frame.setVisible (verdadeiro);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
novo JTableDemo3();
}
}
Captura de tela 2:
Dois: Árvore (JTree):
1. Conceitos básicos:
Árvore (JTree): um controle que exibe conjuntos de dados hierárquicos como contornos.
2. Métodos de construção comumente usados:
JTree(): Retorna um JTree com o modelo de amostra.
JTree(Object[] value): Retorna um JTree especificando cada elemento do array como um nó filho do novo nó raiz que não é exibido.
//Somente este construtor pode criar múltiplos nós raiz
JTree(Object[] value): Retorna um JTree especificando cada elemento do array como um nó filho do novo nó raiz que não é exibido.
JTree (TreeNode root): Retorna um JTree com o TreeNode especificado como raiz, que exibe o nó raiz.
JTree (TreeNode root, boolean askAllowsChildren): Retorna um JTree com o TreeNode especificado como sua raiz.
Ele exibe o nó raiz de uma maneira especificada e determina se o nó é um nó folha. (Defina true para adicionar nós filhos e, em seguida, adicione nós filhos).
3. Demonstração de código:
Exemplo 1:
Copie o código do código da seguinte forma:
classe pública JTreeDemo1 {
JFrame f;
Caixa de caixa;
JÁrvore jÁrvore1,jÁrvore2;
JTreeDemo1 público()
{
f = novo JFrame("JTreeDemo1");
box = Box.createHorizontalBox(); //Criar objeto de classe Box
jTree1 = new JTree();
jTree2 = new JTree();
//Adiciona chaves/valores arbitrários a este componente
jTree1.putClientProperty("JTree.lineStyle", "Angulado");
//Adiciona um painel de rolagem ao contêiner Box
box.add(novo JScrollPane(jTree1), BorderLayout.WEST);
box.add(novo JScrollPane(jTree2), BorderLayout.EAST);
f.getContentPane().add(caixa, BorderLayout.CENTER);
f.setSize(300, 240);
//f.pack();
f.setLocation(300, 200);
f.setVisible(verdadeiro);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
novo JTreeDemo1();
}
}
Captura de tela 1:
Exemplo 2:
Copie o código do código da seguinte forma:
classe pública JTreeDemo2 {
JFrame f;
JPanelp;
JÁrvore jÁrvore1,jÁrvore2,jÁrvore3,jÁrvore4,jÁrvore5,jÁrvore6,jÁrvore7;
publicJTreeDemo2(){
f = novo JFrame("JTreeDemo2");
// Construtor: JTree()
jTree1 = new JTree();
// Construtor: JTree(Object[] valor)
Objeto[] letras = { "a", "b", "c", "d", "e" };
jTree2 = nova JTree(letras);
// Construtor: JTree(TreeNode root)(TreeNode vazio)
//Cria uma árvore com nós vazios
DefaultMutableTreeNode node1 = new DefaultMutableTreeNode();
jTree3 = new JTree(node1); // Use este nó da árvore como parâmetro para chamar o construtor JTree para criar uma árvore com um nó raiz
// Construtor: JTree(TreeNode root) (igual ao acima, exceto que TreeNode não está vazio)
// Cria uma árvore com um nó raiz
DefaultMutableTreeNode node2 = new DefaultMutableTreeNode("Cor");
jTree4 = new JTree(node2); // Os nós não podem ser coloridos, o padrão é branco com texto preto
jTree4.setBackground(Color.lightGray);
// Construtor: JTree(raiz TreeNode, boolean
// pedeAllowsChildren) (igual ao acima, mas TreeNode é diferente)
// Use a classe DefaultMutableTreeNode para primeiro criar uma árvore com um nó raiz, configurá-la para adicionar nós filhos e, em seguida, adicionar nós filhos.
DefaultMutableTreeNode cor = new DefaultMutableTreeNode("Cor",
verdadeiro);
DefaultMutableTreeNode cinza = new DefaultMutableTreeNode("Cinza");
cinza.add(new DefaultMutableTreeNode(" Lightgray "));
cinza.add(new DefaultMutableTreeNode(" Darkgray "));
color.add(cinza);
color.add(new DefaultMutableTreeNode("Vermelho"));
color.add(new DefaultMutableTreeNode(" Verde "));
jTree5 = new JTree(cor);
// Construtor: JTree(TreeNode root) (igual ao acima, exceto que TreeNode não está vazio)
// Cria uma árvore adicionando nós um por um
DefaultMutableTreeNode biologia = new DefaultMutableTreeNode("Biologia");
DefaultMutableTreeNode animal = new DefaultMutableTreeNode("Animal");
DefaultMutableTreeNode mamífero = new DefaultMutableTreeNode("Mamífero");
DefaultMutableTreeNode cavalo = new DefaultMutableTreeNode("Cavalo");
mamífero.add(cavalo);
animal.add(mamífero);
biologia.add(animal);
jTree6 = novo JTree(biologia);
cavalo.isLeaf();
cavalo.isRoot();
//Construtor:JTree(TreeModel newModel)
// Use a classe DefaultMutableTreeNodel para definir um nó e então use este nó como parâmetro para definir um nó usando DefaultTreeMode
// Crie um modelo de árvore e use o construtor JTree para criar uma árvore
DefaultMutableTreeNode raiz = novo DefaultMutableTreeNode("Root1");
DefaultMutableTreeNode filho1 = novo DefaultMutableTreeNode(" Filho1 ");
DefaultMutableTreeNode filho11 = novo DefaultMutableTreeNode(" Filho11 ");
DefaultMutableTreeNode filho111 = novo DefaultMutableTreeNode(
"Criança111");
raiz.add(filho1);
filho1.add(filho11);
filho11.add(filho111);
Modelo DefaultTreeModel = novo DefaultTreeModel (raiz);
jTree7 = novo JTree(modelo);
p = novo JPanel();
p.setLayout(new BoxLayout(p, BoxLayout.X_AXIS));
p.setPreferredSize(nova Dimensão(700, 400));
//JTree deve ser colocado em JScrollPane
p.add(novo JScrollPane(jTree1));
p.add(novo JScrollPane(jTree2));
p.add(novo JScrollPane(jTree3));
p.add(novo JScrollPane(jTree4));
p.add(novo JScrollPane(jTree5));
p.add(novo JScrollPane(jTree6));
p.add(novo JScrollPane(jTree7));
f.setContentPane(p);
f.pack();
f.setLocation(300, 200);
f.setVisible(verdadeiro);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
novo JTreeDemo2();
}
}
Captura de tela 2: