14ª LISTA DE EXERCÍCIOS

GUI + ARQUIVOS
Disciplina: PC-II

Exercício 1: Explorar e entender as estruturas de um programa que emprega

os seguintes elementos de interface gráfica: JTabbedPane (divisão da tela em
painéis) e JTable (para armazenar dados e opções selecionadas em campos
anteriores) em conjunto com a leitura de dados armazenados em arquivos
(através de JMenu). A descrição dos elementos e a aparência da interface são
ilustradas nas Figuras 1.1 e 1.2. Deve existir um arquivo CadastroEmpresa.txt
no mesmo diretório do programa.

Figura 1.1: Interface do programa proposto.

Figura 1.2: Interface do programa proposto.

Com o código da Figura 1.3 descobrir como a GUI gera as Figuras 1.1 e 1.2.

1 2
import java.awt.*; public void createContents()
import java.awt.event.*; {
import javax.swing.*; //---------------------------------------------------------------------//
import javax.swing.table.*; // CRIANDO JMENUS. //
import javax.swing.JScrollPane; //---------------------------------------------------------------------//
import javax.swing.JTable;
import java.io.*; barra = new JMenuBar(); // a barra de menus é um contêiner
import java.util.Scanner;
// Cria JMenu arquivo.
arqMenu = createJMenu1();
public class Exe31 extends JFrame // Anexa o arqMenu a Barra de Menus.
{ barra.add(arqMenu);
private JMenu arqMenu;
private JMenuItem abrirItem, salvarItem;
private JMenuBar barra; // Configura a barra de menus para o JFrame
private final int WIDTH = 500; // Largura da GUI. //--------------------------------------------------------------//
private final int HEIGHT = 550; // Altura da GUI. setJMenuBar(barra);
// Criando um JTabbedPane.
JTabbedPane tabPane = new JTabbedPane(); //---------------------------------------------------------------------//
JPanel p1;
// Criando uma JTable onde ficaram armazenadas as informacoes de relatorio.
JTable jtableEntrada; //---------------------------------------------------------------------//
// Criando um modelo de JTable a partir do qual podemos manipular os dados // CRIANDO JPANELS. //
// de JTable. //---------------------------------------------------------------------//
DefaultTableModel modeloEntrada;
// Itens para tratar a abertura e leitura dos dados de um arquivo texto. // Cria o panel com informacoes carregadas em arquivo.
File fileDir; // Diretorio ou arquivo especificado pelo usuário. p1 = createJPanel1();
int response; // resposta do usuario na GUI.
String output = ""; // lista de arquivos com tamanhos. // Adicionando o JTabbedPane a Janela.
JFileChooser chooser = new JFileChooser("."); tabPane.addTab("Dados do Arquivo",null,p1,"Dados carregados");
// Itens para abrir e ler conteudo de arquivos ou abrir e escrever dados. add(tabPane);
Scanner fileIn;
PrintWriter fileOut; //---------------------------------------------------------------------//
String line; }

//---------------------------------------------------------------------//
public Exe31() // CRIANDO JMENUS. //
{ //---------------------------------------------------------------------//
setTitle("Interfaces e Arquivos");
setSize(WIDTH,HEIGHT);
setDefaultCloseOperation(EXIT_ON_CLOSE); public JMenu createJMenu1()
setLocation(100,50); {
setResizable(false);
createContents(); // Metodo que adiciona componentes. //--------------------------------------------------------------//
setVisible(true); // Menu Arquivo
} //--------------------------------------------------------------//
arqMenu = new JMenu("Arquivo");
arqMenu.setMnemonic('A');

3 4
 abrirItem = new JMenuItem("Abrir..."); //---------------------------------------------------------------------//
abrirItem.setMnemonic('b'); // TRATAMENTO DE EVENTOS. //
abrirItem.addActionListener(new TrataArqMenu()); //---------------------------------------------------------------------//

// Adicionando itens ao JMenu arqMenu. //---------------------------------------------------------------------//

arqMenu.add(abrirItem); // TRATAMENTO DE EVENTOS DO MENU ARQUIVO. //
//---------------------------------------------------------------------//
// Retornando o arqMenu preenchido.
return arqMenu; private class TrataArqMenu implements ActionListener
//--------------------------------------------------------------// {
} public void actionPerformed(ActionEvent e)
{

private JPanel createJPanel1() //-----------------------------------------------------------------//

{ // Tratando eventos de abertura de arquivos e recuperacao de dados.
p1 = new JPanel(); //-----------------------------------------------------------------//
JLabel label2 = new JLabel("Tabela de Dados Recuperados"); if (e.getSource() == abrirItem)
p1.setBackground(Color.GREEN); {
// Abrindo painel grafico para escolha de arquivos
chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
// Construindo a JTable. response = chooser.showOpenDialog(null);
String[] colunas = new String[] {"Nome do Funcionário","Cargo","Salário"};
// Verificando se o usuario selecionou pressionou o botao Open.
Object[][] dados = new Object[][]{}; if (response == JFileChooser.APPROVE_OPTION)
{
// Ao inves de passar direto, colocamos os dados em um modelo fileDir = chooser.getSelectedFile();
modeloEntrada = new DefaultTableModel(dados, colunas);
// e passamos o modelo para criar a jtable. // Verificando se um arquivo foi selecionado.
jtableEntrada = new JTable( modeloEntrada ); if (fileDir.isFile())
{
// Colocando a tabela dentro de uma barra de rolagem,
// senão o cabecalho não ira aparecer. // Tenta abrir arquivo para leitura de dados.
JScrollPane jsp = new JScrollPane(jtableEntrada); try
jtableEntrada.setFillsViewportHeight(true); {
// Declaracao de variaveis a serem empregadas na
// Adicionando os elementos na interface. // leitura dos dados de um arquivo.
p1.setLayout(new BorderLayout()); String nome;
p1.add(label2,BorderLayout.NORTH); String cargo;
// Adicionando a barra de rolagem que contém a jtable. double salario;
p1.add(jsp,BorderLayout.CENTER);
return p1; fileIn = new Scanner(new FileReader(fileDir));
}
while (fileIn.hasNextLine())
{
// Leitura dos dados do arquivo.
line = fileIn.nextLine();
//---------------------------------------------------------------------// nome = line.substring(0,23);
cargo = line.substring(24,39);

5 6
 salario = Double.parseDouble(line.substring(39,49).trim());

// Colocando os dados na ultima linha da tabela de

// entrada de dados.
modeloEntrada.insertRow(jtableEntrada.getRowCount(),
new Object[] {new String(nome), new String(cargo),
new Double(salario)});
}
fileIn.close();
output = "Dados recuperados com sucesso !";

}
// Caso o arquivo nao tenha sido encontrado.
catch(FileNotFoundException ex)
{
JOptionPane.showMessageDialog(null, "Arquivo não encontrado!",
"File Sizes", JOptionPane.INFORMATION_MESSAGE);

// Verificando se um diretorio foi selecionado.

else if (fileDir.isDirectory())
{
output = "Diretório Selecionado. Selecione um arquivo";
} // end else.
// Caso em que nem um arquivo nem um diretorio foram selecionados.
else
{
output = "Escolha inválida. Não é diretório nem arquivo.";
}

JOptionPane.showMessageDialog(null, output,
"Recuperação de Dados",
JOptionPane.INFORMATION_MESSAGE);
}
}
} // FIM DO ACTIONPERFORMED.
} // FIM DA CLASSE TRATAARQMENU.

public static void main( String args[] )

{
Exe31 jt1 = new Exe31();
}

7 8
Exercício 2: Explorar e entender as estruturas de um programa que emprega import java.awt.*;
os seguintes elementos de interface gráfica: JTabbedPane (divisão da tela em import java.awt.event.*;
painéis) e JTable (para armazenar dados e opções selecionadas em campos import javax.swing.*;
anteriores) em conjunto com a gravação de dados em arquivos (através de import javax.swing.table.*;
JMenu). A descrição dos elementos e a aparência da interface são ilustradas na import javax.swing.JScrollPane;
Figura 2.1. Deve existir um arquivo CadastroEmpresa.txt no mesmo diretório do import javax.swing.JTable;
programa. O código para a GUI da Figura 2.1 está na Figura 2.2. import java.io.*;
import java.util.Scanner;

public class Exe32 extends JFrame

{
private JMenu arqMenu;
private JMenuItem abrirItem, salvarItem;
private JMenuBar barra;
private final int WIDTH = 500; // Largura da GUI.
private final int HEIGHT = 550; // Altura da GUI.
// Criando um JTabbedPane.
JTabbedPane tabPane = new JTabbedPane();
JPanel p1; // paineis para preencher os JTabbedPane().
// Criando uma JTable onde ficaram armazenadas as informacoes de relatorio.
JTable jtableEntrada;
// Criando um modelo de JTable a partir do qual podemos manipular os dados
// de JTable.
DefaultTableModel modeloEntrada;
// Itens para tratar a abertura e leitura dos dados de um arquivo texto.
File fileDir; // Diretorio ou arquivo especificado pelo usuário.
int response; // resposta do usuario na GUI.
String output = ""; // lista de arquivos com tamanhos.
JFileChooser chooser = new JFileChooser(".");
// Itens para abrir e ler conteudo de arquivos ou abrir e escrever dados.
Scanner fileIn;
PrintWriter fileOut;
String line;

public Exe32()
{
setTitle("Interfaces e Arquivos");
setSize(WIDTH,HEIGHT);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLocation(100,50);
setResizable(false);
createContents(); // Metodo que adiciona componentes.
setVisible(true);
}

Figura 2.1: Interface do programa proposto.

9 10
public void createContents() private JPanel createJPanel1()
{ {
//---------------------------------------------------------------------// p1 = new JPanel();
// CRIANDO JMENUS. // JLabel label2 = new JLabel("Tabela de Dados Recuperados");
//---------------------------------------------------------------------// p1.setBackground(Color.GREEN);
barra = new JMenuBar(); // a barra de menus é um contêiner
// Construindo a JTable.
// Cria JMenu arquivo. String[] colunas = new String[] {"Nome do
arqMenu = createJMenu1(); Funcionário","Cargo","Salário"};
// Anexa o arqMenu a Barra de Menus.
barra.add(arqMenu); // Preenchendo a JTable com elementos.
Object[][] dados = {
// Configura a barra de menus para o JFrame {new String("Joao Ninguem"),new String("Operador 1"), new
setJMenuBar(barra); Double(1600.0)},
//--------------------------------------------------------------// {new String("Jose Moleza"), new String("Gerente"), new
Double(6567.0)},
//---------------------------------------------------------------------// {new String("Tritao Forte"), new String("Operador 2"), new
// CRIANDO JPANELS. // Double(1900.0)},
//---------------------------------------------------------------------// {new String("Zoroastro da Silva"), new String("Operador 3"), new
// Cria o panel com informacoes carregadas em arquivo. Double(2400.0)}};
p1 = createJPanel1();
tabPane.addTab("Dados do Arquivo",null,p1,"Dados carregados"); // Ao inves de passar direto, colocamos os dados em um modelo
add(tabPane); modeloEntrada = new DefaultTableModel(dados, colunas);
// e passamos o modelo para criar a jtable.
//---------------------------------------------------------------------// jtableEntrada = new JTable( modeloEntrada );
}
// Colocando a tabela dentro de uma barra de rolagem,
//---------------------------------------------------------------------// // senão o cabecalho não ira aparecer.
// CRIANDO JMENUS. // JScrollPane jsp = new JScrollPane(jtableEntrada);
//---------------------------------------------------------------------// jtableEntrada.setFillsViewportHeight(true);
public JMenu createJMenu1()
{ // Adicionando os elementos na interface.
//--------------------------------------------------------------// p1.setLayout(new BorderLayout());
// Menu Arquivo p1.add(label2,BorderLayout.NORTH);
//--------------------------------------------------------------// // Adicionando a barra de rolagem que contém a jtable.
arqMenu = new JMenu("Arquivo"); p1.add(jsp,BorderLayout.CENTER);
arqMenu.setMnemonic('A'); return p1;
salvarItem = new JMenuItem("Salvar"); }
salvarItem.setMnemonic('S');
salvarItem.addActionListener(new TrataArqMenu()); //---------------------------------------------------------------------//
// TRATAMENTO DE EVENTOS. //
// Adicionando itens ao JMenu arqMenu. //---------------------------------------------------------------------//
arqMenu.add(salvarItem);
//---------------------------------------------------------------------//
// Retornando o arqMenu preenchido. // TRATAMENTO DE EVENTOS DO MENU ARQUIVO. //
return arqMenu; //---------------------------------------------------------------------//
}
//--------------------------------------------------------------//

11 12
private class TrataArqMenu implements ActionListener // Caso o arquivo nao tenha sido encontrado
{ catch (FileNotFoundException ex)
public void actionPerformed(ActionEvent e) {
{ output = "Arquivo não encontrado!";
}
//----------------------------------------------------------------------//
// Tratamento de evento para salvar informacoes em arquivo. JOptionPane.showMessageDialog(null, output,
//----------------------------------------------------------------------// "Recuperação de Dados",
if (e.getSource() == salvarItem) JOptionPane.INFORMATION_MESSAGE);
{ } // FIM DO IF.
// Abrindo painel grafico para escolha de arquivos
chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
response = chooser.showSaveDialog(null); } // FIM DO IF SalvarItem.
//----------------------------------------------------------------------//
// Verificando se o usuario selecionou pressionou o botao Open.
if (response == JFileChooser.APPROVE_OPTION) } // FIM DO ACTIONPERFORMED.
{ } // FIM DA CLASSE TRATAARQMENU.
fileDir = chooser.getSelectedFile();
// Criando o arquivo, se for possivel. //----------------------------------------------------------------------//
try //----------------------------------------------------------------------//
{ //----------------------------------------------------------------------//
fileOut = new PrintWriter(fileDir);
public static void main( String args[] )
// Declaracao de variaveis a serem empregadas na {
// leitura dos dados de um arquivo. Exe32 jt1 = new Exe32();
String value = ""; }

// Percorrendo a tabela e colocando seus elementos }

// em um arquivo.
for (int i=0; i < modeloEntrada.getRowCount(); i++)
{
for (int j=0; j < modeloEntrada.getColumnCount(); j++)
{
if (j == 0)
value = String.format("%24s",modeloEntrada.getValueAt(i,j));
else if (j == 1)
value+= String.format("%16s",modeloEntrada.getValueAt(i,j));
else if (j == 2)
value+= String.format("%10s",modeloEntrada.getValueAt(i,j));
}

// Salvando as informacoes em um arquivo.

fileOut.println(value);
}
fileOut.close();
output = "Dados salvos com sucesso !";

13 14
Exercício 3: Explorar e entender as estruturas de um programa que emprega
os seguintes elementos de interface gráfica: JTabbedPane (divisão da tela em
painéis) e JTable (para armazenar dados e opções selecionadas em campos
anteriores) tal que um JButton exporta informações de um JTable para outra. A
descrição dos elementos e a aparência da interface são ilustradas na Figura 3.1.
public class Exe33 extends JFrame
{
private final int WIDTH = 500; // Largura da GUI.
private final int HEIGHT = 550; // Altura da GUI.
// Criando um JTabbedPane.
JTabbedPane tabPane = new JTabbedPane();
JPanel p1, p2; // paineis para preencher os JTabbedPane().
// Criando uma JTable onde ficaram armazenadas as informacoes de relatorio.
JTable jtableEntrada, jtableSaida;
// Criando um modelo de JTable a partir do qual podemos manipular os dados
// de JTable.
DefaultTableModel modeloEntrada, modeloSaida;
// Botao exporta dados de uma JTable para outra: da Entrada para Saida.
JButton btnExp;

public Exe33()
{
setTitle("Interfaces e Arquivos");
setSize(WIDTH,HEIGHT);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLocation(100,50);
setResizable(false);
createContents(); // Metodo que adiciona componentes.
setVisible(true);
}

public void createContents()

{

//---------------------------------------------------------------------//
// CRIANDO JPANELS. //
//---------------------------------------------------------------------//
Figura 3.1: Comportamento das GUIs para o programa fornecido.
// Cria o panel com informacoes carregadas em arquivo.
O código para a GUI da Figura 3.1 está na Figura 3.2.
p1 = createJPanel1();

import java.awt.*; // Cria o panel com informacoes a serem gravada em arquivo.

import java.awt.event.*; p2 = createJPanel2();
import javax.swing.*;
import javax.swing.table.*; tabPane.addTab("Dados do Arquivo",null,p1,"Dados carregados");
import javax.swing.JScrollPane; tabPane.addTab("Dados da Interface",null,p2,"Dados a serem gravados");
import javax.swing.JTable; add(tabPane);
import java.io.*;
import java.util.Scanner; //---------------------------------------------------------------------//
}

15 16

private JPanel createJPanel1()
{ p2 = new JPanel();
p1 = new JPanel();
JLabel label2 = new JLabel("Tabela de Dados Recuperados");
p1.setBackground(Color.GREEN);
// Construindo a JTable.
String[] colunas = new String[] {"Nome do Funcionário","Cargo","Salário"};
Object[][] dados = {
{new String("Joao Ninguem"),new String("Operador 1"),
Double(1600.0)},
{new String("Jose Moleza"), new String("Gerente"),
Double(6567.0)},
{new String("Tritao Forte"), new String("Operador 2"),
Double(1900.0)},
{new String("Zoroastro da Silva"), new String("Operador 3"),
Double(2400.0)}};
// Ao inves de passar direto, colocamos os dados em um modelo
modeloEntrada = new DefaultTableModel(dados, colunas);
// e passamos o modelo para criar a jtable.
jtableEntrada = new JTable( modeloEntrada );
// Colocando a tabela dentro de uma barra de rolagem,
// senão o cabecalho não ira aparecer.
JScrollPane jsp = new JScrollPane(jtableEntrada);
jtableEntrada.setFillsViewportHeight(true);
// Criando botao para exportar dados para outra jtable.
btnExp = new JButton("Exportar");
btnExp.addActionListener(new TrataExportar());
// Adicionando os elementos na interface.
p1.setLayout(new BorderLayout());
p1.add(label2,BorderLayout.NORTH);
// Adicionando a barra de rolagem que contém a jtable.
p1.add(jsp,BorderLayout.CENTER);
// Adicionando botao para exportar dados de uma tabela para outra.
p1.add(btnExp,BorderLayout.SOUTH);
return p1;
} {
private JPanel createJPanel2()
{
JLabel label2 = new JLabel("Tabela de Gravação de Dados");
p2.setBackground(Color.YELLOW);
// Construindo a JTable.
String[] colunas = new String[] {"Nome do Funcionário","Cargo","Salário"};
Object[][] dados = new Object[][]{};
// Ao inves de passar direto, colocamos os dados em um modelo
modeloSaida = new DefaultTableModel(dados, colunas);
new // e passamos o modelo para criar a jtable.
jtableSaida = new JTable( modeloSaida );
new
// Colocando a tabela dentro de uma barra de rolagem,
new // senão o cabecalho não ira aparecer.
JScrollPane jsp = new JScrollPane(jtableSaida);
new jtableSaida.setFillsViewportHeight(true);
// Adicionando os elementos na interface.
p2.setLayout(new BorderLayout());
p2.add(label2,BorderLayout.NORTH);
p2.add(jsp,BorderLayout.CENTER);
return p2;
}
//---------------------------------------------------------------------//
// TRATAMENTO DE EVENTOS DO BOTAO EXPORTAR. //
//---------------------------------------------------------------------//
private class TrataExportar implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
int initi = 0;
// Verificando se ja existem elementos na tabela de saida de dados.
if (modeloSaida.getRowCount() > 0)
initi = modeloSaida.getRowCount();
// Copiar elementos de uma tabela para outra.
// Percorrendo a tabela e colocando seus elementos
// em um arquivo.
for (int i=0; i < modeloEntrada.getRowCount(); i++)
// Adicionando uma linha vazia na tabela de saida de dados.
17 18
 modeloSaida.insertRow(jtableSaida.getRowCount(),
new Object[] {new String(""), new String(""),
new Double(0.0)});

// Preenchendo a linha da tabela de saida com dados da

// tabela de entrada.
for (int j=0; j < modeloEntrada.getColumnCount(); j++)
{
// Colocando os dados na ultima linha da tabela de
// Saida de dados.
modeloSaida.setValueAt(modeloEntrada.getValueAt(i,j),initi+i,j);
}
}

JOptionPane.showMessageDialog(null, "Dados exportados com sucesso",

"Exportar Dados", JOptionPane.INFORMATION_MESSAGE);

// Mudando o foco para a segunda aba: dados exportados.

tabPane.setSelectedIndex(1);

}
}

//----------------------------------------------------------------------//
//----------------------------------------------------------------------//
//----------------------------------------------------------------------//

public static void main( String args[] )

{
Exe33 jt1 = new Exe33();
}

19 20
Exercício 4: Explorar e entender as estruturas de um programa que emprega import java.awt.*;
os seguintes elementos de interface gráfica: JTabbedPane (divisão da tela em import java.awt.event.*;
painéis) e JTable (para armazenar dados e opções selecionadas em campos import javax.swing.*;
anteriores) tal que dois JButtons incluem e removem informações de uma import javax.swing.table.*;
JTable. A descrição dos elementos e a aparência da interface são ilustradas na import javax.swing.JScrollPane;
Figura 4.1. import javax.swing.JTable;
import java.io.*;
import java.util.Scanner;

public class Exe34 extends JFrame

{
private JMenu arqMenu;
private JMenuItem abrirItem, salvarItem;
private JMenuBar barra;
private final int WIDTH = 500; // Largura da GUI.
private final int HEIGHT = 550; // Altura da GUI.
// Criando um JTabbedPane.
JTabbedPane tabPane = new JTabbedPane();
JPanel p2; // paineis para preencher os JTabbedPane().
// Criando uma JTable onde ficaram armazenadas as informacoes de relatorio.
JTable jtableSaida;
// Criando um modelo de JTable a partir do qual podemos manipular os dados
// de JTable.
DefaultTableModel modeloSaida;
// Botao de acao no JTable Saida: Adicionar ou Remover linhas.
JButton btnAddL, btnRmvL;

public Exe34()
{
setTitle("Interfaces e Arquivos");
setSize(WIDTH,HEIGHT);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLocation(100,50);
setResizable(false);
createContents(); // Metodo que adiciona componentes.
setVisible(true);
}

public void createContents()

Figura 4.1: Comportamento das GUIs para o programa fornecido. {
// CRIANDO JPANELS. //
O código para a GUI da Figura 4.1 está na Figura 4.2. // Cria o panel com informacoes a serem gravadas em arquivo.
p2 = createJPanel2();
tabPane.addTab("Dados da Interface",null,p2,"Dados a serem gravados");
add(tabPane);

//---------------------------------------------------------------------//
}

21 22
private JPanel createJPanel2() //---------------------------------------------------------------------//
{ // TRATAMENTO DE EVENTOS: //
p2 = new JPanel(); // BOTOES PARA ADICIONAR E REMOVER LINHAS. //
JLabel label2 = new JLabel("Tabela de Gravação de Dados"); //---------------------------------------------------------------------//
p2.setBackground(Color.YELLOW);
private class TrataLinha implements ActionListener
// Construindo a JTable. {
String[] colunas = new String[] {"Nome do Funcionário","Cargo","Salário"}; public void actionPerformed(ActionEvent e)
{
Object[][] dados = { // Obtendo qual linha da tabela foi selecionada.
{new String("Joao Ninguem"),new String("Operador 1"), new int rowIndex = jtableSaida.getSelectedRow();
Double(1600.0)},
{new String("Jose Moleza"), new String("Gerente"), new // Verificando se realmente uma coluna foi selecionada.
Double(6567.0)}, if (rowIndex != -1)
{new String("Tritao Forte"), new String("Operador 2"), new {
Double(1900.0)},
{new String("Zoroastro da Silva"), new String("Operador 3"), new // ADICIONANDO LINHAS NA TABELA.
Double(2400.0)}}; if (e.getSource() == btnAddL)
{
// Ao inves de passar direto, colocamos os dados em um modelo addRow(rowIndex);
modeloSaida = new DefaultTableModel(dados, colunas); }
// e passamos o modelo para criar a jtable.
jtableSaida = new JTable( modeloSaida ); // REMOVENDO AS LINHAS DA TABELA.
if (e.getSource() == btnRmvL)
// Colocando a tabela dentro de uma barra de rolagem, {
// senão o cabecalho não ira aparecer. removeRow(rowIndex);
JScrollPane jsp = new JScrollPane(jtableSaida); }
jtableSaida.setFillsViewportHeight(true);
}
// Criando os botoes para adicionar e remover colunas na JTable Saida. // Nenhuma linha foi selecionada !
btnAddL = new JButton("Adicionar Linhas"); else
btnRmvL = new JButton("Remover Linhas"); {
btnAddL.addActionListener(new TrataLinha()); // Verificando se eh porque todas linhas foram eliminadas.
btnRmvL.addActionListener(new TrataLinha()); if (modeloSaida.getRowCount() == 0)
// Adicionar linha na primeira linha da tabela.
// Adicionando os elementos na interface. addRow(0);
p2.setLayout(new BorderLayout()); }
p2.add(label2,BorderLayout.NORTH);
p2.add(jsp,BorderLayout.CENTER); }
JPanel p21 = new JPanel();
p21.setLayout(new FlowLayout()); // METODO ESPECIFICO PARA ADICIONAR LINHAS NA TABELA.
p21.add(btnAddL); public void addRow(int vColIndex)
p21.add(btnRmvL); {
p2.add(p21,BorderLayout.SOUTH); // Remove a linha da tabela sem nenhum conteúdo.
return p2; modeloSaida.insertRow(vColIndex, new Object[]{});
} // Atualiza as informacoes da tabela.
modeloSaida.fireTableStructureChanged();
}

23 24
 // METODO ESPECIFICO PARA REMOVER AS LINHAS DA TABELA.
public void removeRow(int vColIndex)
{
// Remove a linha da tabela.
modeloSaida.removeRow(vColIndex);
// Atualiza as informacoes da tabela.
modeloSaida.fireTableStructureChanged();
}

//---------------------------------------------------------------------//
//---------------------------------------------------------------------//
//---------------------------------------------------------------------//

public static void main( String args[] )

{
Exe34 jt1 = new Exe34();
}

25 26
Exercício 5: Explorar e entender as estruturas de um programa que emprega import java.awt.*;
os seguintes elementos de interface gráfica: JTabbedPane (divisão da tela em import java.awt.event.*;
painéis) e JTable (para armazenar dados e opções selecionadas em campos import javax.swing.*;
anteriores) tal que um JButton armazena os dados em um arquivo HTML. A import javax.swing.table.*;
descrição dos elementos e a aparência da interface são ilustradas na Figura 5.1. import javax.swing.JScrollPane;
import javax.swing.JTable;
import java.io.*;
import java.util.Scanner;

public class Exe35 extends JFrame

{
private final int WIDTH = 500; // Largura da GUI.
private final int HEIGHT = 550; // Altura da GUI.
// Criando um JTabbedPane.
JTabbedPane tabPane = new JTabbedPane();
JPanel p2; // paineis para preencher os JTabbedPane().
// Criando uma JTable onde ficaram armazenadas as informacoes de relatorio.
JTable jtableSaida;
// Criando um modelo de JTable a partir do qual podemos manipular os dados
// de JTable.
DefaultTableModel modeloSaida;
// Botao de acao no JTable Saida: Salvar em arquivo html.
JButton btnHtml;
// Itens para tratar a abertura e leitura dos dados de um arquivo texto.
File fileDir; // Diretorio ou arquivo especificado pelo usuário.
int response; // resposta do usuario na GUI.
String output = ""; // lista de arquivos com tamanhos.
JFileChooser chooser = new JFileChooser(".");
// Itens para abrir e ler conteudo de arquivos ou abrir e escrever dados.
Scanner fileIn;
PrintWriter fileOut;
String line;

public Exe35()
{
setTitle("Interfaces e Arquivos");
setSize(WIDTH,HEIGHT);
Figura 5.1: Comportamento das GUIs para o programa fornecido. setDefaultCloseOperation(EXIT_ON_CLOSE);
setLocation(100,50);
O código para a GUI da Figura 5.1 está na Figura 5.2. setResizable(false);
createContents(); // Metodo que adiciona componentes.
setVisible(true);
}

27 28
 public void createContents() //-----------------------------------------------------------------------------------------//
{// Cria o panel com informacoes a serem gravada em arquivo. // TRATAMENTO DE EVENTOS DO BOTAO: DADOS DE TABELA EM HTML. //
p2 = createJPanel2(); //-----------------------------------------------------------------------------------------//
tabPane.addTab("Dados da Interface",null,p2,"Dados a serem gravados"); private class TrataHtml implements ActionListener
add(tabPane); } {

private JPanel createJPanel2() public void actionPerformed(ActionEvent e)

{ {
p2 = new JPanel(); // Passando a informacao contida na Tabela para um arquivo HTML.
JLabel label2 = new JLabel("Tabela de Gravação de Dados"); // Criando o arquivo, se for possivel.
p2.setBackground(Color.YELLOW); try
{
// Construindo a JTable. String fileNameOut = "Tabela2.htm";
String[] colunas = new String[] {"Nome do Funcionário","Cargo","Salário"}; PrintWriter fileOut = new PrintWriter(fileNameOut);
Object[][] dados = {
{new String("Joao Ninguem"),new String("Operador 1"), new // Construindo o cabecalho do arquivo HTML.
Double(1600.0)}, // Inclusao de "tags" que permitem a inclusao do
{new String("Jose Moleza"), new String("Gerente"), new // conteudo no arquivo.
Double(6567.0)}, //-------------------------------------------------------------//
{new String("Tritao Forte"), new String("Operador 2"), new fileOut.println("<html>");
Double(1900.0)}, fileOut.println("<head>");
{new String("Zoroastro da Silva"), new String("Operador 3"), new fileOut.println("<title>" + " Arquivo HTML");
Double(2400.0)}}; fileOut.println("</head>");
// Comeco do corpo do html:
// Ao inves de passar direto, colocamos os dados em um modelo //onde serao colocadas as informacoes da tabela.
modeloSaida = new DefaultTableModel(dados, colunas); fileOut.println("<body>");
// e passamos o modelo para criar a jtable. fileOut.println("<h1>Dados da Tabela</h1>");
jtableSaida = new JTable( modeloSaida ); //-------------------------------------------------------------//

// Colocando a tabela dentro de uma barra de rolagem, //------------------------------------------------------------------//

// senão o cabecalho não ira aparecer. // "Tag" adicional para imprimir os dados em formato Tabela de HTML.
JScrollPane jsp = new JScrollPane(jtableSaida); //------------------------------------------------------------------//
jtableSaida.setFillsViewportHeight(true); fileOut.println("<table>");
// Legenda da Tabela.
// Criando os botoes para salvar o conteudo da JTable em um arquivo HTML. fileOut.println("<caption>"+"Tabela com os dados de
btnHtml = new JButton("Arquivo HTML"); saida."+"</caption>");
btnHtml.addActionListener(new TrataHtml());
// Inicio da tabela.
// Adicionando os elementos na interface. fileOut.println("<tr>");
p2.setLayout(new BorderLayout()); // Inserindo celula vazia para alinhar cabecalho das colunas.
p2.add(label2,BorderLayout.NORTH); fileOut.println("<td> </td>");
p2.add(jsp,BorderLayout.CENTER); // Cabecalho de cada coluna da tabela html.
JPanel p21 = new JPanel(); for (int j=0; j < modeloSaida.getColumnCount(); j++)
p21.setLayout(new FlowLayout()); {
p21.add(btnHtml); fileOut.println("<th> Coluna "+(j+1)+"</th>");
p2.add(p21,BorderLayout.SOUTH); }
return p2; fileOut.println("</tr>");
} //-------------------------------------------------------------//

29 30
 JOptionPane.showMessageDialog(null, output,
// Declaracao de variaveis a serem empregadas na "Gravar Dados em HTML",
// leitura dos dados de um arquivo. JOptionPane.INFORMATION_MESSAGE);
String value = ""; }

// Percorrendo a tabela e colocando seus elementos }

// em um arquivo.
for (int i=0; i < modeloSaida.getRowCount(); i++) //---------------------------------------------------------------------//
{ //---------------------------------------------------------------------//
fileOut.println("<tr>"); // Comeca uma linha da tabela html. //---------------------------------------------------------------------//
// Comeca o cabecalho da linha da tabela html.
fileOut.println("<th> Linha "+(i+1)+"</th>");
for (int j=0; j < modeloSaida.getColumnCount(); j++) public static void main( String args[] )
{ {
if (j == 0) Exe35 jt1 = new Exe35();
value = String.format("%24s",modeloSaida.getValueAt(i,j)); }
else if (j == 1)
value = String.format("%16s",modeloSaida.getValueAt(i,j)); }
else if (j == 2)
value = String.format("%10s",modeloSaida.getValueAt(i,j));

// Salvando as informacoes no arquivo html.

fileOut.println("<td>"+value+"</td>");
}
fileOut.println("</tr>"); // termina uma linha da tabela html.

}
// Apos imprimir todos os dados, fechar a "tag" table do html.
fileOut.println("/<table>");

// Codigo necessario para terminar o arquivo HTML.

fileOut.println("</body>");
fileOut.println("</html>");
//-------------------------------------------------------------//

fileOut.close();
// Mensagem para o usuario saber se o arquivo foi gravado.
output = "Dados salvos com sucesso !";

}
// Caso o arquivo nao tenha sido encontrado
catch (FileNotFoundException ex)
{
// Mensagem caso o arquivo nao possa ter sido criado.
output = "Não foi possivel criar o arquivo!";
}

31 32
Exercício 6: Reunir todos os elementos de interface gráfica (JMenus, JTable, import java.awt.*;
JTabbedPane e JButton) e suas respectivas funcionalidades em único programa import java.awt.event.*;
tal como descrito nas Figura 6.1 e 6.2. import javax.swing.*;
import javax.swing.table.*;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import java.io.*;
import java.util.Scanner;

public class Exe3 extends JFrame

{
private JMenu arqMenu;
private JMenuItem abrirItem, salvarItem;
private JMenuBar barra;
private final int WIDTH = 500; // Largura da GUI.
private final int HEIGHT = 550; // Altura da GUI.
// Criando um JTabbedPane.
JTabbedPane tabPane = new JTabbedPane();
JPanel p1, p2; // paineis para preencher os JTabbedPane().
// Criando uma JTable onde ficaram armazenadas as informacoes de relatorio.
JTable jtableEntrada, jtableSaida;
// Criando um modelo de JTable a partir do qual podemos manipular os dados
// de JTable.
DefaultTableModel modeloEntrada, modeloSaida;
// Botao para exportar dados de uma JTable para outra: da Entrada para
Saida.
JButton btnExp;
// Botao de acao no JTable Saida: Adicionar ou Remover linhas com
informacoes.
Figura 6.1: Componentes GUIs para o programa fornecido. JButton btnAddL, btnRmvL;
// Botao de acao no JTable Saida: Salvar em arquivo html.
JButton btnHtml;
// Itens para tratar a abertura e leitura dos dados de um arquivo texto.
File fileDir; // Diretorio ou arquivo especificado pelo usuário.
int response; // resposta do usuario na GUI.
String output = ""; // lista de arquivos com tamanhos.
JFileChooser chooser = new JFileChooser(".");
// Itens para abrir e ler conteudo de arquivos ou abrir e escrever dados.
Scanner fileIn;
PrintWriter fileOut;
String line;

public Exe3()
{
setTitle("Interfaces e Arquivos");
setSize(WIDTH,HEIGHT);

33 34
 setDefaultCloseOperation(EXIT_ON_CLOSE);
setLocation(100,50); //---------------------------------------------------------------------//
setResizable(false); // CRIANDO JMENUS. //
createContents(); // Metodo que adiciona componentes. //---------------------------------------------------------------------//
setVisible(true);
}
public JMenu createJMenu1()
public void createContents() {
{

//---------------------------------------------------------------------// //--------------------------------------------------------------//
// CRIANDO JMENUS. // // Menu Arquivo
//---------------------------------------------------------------------// //--------------------------------------------------------------//
arqMenu = new JMenu("Arquivo");
barra = new JMenuBar(); // a barra de menus é um contêiner arqMenu.setMnemonic('A');
abrirItem = new JMenuItem("Abrir...");
// Cria JMenu arquivo. abrirItem.setMnemonic('b');
arqMenu = createJMenu1(); abrirItem.addActionListener(new TrataArqMenu());
// Anexa o arqMenu a Barra de Menus. salvarItem = new JMenuItem("Salvar");
barra.add(arqMenu); salvarItem.setMnemonic('S');
salvarItem.addActionListener(new TrataArqMenu());

// Configura a barra de menus para o JFrame // Adicionando itens ao JMenu arqMenu.

//--------------------------------------------------------------// arqMenu.add(abrirItem);
setJMenuBar(barra); arqMenu.add(salvarItem);

// Retornando o arqMenu preenchido.

//---------------------------------------------------------------------// return arqMenu;
//--------------------------------------------------------------//
}
//---------------------------------------------------------------------//
// CRIANDO JPANELS. //
//---------------------------------------------------------------------// private JPanel createJPanel1()
{
// Cria o panel com informacoes carregadas em arquivo. p1 = new JPanel();
p1 = createJPanel1(); JLabel label2 = new JLabel("Tabela de Dados Recuperados");
p1.setBackground(Color.GREEN);
// Cria o panel com informacoes a serem gravada em arquivo.
p2 = createJPanel2();
// Construindo a JTable.
tabPane.addTab("Dados do Arquivo",null,p1,"Dados carregados"); String[] colunas = new String[] {"Nome do Funcionário","Cargo","Salário"};
tabPane.addTab("Dados da Interface",null,p2,"Dados a serem
gravados");
add(tabPane); Object[][] dados = new Object[][]{};

//---------------------------------------------------------------------//
} // Ao inves de passar direto, colocamos os dados em um modelo
modeloEntrada = new DefaultTableModel(dados, colunas);

35 36
 // e passamos o modelo para criar a jtable.
jtableEntrada = new JTable( modeloEntrada );
//jtableEntrada.setAutoCreateRowSorter(true);
//Insert last position
//modeloEntrada.insertRow(jtableEntrada.getRowCount(),new
Object[]{"Sushil",new Boolean(true), new Double(120.0)});
// Colocando a tabela dentro de uma barra de rolagem,
// senão o cabecalho não ira aparecer.
JScrollPane jsp = new JScrollPane(jtableEntrada);
jtableEntrada.setFillsViewportHeight(true);
// Criando botao para exportar dados para outra jtable.
btnExp = new JButton("Exportar");
btnExp.addActionListener(new TrataExportar());
// Adicionando os elementos na interface.
p1.setLayout(new BorderLayout());
p1.add(label2,BorderLayout.NORTH);
// Adicionando a barra de rolagem que contém a jtable.
p1.add(jsp,BorderLayout.CENTER);
// Adicionando botao para exportar dados de uma tabela para outra.
p1.add(btnExp,BorderLayout.SOUTH);
return p1;
}
private JPanel createJPanel2()
{ // TRATAMENTO DE EVENTOS.
p2 = new JPanel();
JLabel label2 = new JLabel("Tabela de Gravação de Dados");
p2.setBackground(Color.YELLOW);
// Construindo a JTable.
String[] colunas = new String[] {"Nome do Funcionário","Cargo","Salário"};
Object[][] dados = new Object[][]{};
// Ao inves de passar direto, colocamos os dados em um modelo
modeloSaida = new DefaultTableModel(dados, colunas);
// e passamos o modelo para criar a jtable
jtableSaida = new JTable( modeloSaida );
// Colocando a tabela dentro de uma barra de rolagem,
// senão o cabecalho não ira aparecer.
37
JScrollPane jsp = new JScrollPane(jtableSaida);
jtableSaida.setFillsViewportHeight(true);
// Criando os botoes para adicionar e remover colunas na JTable Saida.
// Ou ainda, salvar o conteudo da JTable em um arquivo HTML.
btnAddL = new JButton("Adicionar Linhas");
btnRmvL = new JButton("Remover Linhas");
btnHtml = new JButton("Arquivo HTML");
btnAddL.addActionListener(new TrataLinha());
btnRmvL.addActionListener(new TrataLinha());
btnHtml.addActionListener(new TrataHtml());
// Adicionando os elementos na interface.
p2.setLayout(new BorderLayout());
p2.add(label2,BorderLayout.NORTH);
p2.add(jsp,BorderLayout.CENTER);
JPanel p21 = new JPanel();
p21.setLayout(new FlowLayout());
p21.add(btnAddL);
p21.add(btnRmvL);
p21.add(btnHtml);
p2.add(p21,BorderLayout.SOUTH);
return p2;
}
//---------------------------------------------------------------------//
//---------------------------------------------------------------------//
//
//---------------------------------------------------------------------//
//---------------------------------------------------------------------//
// TRATAMENTO DE EVENTOS DO MENU ARQUIVO. //
//---------------------------------------------------------------------//
private class TrataArqMenu implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
//-----------------------------------------------------------------//
// Tratando eventos de abertura de arquivos e recuperacao de dados.
//-----------------------------------------------------------------//
if (e.getSource() == abrirItem)
{
38
 // Abrindo painel grafico para escolha de arquivos }
// Caso o arquivo nao tenha sido encontrado
chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES); catch(FileNotFoundException ex)
response = chooser.showOpenDialog(null); {
JOptionPane.showMessageDialog(null, "Arquivo não
// Verificando se o usuario selecionou pressionou o botao Open. encontrado!",
if (response == JFileChooser.APPROVE_OPTION) "File Sizes", JOptionPane.INFORMATION_MESSAGE);
{
fileDir = chooser.getSelectedFile(); }

// Verificando se um arquivo foi selecionado. }

if (fileDir.isFile())
{ // Verificando se um diretorio foi selecionado.
//output += String.format("%-25s%12s%n", else if (fileDir.isDirectory())
//fileDir.getName(), fileDir.length() + "bytes"); {
output = "Diretório Selecionado. Selecione um
// Tenta abrir arquivo para leitura de dados. arquivo";
try
{ } // end else.
// Declaracao de variaveis a serem empregadas na
// leitura dos dados de um arquivo. // Caso em que nem um arquivo nem um diretorio foram
String nome; selecionados.
String cargo; else
double salario; {
output = "Escolha inválida. Não é diretório nem
fileIn = new Scanner(new FileReader(fileDir)); arquivo.";
}
while (fileIn.hasNextLine())
{ JOptionPane.showMessageDialog(null, output,
// Leitura dos dados do arquivo. "Recuperação de Dados",
line = fileIn.nextLine(); JOptionPane.INFORMATION_MESSAGE);
}
nome = line.substring(0,23);
cargo = line.substring(24,39); }
salario =
Double.parseDouble(line.substring(39,49).trim());
//----------------------------------------------------------------------//
// Colocando os dados na ultima linha da tabela de // Tratamento de evento para salvar informacoes em arquivo.
// entrada de dados. //----------------------------------------------------------------------//
modeloEntrada.insertRow(jtableEntrada.getRowCount(), else if (e.getSource() == salvarItem)
new Object[] {new String(nome), new String(cargo), {
new Double(salario)}); // Abrindo painel grafico para escolha de arquivos
chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
} response = chooser.showSaveDialog(null);
fileIn.close();
output = "Dados recuperados com sucesso !"; // Verificando se o usuario selecionou pressionou o botao Open.
if (response == JFileChooser.APPROVE_OPTION)

39 40
 {
fileDir = chooser.getSelectedFile(); }
// Criando o arquivo, se for possivel. //----------------------------------------------------------------------//
try
{ } // FIM DO ACTIONPERFORMED.
fileOut = new PrintWriter(fileDir); } // FIM DA CLASSE TRATAARQMENU.

// Declaracao de variaveis a serem empregadas na //----------------------------------------------------------------------//

// leitura dos dados de um arquivo. //----------------------------------------------------------------------//
String value = ""; //----------------------------------------------------------------------//

// Percorrendo a tabela e colocando seus elementos

// em um arquivo. //---------------------------------------------------------------------//
for (int i=0; i < modeloEntrada.getRowCount(); i++) // TRATAMENTO DE EVENTOS DO BOTAO EXPORTAR. //
{ //---------------------------------------------------------------------//
for (int j=0; j < modeloEntrada.getColumnCount();
j++) private class TrataExportar implements ActionListener
{ {
if (j == 0) public void actionPerformed(ActionEvent e)
value = String.format("%24s",modeloEntrada.getValueAt(i,j)); {
else if (j == 1) int initi = 0;
value += // Verificando se ja existem elementos na tabela de saida de dados.
String.format("%16s",modeloEntrada.getValueAt(i,j)); if (modeloSaida.getRowCount() > 0)
else if (j == 2) initi = modeloSaida.getRowCount();
value +=
String.format("%10s",modeloEntrada.getValueAt(i,j)); // Copiar elementos de uma tabela para outra.
} // Percorrendo a tabela e colocando seus elementos
// em um arquivo.
// Salvando as informacoes em um arquivo. for (int i=0; i < modeloEntrada.getRowCount(); i++)
fileOut.println(value); {
} // Adicionando uma linha vazia na tabela de saida de dados.
fileOut.close(); modeloSaida.insertRow(jtableSaida.getRowCount(),
output = "Dados salvos com sucesso !"; new Object[] {new String(""), new String(""),
new Double(0.0)});
}
// Caso o arquivo nao tenha sido encontrado // Preenchendo a linha da tabela de saida com dados da
catch(FileNotFoundException ex) // tabela de entrada.
{ for (int j=0; j < modeloEntrada.getColumnCount(); j++)
output = "Arquivo não encontrado!"; {
// Colocando os dados na ultima linha da tabela de
} // Saida de dados.
modeloSaida.setValueAt(modeloEntrada.getValueAt(i,j),initi+i,j);
JOptionPane.showMessageDialog(null, output, }
"Recuperação de Dados", }
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(null, "Dados exportados com sucesso",
} // FIM DO IF. "Exportar Dados", JOptionPane.INFORMATION_MESSAGE);

41 42
 // Mudando o foco para a segunda aba: dados exportados. }
tabPane.setSelectedIndex(1);

} }
}
// METODO ESPECIFICO PARA ADICIONAR LINHAS NA TABELA.
//----------------------------------------------------------------------// public void addRow(int vColIndex)
//----------------------------------------------------------------------// {
//----------------------------------------------------------------------// // Remove a linha da tabela sem nenhum conteúdo.
modeloSaida.insertRow(vColIndex, new Object[]{});
// Atualiza as informacoes da tabela.
//---------------------------------------------------------------------// modeloSaida.fireTableStructureChanged();
// TRATAMENTO DE EVENTOS DO BOTOES PARA ADICIONAR E REMOVER }
LINHAS. //
//---------------------------------------------------------------------// // METODO ESPECIFICO PARA REMOVER AS LINHAS DA TABELA.
public void removeRow(int vColIndex)
private class TrataLinha implements ActionListener {
{ // Remove a linha da tabela.
modeloSaida.removeRow(vColIndex);
public void actionPerformed(ActionEvent e) // Atualiza as informacoes da tabela.
{ modeloSaida.fireTableStructureChanged();
// Obtendo qual linha da tabela foi selecionada. }
int rowIndex = jtableSaida.getSelectedRow();
}
// Verificando se realmente uma coluna foi selecionada.
if (rowIndex != -1) //---------------------------------------------------------------------//
{ //---------------------------------------------------------------------//
//---------------------------------------------------------------------//
// ADICIONANDO LINHAS NA TABELA.
if (e.getSource() == btnAddL)
{ //---------------------------------------------------------------------//
addRow(rowIndex); // TRATAMENTO DE EVENTOS DO BOTOES PARA SALVAR DADOS DE TABELA
} EM HTML.//
//---------------------------------------------------------------------//
// REMOVENDO AS LINHAS DA TABELA.
if (e.getSource() == btnRmvL) private class TrataHtml implements ActionListener
{ {
removeRow(rowIndex);
} public void actionPerformed(ActionEvent e)
{
} // Passando a informacao contida na Tabela para um arquivo HTML.
// Nenhuma coluna foi selecionada ! // Criando o arquivo, se for possivel.
else try
{ {
// Verificando se eh porque todas linhas foram eliminadas. String fileNameOut = "Tabela2.htm";
if (modeloSaida.getRowCount() == 0) PrintWriter fileOut = new PrintWriter(fileNameOut);
// Adicionar linha na primeira linha da tabela.
addRow(0); // Construindo o cabecalho do arquivo HTML.

43 44
 // Inclusao de "tags" que permitem a inclusao do for (int j=0; j < modeloSaida.getColumnCount(); j++)
// conteudo no arquivo. {
//-------------------------------------------------------------// if (j == 0)
fileOut.println("<html>"); value = String.format("%24s",modeloSaida.getValueAt(i,j));
fileOut.println("<head>"); else if (j == 1)
fileOut.println("<title>" + " Arquivo HTML"); value = String.format("%16s",modeloSaida.getValueAt(i,j));
fileOut.println("</head>"); else if (j == 2)
// Comeco do corpo do html: onde serao colocadas as value = String.format("%10s",modeloSaida.getValueAt(i,j));
informacoes da tabela.
fileOut.println("<body>"); // Salvando as informacoes no arquivo html.
fileOut.println("<h1>Dados da Tabela</h1>"); fileOut.println("<td>"+value+"</td>");
//-------------------------------------------------------------// }
fileOut.println("</tr>"); // termina uma linha da tabela html.

//------------------------------------------------------------------// }
// "Tag" adicional para imprimir os dados em formato
Tabela de HTML. // Apos imprimir todos os dados, fechar a "tag" table do
//------------------------------------------------------------------// html.
fileOut.println("<table>"); fileOut.println("<table>");
// Legenda da Tabela.
fileOut.println("<caption>"+"Tabela com os dados de // Codigo necessario para terminar o arquivo HTML.
saida."+"</caption>"); fileOut.println("</body>");
fileOut.println("</html>");
// Inicio da tabela. //-------------------------------------------------------------//
fileOut.println("<tr>");
// Inserindo celula vazia para alinhar cabecalho das
colunas. fileOut.close();
fileOut.println("<td> </td>");
// Cabecalho de cada coluna da tabela html. // Mensagem para o usuario saber se o arquivo foi
for (int j=0; j < modeloSaida.getColumnCount(); j++) gravado.
{ output = "Dados salvos com sucesso !";
fileOut.println("<th> Coluna "+(j+1)+"</th>");
} }
fileOut.println("</tr>"); // Caso o arquivo nao tenha sido encontrado
//-------------------------------------------------------------// catch(FileNotFoundException ex)
{
// Declaracao de variaveis a serem empregadas na // Mensagem caso o arquivo nao possa ter sido criado.
// leitura dos dados de um arquivo. output = "Não foi possivel criar o arquivo!";
String value = "";
}
// Percorrendo a tabela e colocando seus elementos
// em um arquivo. JOptionPane.showMessageDialog(null, output,
for (int i=0; i < modeloSaida.getRowCount(); i++) "Gravar Dados em HTML",
{ JOptionPane.INFORMATION_MESSAGE);
fileOut.println("<tr>"); // Comeca uma linha da tabela
html.
fileOut.println("<th> Linha "+(i+1)+"</th>"); //
Comeca o cabecalho da linha da tabela html. }

45 46
 }

//---------------------------------------------------------------------//
//---------------------------------------------------------------------//
//---------------------------------------------------------------------//

public static void main( String args[] )

{
Exe3 jt1 = new Exe3();
}

47 48
Exercício 7: Explorar e entender as estruturas de um programa que emprega import java.awt.*;
os seguintes elementos de interface gráfica: JTabbedPane (divisão da tela em import java.awt.event.*;
painéis), JTable (para armazenar dados e opções selecionadas em campos import javax.swing.*;
anteriores), JTree (árvore com opções pré-definidas) e um JButton tal que import javax.swing.tree.*;
seleciona opções dadas na JTree. A descrição dos elementos e a aparência da import javax.swing.event.*;
interface são ilustradas na Figura 7.1. import javax.swing.table.*;

public class Exe4 extends JFrame implements TreeSelectionListener,

ActionListener
{
// Criando um JTabbedPane.
JTabbedPane tabPane = new JTabbedPane();
JPanel p1, p2;
JTextField currentSelectionField;
// Criando um JTree.
JTree arvore;
// Criando JTextField para colocar em p2.
JTextField f[] = new JTextField[5];
//---------------------------------------------//
// Criando a árvore e seus respectivos nós.
// Nó raiz.
DefaultMutableTreeNode pais = new DefaultMutableTreeNode("Brasil");
// Criando os nós secundários.
// Nomes das regioes a serem usadas na criacao de cada no de regiao.
String nomesR[] = {"Norte", "Nordeste", "Centro-Oeste", "Sudeste", "Sul"};
// Matriz de nomes dos estados a ser usado em conjunto com o vetor de
nomes das regioes.
String estadosR0[] = { "Acre", "Amazonas", "Amapa", "Para", "Roraima",
"Rondonia"};
String estadosR1[] = {"Alagoas", "Bahia", "Ceará", "Maranhão", "Piaui",
"Pernanbuco", "Rio Grande do Norte"};
String estadosR2[] = {"Goias", "Mato Grosso", "Mato Grosso do Sul",
"Tocantins","Distrito Federal"};
String estadosR3[] = {"Espirito Santo", "Minas Gerais", "Rio de Janeiro", "São
Paulo"};
String estadosR4[] = {"Paraná", "Rio Grande do Sul", "Santa Catarina"};
Figura 7.1: Comportamento das GUIs para o programa fornecido.
// Vetor de nós das regiões.
O código para a GUI da Figura 7.1 está na Figura 7.2.
DefaultMutableTreeNode regiao[] = new
DefaultMutableTreeNode[nomesR.length];
// Vetor de nós dos estados.
DefaultMutableTreeNode estados[] = new DefaultMutableTreeNode[30];
// Numero de estados para cada regiao.
int nestados[] = {6, 7, 5, 4, 3};
// Botao de acao para selecionar regiao e estado e outro para gerar relatorio.
JButton botao1, botao2;
// Variavel que conta o numero de itens selecionados da arvore.

49 50
 int number = 0;
// Criando uma JTable onde ficaram armazenadas as informacoes de // Criacao efetiva dos nós com os nomes contidos em nomesR.
relatorio. regiao[i] = new DefaultMutableTreeNode(nomesR[i]);
JTable jtable; // Adicionando os nós secundários ao nó raiz.
// Criando um modelo de JTable a partir do qual podemos manipular os pais.add(regiao[i]);
dados
// de JTable. // Criacao efetiva dos nós com os nomes contidos em estados.
DefaultTableModel modelo; for (int j=0; j < nestados[i]; j++)
{
if (i == 0)
// Configura a GUI // Criacao efetiva dos nós com os nomes contidos em nomesR.
public Exe4() estados[k] = new DefaultMutableTreeNode(estadosR0[j]);
{ if (i == 1)
setTitle("Guia de Turismo"); // Criacao efetiva dos nós com os nomes contidos em nomesR.
setSize(600,400); estados[k] = new DefaultMutableTreeNode(estadosR1[j]);
setLocation(100,50); if (i == 2)
setResizable(false); // Criacao efetiva dos nós com os nomes contidos em nomesR.
createContents(); estados[k] = new DefaultMutableTreeNode(estadosR2[j]);
setVisible(true); if (i == 3)
} // Criacao efetiva dos nós com os nomes contidos em nomesR.
estados[k] = new DefaultMutableTreeNode(estadosR3[j]);
public void createContents() if (i == 4)
{ // Criacao efetiva dos nós com os nomes contidos em nomesR.
// Cria o panel a ser mostrado na primeira aba: "Dados do Brasil". estados[k] = new DefaultMutableTreeNode(estadosR4[j]);
p1 = createJPanel1();
// Adicionando eventos nas opces de estado da arvore.
// Cria o panel a ser mostrado na segunda aba: "Relatorio". // estados[k].addActionListener(new TrataEstado());
p2 = createJPanel2();
// Adicionando estados[i] em cada regiao[i].
tabPane.addTab("Dados do Brasil",null,p1,"Dados turísticos"); regiao[i].add(estados[k]);
tabPane.addTab("Relatório",null,p2,"Tabela de Precos dos lugares");
add(tabPane); // Criando mais um elemento no vetor estados[k].
} k++;
}

private JPanel createJPanel1() }

{
p1 = new JPanel();
// Criando os elementos gráficos.
// Texto de legenda. // Definindo com inserir os elementos graficos na interface grafica.
JLabel label1 = new JLabel("Lugares Turísticos"); p1.setLayout(new BorderLayout());
currentSelectionField = new JTextField("Current Selection: NONE"); p1.add(label1,BorderLayout.NORTH);
arvore = new JTree(pais);
int k = 0; // Listen for when the selection changes.
// Laco para efetivar a construcao do vetor de regioes. arvore.addTreeSelectionListener(this);
for (int i = 0; i < nomesR.length; i++)
{
// Adicionando a arvore ao primeiro JPanel.

51 52
 p1.add(new JScrollPane(arvore),BorderLayout.CENTER); // Evento no qual o botão de seleção de estado/região foi
// Adicionando o texto de quem foi selecionado. pressionado.
p1.add(currentSelectionField,BorderLayout.SOUTH); if (e.getSource() == botao1)
// Adicionando botao que fornece o nome do estado ou {
// da regiao que sera incluido no JTabedPanel seguinte.
botao1 = new JButton("Selecionar"); String nomeitem =
// Adicao de evento no botao. arvore.getLastSelectedPathComponent().toString();
botao1.addActionListener(this);
p1.add(botao1,BorderLayout.EAST); modelo.insertRow(jtable.getRowCount(),new Object[]{nomeitem,new
p1.setBackground(Color.white); Boolean(true), new Double(120.0)});
return p1;
} }
// Evento no qual o botão de seleção de gerar relatório foi pressionado.
if (e.getSource() == botao2)
{
private JPanel createJPanel2() }
{
p2 = new JPanel();
JLabel label2 = new JLabel("Tabela de Avaliação"); }
p2.setBackground(Color.LIGHT_GRAY);

public void valueChanged(TreeSelectionEvent e)

// Construindo a JTable. {
String[] colunas = new String []{"Região/Estado","Confirmado","Preço"};

String nomeitem = arvore.getLastSelectedPathComponent().toString();

currentSelectionField.setText("Seleção atual:"+
//Object[][] dados = {{new String(""), new Boolean(true), new nomeitem);
Double(500.0)}};
Object[][] dados = new Object[][]{}; }

// Ao inves de passar direto, colocamos os dados em um modelo

modelo = new DefaultTableModel(dados, colunas); public static void main( String args[] )
// e passamos o modelo para criar a jtable {
jtable = new JTable( modelo ); Exe4 jt1 = new Exe4();
}

p2.setLayout(new BorderLayout());
p2.add(label2,BorderLayout.NORTH);
p2.add(jtable,BorderLayout.CENTER);
return p2; }
}

public void actionPerformed(ActionEvent e)

{

53 54