import java.io.*;import javax.swing.*;
public class Estudos{ public static void main(String[] args) { JFileChooser fc = new JFileChooser(); // Altera o texto do botão Open ou Save fc.setApproveButtonText("Abrir"); // Define a tecla de atalho fc.setApproveButtonMnemonic('a'); // Define o tool tip fc.setApproveButtonToolTipText("Clique para abrir o arquivo selecionado"); int r = fc.showOpenDialog(new JFrame()); System.exit(0); }}
Função para formatar fonte de uma JLabel
1. Font f = new Font("SansSerif", Font.BOLD, 20);2. 3. seuLabel.setFont(f); JButton.setText("Button"); JButton.setFont(new
Font("sansserif",Font.BOLD,12); 4. textField.setText(String.valueOf(num)); //Valores do tipo String.
import java.awt.GridLayout;
02 import javax.swing.DefaultListModel;
03 import javax.swing.JButton;
04 import javax.swing.JComboBox;
05 import javax.swing.JFrame;
06 import javax.swing.JLabel;
07 import javax.swing.JList;
08 import javax.swing.JPanel;
09
10
11 public class GridLayoutExemplo {
12
13 JFrame janela=new JFrame(); //instanciar e criar janela
14 JPanel painel=new JPanel(); //instanciar e criar painel
15 JLabel rotulo1=new JLabel("Fruta:"); //instanciar e criar rotulo com instrução
16 JLabel rotulo2=new JLabel("Bebida:");
17
18 DefaultListModel listModel = new DefaultListModel();
19 JList lista= new JList (listModel);
20 JComboBox combo=new JComboBox();
21
22 JButton botao=new JButton("OK");
23
24
25 public static void main(String[] args) {new GridLayoutExemplo();}
26
27 private GridLayoutExemplo() {
28 janela.setTitle("Janela Alan");
29 janela.setSize(350, 150);
30 janela.setLocation(50, 50);
31 janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
32 janela.setVisible(true);
33
34 painel.setLayout(new GridLayout(3,2,5,7));
35 //sintax: new GridLayout (linhas,colunas,espaçamento_horizontal, espaçamento_vertical
36
37 painel.add(rotulo1);
38
39 //ADICIONAR ITENS A LISTA
40 listModel.addElement("Maça");
41 listModel.addElement("Uva");
42 listModel.addElement("Banana");
43 listModel.addElement("Laranja");
44 listModel.addElement("Caju");
45 listModel.addElement("Ameixa");
46 listModel.addElement("Açaí");
47
48 painel.add(lista);
49 painel.add(rotulo2);
50
51 //ADICINAR ITENS AO COMBO
52 combo.addItem ("Água");
53 combo.addItem ("Coca-Cola");
54 combo.addItem ("Café");
55 combo.addItem ("Chá");
56 combo.addItem ("Energetico");
57 combo.addItem ("Água Tônica");
58 combo.addItem ("Suco");
59
60 painel.add(combo);
61 painel.add(botao);
62 janela.add(painel);
63 janela.setVisible(true);
64
65 }}
//importação das classes necessárias 2 //layouts para alinhamento dos componentes 3 import java.awt.FlowLayout; 4 import java.awt.GridLayout; 5 //janela 6 import javax.swing.JFrame; 7 //botão 8 import javax.swing.JButton; 9 //caixa de seleção 10 import javax.swing.JComboBox; 11 //inserção de texto e/ou imagem 12 import javax.swing.JLabel; 13 //exibição de textos numa pequena caixa de mensagens 14 import javax.swing.JOptionPane; 15 //painel 16 import javax.swing.JPanel; 17 //inserção de barras de rolagem numa JTextArea 18 import javax.swing.JScrollPane; 19 //caixa de texto 20 import javax.swing.JTextArea; 21 //campo para inserção de valores ou caracteres 22 import javax.swing.JTextField; 23 //Evento para de ouvir um evento do botão 24 import java.awt.event.ActionListener; 25 //Evento de executar uma ação do evento que foi ouvido(ativado) 26 import java.awt.event.ActionEvent; 27 //tratador de error 28 import java.util.InputMismatchException; 29 30 //Criação da classe EX5 extendendo a classe JFrame que foi importada 31 public class Ex5 extends JFrame 32 {
33 //declaração de um array de 4 colunas já com seus valores configurados 34 private String cargos[]={"Gerente","Técnico","Auxiliar","Outros"}; 35 //criação de duas variáveis do tipo double 36 private double salario,aumento; 37 //criação de um array de 6 colunas do tipo String 38 private String dados[]=new String[6]; 39 //criação de uma string vazia 40 private String string=""; 41 42 //criação do FlowLayout que alinha componentes da esquerda para a direita. 43 private FlowLayout flowLayout = new FlowLayout(); 44 /*criação de GridLayout com 4 linhas e 2 colunas com 10 de espaço em largura 45 e 1 de altura*/ 46 private GridLayout gridLayout = new GridLayout(4,2,10,1); 47 //criação de um painel 48 private JPanel gridJPanel = new JPanel(); 49 50 //criação de dois botões Calcular e Limpar Dados 51 private JButton butao = new JButton("Calcular"); 52 private JButton butao2 = new JButton("Limpar Dados"); 53 //Criação das label's 54 private JLabel Lcargo = new JLabel("Escolha o Cargo:"); 55 private JLabel Lnome = new JLabel("Nome:"); 56 private JLabel Lsalario = new JLabel("Salário:"); 57 //criação dos campos 58 private JTextField Fnome = new JTextField("",5); 59 private JTextField Fsalario = new JTextField("",3); 60 //criação da caixa de seleção anexando o valor do array cargos 61 private JComboBox escolhas = new JComboBox(cargos); 62 //criação de uma caixa de texto com 10 linhas e 22 colunas 63 private JTextArea resultado = new JTextArea(10,22); 64 65 //construtor de Ex5 66 public Ex5() 67 { 68 //título da janela 69 super("Cargos e salários"); 70 //alinhamento do frame com o uso do objeto flowLayout 71 super.setLayout(flowLayout); 72 //tamanho da janela 73 setSize(300, 340); 74 //inclusão dos componentes de maximinizar, miniminizar e fechar 75 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 76 77 //tornando a caixa de texto resultado como não editável 78 resultado.setEditable(false); 79 //exibe 4 linhas da caixa de seleção ao clicá-la 80 escolhas.setMaximumRowCount(4); 81 //alinha o painel com o objeto gridLayout 82 gridJPanel.setLayout(gridLayout); 83 //adiciona os componentes 84 gridJPanel.add(Lcargo); 85 gridJPanel.add(escolhas); 86 gridJPanel.add(Lnome); 87 gridJPanel.add(Fnome); 88 gridJPanel.add(Lsalario); 89 gridJPanel.add(Fsalario); 90 gridJPanel.add(butao); 91 gridJPanel.add(butao2); 92 93 //adiciona a janela principal
94 super.add(gridJPanel); 95 //Adiciona a caixa de texto resultado e ao mesmo tempo adiciona as barras de rolagem 96 super.add(new JScrollPane(resultado)); 97 98 //criação de uma classe interna anônima para butao 99 butao.addActionListener( 100 new ActionListener() 101 { 102 public void actionPerformed(ActionEvent event) 103 { 104 switch (escolhas.getSelectedIndex()) 105 { 106 /*caso seja a primeira opção que foi selecionada na caixa de seleção 107 configure as vaiáveis e vá para o método Calculos*/ 108 case 0: 109 { 110 //configura aumento 111 aumento=1.05; 112 //configura variáveis 113 dados[1]="Gerente"; 114 dados[3]="Aumento de 5%"; 115 //vai para o método calculos 116 Calculos(); 117 //encerra o método case 118 break; 119 } 120 //segunda opção 121 case 1: 122 { 123 aumento=1.075; 124 dados[1]="Técnico"; 125 dados[3]="Aumento de 7,5%"; 126 Calculos(); 127 break; 128 } 129 //terceira opção 130 case 2: 131 { 132 aumento=1.10; 133 dados[1]="Auxiliar"; 134 dados[3]="Aumento de 10%"; 135 Calculos(); 136 break; 137 } 138 //quarta opção 139 case 3: 140 { 141 aumento=1.04; 142 dados[1]="Outros"; 143 dados[3]="Aumento de 4%"; 144 Calculos(); 145 break; 146 } 147 } 148 } 149 }//Fim da classe interna anônima 150 );//fim da chamada para addActionListerner 151 butao2.addActionListener( 152 new ActionListener() 153 { 154 //ao clicar no butao2 de nome limpar chama o método limpar
155 public void actionPerformed(ActionEvent event) 156 { 157 limpar(); 158 } 159 }//Fim da classe interna anônima 160 );//fim da chamada para addActionListerner 161 } 162 private void Calculos() 163 { 164 try //tratador de erros com try e catch 165 { 166 //pega e converte os caracteres em ponto flutuante do campo Fsalario 167 //para a variavel salario 168 salario=Double.parseDouble(Fsalario.getText()); 169 //se salario acima de 100 exiba uma mensagem 170 if (salario>1000) 171 { 172 //WARNING_MESSAGE - refere-se a uma mensagem de aviso 173 JOptionPane.showMessageDialog(this,"Salário acima do permitido!","AVISO!!!" 174 ,JOptionPane.WARNING_MESSAGE); 175 //desconfigura variável e campo 176 Fsalario.setText(""); 177 salario=0; 178 } 179 //do contrário faça 180 else 181 { 182 //multiplica salario com o aumento 183 salario*=aumento; 184 //armazena no array dados na posição 0 o valor do campo Fnome 185 dados[0]=Fnome.getText(); 186 //armazena no array dados na posição 2 o valor do campo Fsalario 187 dados[2]=Fsalario.getText(); 188 //armazena no array dados na posição 4 o valor da variável salario, mas antes 189 //a converte em uma string 190 dados[4]=String.format("%.2f",salario); 191 //Adiciona caracteres no array dados na posição 5 192 dados[5]="_____________________________"; 193 //concatena tudo em uma variável string 194 string += "Nome...:"+dados[0]+"\nCargo...:"+dados[1]+"\nSalário.:"+dados[2]+ 195 +dados[3]+"\nTotal..:"+dados[4]+"\n"+dados[5]+"\n\n"; 196 //exibe o resultado na caixa de texto 197 resultado.setText(string); 198 //limpa os dados 199 limpar(); 200 } 201 } 202 //caso ocorra um erro faça 203 catch(NumberFormatException exception) 204 { 205 JOptionPane.showMessageDialog(this,"No campo salário deve-se digitar um número! 206 \nEx: 345.75","ERROR FATAL!!!",JOptionPane.ERROR_MESSAGE); 207 //desconfigura variável e campo 208 Fsalario.setText(""); 209 salario=0; 210 } 211 } 212 //método para limpar os dados da tela 213 private void limpar() 214 { 215 Fnome.setText("");
216 Fsalario.setText(""); 217 } 218 }//Fim da classe Ex5
1 //Main - Nome da classe 2 public class Main 3 { 4 //Comando principal para execução do programa 5 public static void main(String[] args) 6 { 7 //Criação de um objeto ex da classe Ex1 8 Ex5 ex = new Ex5(); 9 //posição da tela ao abri-la 10 ex.setLocation(400,200); 11 //tornando a tela visível 12 ex.setVisible(true); 13 } 14 }
/**
02 * @author Luciano Santos03 * @site www.analisedesistemas.wordpress.com04 */05 package agenda;0607 import java.awt.FlowLayout;08 import java.awt.event.ActionEvent;09 import java.awt.event.ActionListener;10 import javax.swing.JFrame;11 import javax.swing.JLabel;12 import javax.swing.Timer;13 import java.text.DecimalFormat;14 import java.util.Calendar;1516 public class Relogio extends JFrame {17 JLabel lblHorario;//declarando componente1819 //declarando variaveis20 int hh, mm, ss;21 Calendar hora;22 DecimalFormat formato;2324 public Relogio() {25 setTitle("Relogio");//definindo o titulo da janela2627 setSize(160, 50); //definindo tamanho28 setLayout(new FlowLayout());//definindo o layout da janela29 setLocationRelativeTo(null);//centralizando a janela3031 lblHorario = new JLabel("");//configurando o label inicial32 add(lblHorario);//adicionando o label configurado a janela33 inicio(); //invocando o metodo inicio34 }35 public final void inicio() { //criando o metodo inicio36 Timer time = new Timer(0, ativar);
37 time.start();38 }39 private String formatar(int num) {
40 formato = new DecimalFormat("00");//configurando para que o valor usado apresente 2 digitos
41 return formato.format(num);42 }43 public void horas() {//criando o metodo horas44 hora = Calendar.getInstance();45 hh = hora.get(Calendar.HOUR_OF_DAY);//registrando a hora46 mm = hora.get(Calendar.MINUTE);//registrando os minutos47 ss = hora.get(Calendar.SECOND);//registrando os segundos48 lblHorario.setText(formatar(hh) + ":" + formatar(mm) + ":" + formatar(ss));49 }50 ActionListener ativar = new ActionListener() {51 @Override52 public void actionPerformed(ActionEvent e) {53 horas();//invocando o metodo horas54 }55 };56 }
01 /**02 * alterado por Luciano Santos03 * @site www.analisedesistemas.wordpress.com04 */05 package agenda;0607 import java.sql.*;08 import java.io.*;0910 public class ConexaoDB {1112 Connection conexao;13 FileInputStream fi;14 BufferedReader buff;15 String line = "";16 String[] lines = new String[30];17 int i = 0;1819 public ConexaoDB() {20 try {21 fi = new FileInputStream("/home/luciano/NetBeansProjects/Agenda/db.conf");22 /*23 * Num bloco de notas [windows] ou gedit [linux] digite as seguintes24 * informacoes e salve o arquivo na pasta do projeto com o nome db.conf25 * e altere o endereco acima para o endereco do arquivo.26 *27 * ex: c:\netBeansProjects\agenda\db.conf28 * ============================>>>
29 #hostname ou Endereco IP30 localhost31 #Nome da base de dados32 agenda33 #Nome de usuário MySQL34 luciano35 #senha MySQL (deixe a proxima linha em branco se nao usar senha)36 entrar37 #fim38 * ==============================<<<39 * o arquivo deve conter somente as 9 linhas acima com as devidas40 * alteracoes de nome de usuario e senha.41 */42 buff = new BufferedReader(new InputStreamReader(fi));43 i = 0;44 while ((line = buff.readLine()) != null) {45 lines[i] = line;46 i++;47 }48 String host = lines[1].trim();49 String baseDeDados = lines[3].trim();50 String usuario = lines[5].trim();51 String senha = lines[7].trim();52 try{
53 conexao = DriverManager.getConnection("jdbc:mysql://" + host + "/" + baseDeDados, usuario, senha);
54 System.out.println("Conexao com banco de dados realizada com sucesso");55 }catch (SQLException erro1){56 System.out.println("Erro de conexao - " + erro1);57 }58 } catch (Exception erro2) {59 System.out.println("Erro de arquivo - " + erro2);60 }61 }62 }
01 /**02 * Implementação de um TableModel para renderizar o ResultSet de03 * uma consulta ao banco04 *05 * @author Ricardo Artur Staroski06 */07 package agenda;0809 import java.sql.*;10 import java.util.*;11 import javax.swing.table.*;1213 public class TabelaModelo extends AbstractTableModel {
1415 private static class Column {16 public final Class<?> CLASS;17 public final String NAME;1819 public Column(final String name, final Class<?> type) {20 NAME = name;21 CLASS = type;22 }23 }2425 private static class Row {26 public final Object [] VALUES ;27 public Row(final ResultSet rs) throws SQLException {28 final int columns = rs.getMetaData().getColumnCount();29 VALUES = new Object [columns ];30 for (int i = 1; i <= columns; i++) {31 VALUES [i - 1] = rs.getObject(i);32 }33 }34 }35 private static final long serialVersionUID = 1L;36 private List<Column> columns;37 private List<Row> lines;3839 public TabelaModelo(final ResultSet rs) throws SQLException,40 ClassNotFoundException {4142 columns = new ArrayList<Column>();43 final ResultSetMetaData md = rs.getMetaData();44 final int count = md.getColumnCount();45 for (int i = 1; i <= count; i++) {
46 columns.add(new Column(md.getColumnName(i), Class.forName(md.getColumnClassName(i))));
47 }48 lines = new ArrayList<Row>();49 while (rs.next()) {50 lines.add(new Row(rs));51 }52 }53 @Override54 public Class<?> getColumnClass(final int columnIndex) {55 return columns.get(columnIndex).CLASS;56 }57 @Override58 public int getColumnCount() {59 return columns.size();60 }61 @Override62 public String getColumnName(final int column) {63 return columns.get(column).NAME;64 }65 @Override
66 public int getRowCount() {67 return lines.size();68 }69 @Override70 public Object getValueAt(final int rowIndex, final int columnIndex) {71 return lines.get(rowIndex).VALUES [columnIndex ];72 }73 @Override74 public boolean isCellEditable(final int rowIndex, final int columnIndex) {75 return false;76 }77 }
/**002 * @author Luciano Santos003 */004 package agenda;005006 import java.awt.event.ActionEvent;007 import java.awt.event.ActionListener;008 import java.awt.event.KeyEvent;009 import java.sql.PreparedStatement;010 import java.sql.ResultSet;011 import java.sql.SQLException;012 import java.text.ParseException;013 import javax.swing.JButton;014 import javax.swing.JComponent;015 import javax.swing.JFormattedTextField;016 import javax.swing.JFrame;017 import javax.swing.JLabel;018 import javax.swing.JOptionPane;019 import javax.swing.JScrollPane;020 import javax.swing.JTable;021 import javax.swing.JTextField;022 import javax.swing.text.MaskFormatter;023024 public class Agenda extends JFrame {025026 JTable tblAmigos;027 JScrollPane scrlAmigos;028 JTextField txtNome;029 JFormattedTextField ftxtFone;030 MaskFormatter mskTelefone;031 JButton btnAddAmigo, btnDelAmigo, btnCorrigir, btnSair;032 JLabel lblTitulo, lblNome, lblTelefone;033 PreparedStatement pStmtAmigo;034 ResultSet rsAmigo;035 ConexaoDB dbAmigo;036 TabelaModelo mdlAmigo;037
038 public Agenda() {039 setTitle("Agenda de telefones");040 setSize(400, 375);041 setLocationRelativeTo(null);042043 setLayout(null);044 setDefaultCloseOperation(EXIT_ON_CLOSE);045046 relogio();047 botoes();048 caixas();049 rotulos();050 tabela();051 buscaAmigos();052 }053054 public final void relogio() {055 Relogio hora = new Relogio();056057 lblTitulo = hora.lblHorario;058 lblTitulo.setBounds(150, 0, 120, 24);059 add(lblTitulo);060 }061062 public final void tabela() {063 tblAmigos = new JTable();064 tblAmigos.setBounds(20, 20, 350, 200);065 add(tblAmigos);066067 scrlAmigos = new JScrollPane(tblAmigos);068 scrlAmigos.setBounds(20, 20, 350, 200);069 add(scrlAmigos);070 }071072 public final void botoes() {073 btnAddAmigo = new JButton("Adicionar");074 btnAddAmigo.setBounds(220, 254, 150, 20);075 btnAddAmigo.addActionListener(Add);076 btnAddAmigo.setMnemonic(KeyEvent.VK_A);077 add(btnAddAmigo);078079 btnSair = new JButton("Sair");080 btnSair.setBounds(120, 314, 150, 20);081 btnSair.addActionListener(Sair);082 btnSair.setMnemonic(KeyEvent.VK_S);083 add(btnSair);084085 btnDelAmigo = new JButton("Deletar");086 btnDelAmigo.setBounds(200, 284, 170, 20);087 btnDelAmigo.addActionListener(Del);088 btnDelAmigo.setMnemonic(KeyEvent.VK_D);089 add(btnDelAmigo);
090091 btnCorrigir = new JButton("Corrigir");092 btnCorrigir.setBounds(20, 284, 165, 20);093 btnCorrigir.addActionListener(Update);094 btnCorrigir.setMnemonic(KeyEvent.VK_C);095 add(btnCorrigir);096 }097098 public final void rotulos() {099 lblNome = new JLabel("Nome:");100 lblNome.setBounds(20, 227, 150, 20);101 add(lblNome);102103 lblTelefone = new JLabel("Telefone:");104 lblTelefone.setBounds(20, 254, 150, 20);105 add(lblTelefone);106 }107108 public final void caixas() {109 txtNome = new JTextField(30);110 txtNome.setBounds(70, 227, 220, 20);111 add(txtNome);112 try {113 mskTelefone = new MaskFormatter("(##) ####-####");114 } catch (ParseException erro) {115 System.out.println("Erro - " + erro);116 }117 ftxtFone = new JFormattedTextField(mskTelefone);118 ftxtFone.setBounds(90, 254, 120, 20);119 add(ftxtFone);120 }121 /*Use os seguintes comandos no mySQL para criar o banco de dados122 create database agenda;123 use agenda;
124 create table amigos (idAmigo int (7) AUTO_INCREMENT PRIMARY KEY, nome varchar(30), telefone varchar (15));
125 desc amigos;126 */127 public String CONSULTA_PADRAO = "SELECT * FROM amigos ORDER BY nome";128129 public final void buscaAmigos() {130 try {131 dbAmigo = new ConexaoDB();132 pStmtAmigo = dbAmigo.conexao.prepareStatement(CONSULTA_PADRAO);133 rsAmigo = pStmtAmigo.executeQuery();134135 mdlAmigo = new TabelaModelo(rsAmigo);136 tblAmigos.setModel(mdlAmigo);137138 rsAmigo.close();139 pStmtAmigo.close();140 dbAmigo.conexao.close();141 } catch (SQLException erro1) {
142 System.out.println("Erro na Query - " + erro1);143 } catch (ClassNotFoundException erro2) {144 System.out.println("Erro ao pegar a classe - " + erro2);145 }146 }147 public String INSERCAO = "INSERT INTO amigos (nome,telefone) VALUES (?,?)";148 ActionListener Add = new ActionListener() {149150 @Override151 public void actionPerformed(ActionEvent clic) {152 try {153 dbAmigo = new ConexaoDB();154 pStmtAmigo = dbAmigo.conexao.prepareStatement(INSERCAO);155
156 if (!txtNome.getText().equals("") && !ftxtFone.getText().equals("")) {// tratamento logico
157 pStmtAmigo.setString(1, txtNome.getText());158 pStmtAmigo.setString(2, ftxtFone.getText());159160 int retorno = pStmtAmigo.executeUpdate();161 System.out.println(retorno + " linha inserida - Nome: " + txtNome.getText());162 } else {
163 JOptionPane.showMessageDialog(rootPane, "Insira um nome e um número de telefone", "Aviso", JOptionPane.WARNING_MESSAGE);
164 }165 pStmtAmigo.close();166 dbAmigo.conexao.close();167 } catch (SQLException erro2) {168 System.out.println("Erro ao inserir - " + erro2);169 }170 buscaAmigos();//atualizando a tabela apresentada171 ftxtFone.requestFocus();//levando o cursor para um novo telefone172 }173 };174 public String DELECAO = "DELETE FROM amigos WHERE idAmigo = (?)";175 ActionListener Del = new ActionListener() {176177 @Override178 public void actionPerformed(ActionEvent clic) {179 try {180 dbAmigo = new ConexaoDB();181 pStmtAmigo = dbAmigo.conexao.prepareStatement(DELECAO);182 String idAmigo = "0";183 if (!idAmigo.equals("")) {// tratamento logico
184 pStmtAmigo.setString(1, JOptionPane.showInputDialog("Qual o id do amigo a ser excluido?"));
185 int retorno = pStmtAmigo.executeUpdate();186 System.out.println(retorno + " linha excluida - id " + idAmigo);187 } else {
188 JOptionPane.showMessageDialog(rootPane, "Insira um id válido", "Aviso", JOptionPane.WARNING_MESSAGE);
189 }190 pStmtAmigo.close();191 dbAmigo.conexao.close();
192 } catch (SQLException erro2) {193 System.out.println("Erro ao excluir - " + erro2);194 }195 buscaAmigos();//atualizando a tabela apresentada196 ftxtFone.requestFocus();//levando o cursor para um novo telefone197 }198 };
199 public String CORRECAO = "UPDATE amigos SET nome = (?), telefone = (?) WHERE idAmigo = (?)";
200 ActionListener Update = new ActionListener() {201202 @Override203 public void actionPerformed(ActionEvent clic) {204 JTextField idAmigo = new JTextField();205 JTextField nome = new JTextField();206 JFormattedTextField fone = new JFormattedTextField(mskTelefone);207 final JComponent[] inputs = new JComponent[]{208 new JLabel("Digite os dados corretos:\n idAmigo"),209 idAmigo,210 new JLabel("Nome"),211 nome,212 new JLabel("Telefone"),213 fone214 };
215 JOptionPane.showMessageDialog(null, inputs, "Corrigir registro", JOptionPane.PLAIN_MESSAGE);
216 try {217 dbAmigo = new ConexaoDB();218 pStmtAmigo = dbAmigo.conexao.prepareStatement(CORRECAO);219
220 if (!idAmigo.getText().equals("") && !nome.getText().equals("") && !fone.getText().equals("")) {// tratamento logico
221 pStmtAmigo.setString(1, nome.getText());222 pStmtAmigo.setString(2, fone.getText());223 pStmtAmigo.setString(3, idAmigo.getText());224 int retorno = pStmtAmigo.executeUpdate();225 System.out.println(retorno + " linha atualizada - id " + idAmigo.getText());226 } else {
227 JOptionPane.showMessageDialog(rootPane, "Preencha todos os dados para correção", "Aviso", JOptionPane.WARNING_MESSAGE);
228 }229 pStmtAmigo.close();230 dbAmigo.conexao.close();231 } catch (SQLException erro2) {232 System.out.println("Erro ao excluir - " + erro2);233 }234 buscaAmigos();//atualizando a tabela apresentada235 ftxtFone.requestFocus();//levando o cursor para um novo telefone236 }237 };238 ActionListener Sair = new ActionListener() {239240 @Override241 public void actionPerformed(ActionEvent click) {
242 System.exit(0);243 }244 };245246 public static void main(String[] args) {247 Agenda amigos = new Agenda();248 amigos.setVisible(true);249 }250 }
comentários: 1
Capítulo 7 - Objetos e conjuntos
7.1 - o método equals
Esse método é definido na classe Object, portanto toda classe o terá por herança. Sua assinatura é:
public boolean equals(Object o)
Qualquer tentativa de substituição desse método escrita de forma diferente, não será evidentemente uma substituição e sim uma sobrecarga de método. Você deve prestar bastante atenção nesses conceitos que agora serão explicados, pois são fundamentais para absorção e compreensão desse capítulo. Você já deve saber que o método equals pode funcionar de forma diferente em cada classe, e isso vai depender de como ele foi definido, por exemplo, nas classes Wrappers, é possível saber se um valor 5 inteiro que está armazenado em um objeto x é igual a um objeto y que também armazena o valor 5 (desde que sejam da mesma classe como Integer), isso devido ao fato de que o método equals foi substituído nas classes Wrappers, fazendo com que retorne true quando o valor armazenado pelas classes Wrappers forem idênticos, a exceção é claro, se o tipo for diferente. Vejamos:
1. Integer i = new Integer("5");2. Long l = new Long("5");3. if ( i.equals(l)) System.out.println("igual");4. else System.out.println("diferente");
// Resultado: diferente
Agora quando comparamos instâncias distintos de duas classes iguais:
1. Integer i = new Integer("5");2. Integer j = new Integer("5");3. if ( i.equals(l)) System.out.println("igual");4. else System.out.println("diferente");
// Resultado: igual
Apesar de serem objetos distintos, tem o mesmo valor.
Se usarmos o operador ==
1. Integer i = new Integer("5");2. Integer j = new Integer("5");3. if (i == j) System.out.println("igual");4. else System.out.println("diferente");
// Resultado: diferente
Apesar dos valores serem identicos, o resultado do teste (==) é falso, pois esse testa se os objetos apontam para o mesmo objeto na memória.
Quando substituir o método equals ?
Para iniciarmos essa discussão, precisamos saber que o método equals na classe Object funciona da mesma forma como o operador ==, portanto quando não substituímos o método equals em uma classe o retorno só será true quando ambos objetos apontarem para o mesmo objeto na memória, vejamos:
1. class Flamengo {2. public static void main(String[] args) {3. Flamengo penta = new Flamengo();4. Flamengo melhor = new Flamengo();5. Flamengo temp = penta;6. int i = 0;7. if (penta.equals(melhor)) ++i;8. if (melhor.equals(penta)) ++i;9. if (temp.equals(penta)) ++i;10. if (temp.equals(melhor)) ++i;11. System.out.print(i);12. }13. }
// Resultado: 1
Note que somente uma vez a condição é satisfeita, no caso em que temp == penta !
Como a Java lhe dá os poderes do mundo, você pode alterar esse comportamento. Como ? Mudando a JVM ? Não ! É só substituir o método equals na classe (tira o calçado para falar esse nome) Flamengo, mas para isso é preciso saber quando e porque mudar o método equals !Essa é uma decisão que deve ser tomada medindo todas as consequências. Você deve primeiro responder uma pergunta básica para saber se precisará ou não mudar o método equals. Pergunte se é preciso em alguma situação identificar dois objetos distintos como iguais. Ficou confuso, calma, calma ! Voce tem dois objetos A e B, e adiciona os mesmos em um conjunto (estudaremos conjuntos mas afrente) agora você precisa realizar uma pesquisa afim de saber se o objeto C está no conjunto - pressuponha que os atributos de C e B são semelhantes, se o métodos equals da classe dos objetos citados não for modificado, você nunca obterá true na condição B.equals(C), mesmo sendo classes iguais por sua semântica.Então a decisão de mudar o método equals de uma classe está intimamente relacionada com a necessidade de em uma pesquisa se saber se um objeto está na lista pesquisa ou não.
Entendendo o uso de hashCode
Outro conceito que precisamos entender agora é, onde a utilização do código hash influência no uso de conjuntos ? Não se preocupe, apesar de parecer estranho é um conceito fácil de se entender. Vamos imaginar uma sala com inúmeras caixas postais, o PAULO tem uma caixa com número 385, a ANA tem uma com o número 208, PEDRO usa a de número 378 e assim por diante. Toda vez que chega uma correpondência (do PAULO por exemplo), sabe-se qual o número da caixa postal atravéz de um cálculo em função do seu nome, por exemplo, a soma dos códigos ASCII como podemos observar a seguir:
P -> 80A -> 65U -> 85L -> 76O -> 79
HASH -> 385
Não tire sarro desse cálculo, esse exemplo de código hash é apropriado porém ineficiente (a quem diga absurdo) e isso veremos mais tarde. Com esse cálculo foi possível obter o número da caixa postal do PAULO. Agora vamos analisar como ficaria a pesquisa, ou seja, quando o PAULO chegar na empresa de correspondência e quiser saber se existe alguma correspondência para ele, o atendente perguntaria seu nome e faria o mesmo cálculo para descobrir qual o número da caixa postal, obtendo o número 297, assim o atendente se reportaria à cx no. 297 e recuperaria todas as suas correspondências. Esse processo é muito indicado quando se deseja extrema velocidade no processo de pesquisa. Se você é um cara esperto já deve ter notado um "erro" em nosso algoritmo de cálculo do código hash, pois seguindo esse cálculo qual seria o número da caixa postal para a IVONE. aha com certeza o PAULO pegaria as correspondências da IVONE e vice-versa ! NÃO ! Não pense assim, o processo de pesquisa usando código hash é um processo em duas fases, a primeira é saber em qual depósito se encontra as informações, ou seja, em qual caixa postal está as correspondências, a segunda é verificar cada item da caixa postal comparando para saber se é um item da pessoa desejada. O que não pode acontecer é criar um algoritmo que coloque todas as correspondências em um ou dois depósitos (caixa postal) assim o seu processo de pesquisa ficaria ineficiente, ruim, ridículo, absurdo! Mas correto ! MAS LENTO ! Talvez o exemplo de correpondência não foi muito convincente, visto que uma caixa postal é um depósito de correpondências de uma única pessoa, mas como a empresa de correpondêcia é nossa, e os clientes não tem chave, convencionamos dessa forma - só quem pega as correpondências é um funcionário da empresa.Imagine que nosso algoritmo fosse contar as letras do nome para saber o número da caixa postal, a seguinte lista mostraria a bagunça que ficaria:
NOME DEPOSITO (CP)
JOAO 4ANA 3PEDRO 5AMY 3MARIA 5JOSE 4ENIO 4JOAQUIM 7CAIO 4
Note que cada nome com 4 (quatro) dígitos o número da caixa postal será o mesmo, ficaria uma bagunça, o processo de busca seria muito lento, portanto, quando for criar um algoritmo de cálculo para código hash (espalhamento), faça-o de forma inteligente, usando números complexos, matrizes, limites, derivadas e funções !!! Só para termos uma idéia, cálulos de hash dão assunto para teses de doutorado (isso eh li no livro) !
Método equals versus hashCode
Você já deve ter notado a relação entre os métodos equals e hashCode, pois em uma pesquisa, você
precisará verificar na segunda fase se um objeto X é igual a um item do conjunto - que nada mais é que um objeto Y. Se você não substituir o métodos equals você não terá essa possibilidade, visto que o método equals da classe Object retorna true se ambos os objetos apontarem (ops! isso não é C) referenciarem o mesmo objeto na memória. Memorize isso: para se utilizar uma classe em um conjunto, ela deve ter o método equals substituído.
Contratos do método equals
1) Reflexivo - Para qualquer valor, x.equals() sempre será true;
2) Simétrico - Para qualquer valor de x e y, x.equals(y) é true, se e somente se y.equals(x) tambem for.
3) Transitivo - Para qualquer valor de x, y e z, se x.equals(y) for verdadeiro e y.equals(z) tambem for, então x.equals(z) tambem será verdadeiro.
4) Consistente - Todas as chamadas para x.equals(y) retornará consistentemente true ou false, até que haja uma mudança em algum dos objetos, caso contrário o resultado será sempre o mesmo.
5) Se x referenciar algum objeto, então x.equals(null) deverá retornar falso. Obviamente que uma tentativa de chamar um método equals para um objeto null, lancará um exceção.
Contrato do método hashCode
1) Sempre que um método hashCode for chamado, ele deverá resultar no mesmo código hash consistentemente (caso nenhum valor usado nas comparações for alterado).
2) Se dois objetos forem iguais, considerados pela chamada ao métodos equals, portanto o código hash deverá ser o mesmo para ambos os objetos.
3) Não é obrigado que dado dois objetos distintos, tenham códigos hash distintos.
4) Não é aconselhável usar atributos transient´s no cálculo do código hash, visto que após o processo de deserialização, o método equals poder produzir um resultado diferente de quando o objeto foi serializado, portanto é uma situação perigosa.
Esse contratos devem ser respeitados pois você poderá alterar (substituir) o método equals, portanto siga sempre essas leis.
Substituindo os métodos equals e hashCode
1. public class Pessoa {2.3. private String CPF;4.5. public int hashCode() {6. return 5;7. }8.9. public boolean equals(Object o) {10. if (o instanceof Pessoa) || (o.CPF == this.CPF) return true;11. else return false;12. }13.14. }
7.2 - Coleção de Dados
O uso de coleção de dados é uma necessidade quando precisamos de trabalhar com dados. Já vimos como comparar objetos afim de saber se são equivalentes ou não, agora vamos entender seus repositórios e como funcionam.Existem classes e interfaces que precisaremos entender, se listassêmos aqui, já ficaria muito nebuloso, por isso vamos por parte. Podemos dividor os conjuntos em três categorias:
ListasConjuntosMapas
Vejamos a hierarquia dessas classes/interfaces:
7.2.1 - Ordem e classificação
Nesse primeiro instante, precisamos entender dois conceitos fundamentais nas coleções, que são: ordem e classificação de conjuntos. Abaixo podemos vislumbrar uma definição completa desses conceitos:
ordenada - Uma classe é ordenada se pode ser iterada pelos seus elementos em uma ordem específica, através de um índice ou por exemplo pela ordem de inserção.
classificada - Uma classe classificada, quando seus elementos estão classificados por algum critério, como por exemplo, em ordem alfabética, crescente ou cronológica etc. Toda classe classificada é ordenada, já uma classe ordenada pode não ser classificada.
7.2.2 - List
As classes que implementam a interface List, relevam o índice, com isso podemos inserir um item no meio de uma lista. Como você já deve ter percebido, as classes que implementam a interface List são ordenadas por meio de um índice, isso permite o acesso a um elemento que se encontra no meio da lista, através de seu índice. É uma espécie de sequência para armazenamento de objetos.
ArrayList - É um estrutura de dados que tem com base um array. É isso mesmo! Um ArrayList nada mais é que um array que pode ser alterado. Sua estrutura interna (pode conferir) é baseada em um Array com um tamanho inicial e deve ser especificado na criação do objeto - se nenhum valor for especificado a classe assumirá 10 (sei lá porquê). Com isso é possível tem uma ordem em ArrayList, pois o índice é o identifica os elementos. Vejamos suas principais características:
- Acesso sequencial / aleatório extremamente rápido.
- Em função do índice o acesso a um elemento no meio da lista é uma operação extremamente rápida, como já sabemos é o mesmo que recuperar um item de um vetor.
- Inserção é também extremamente rápida
- Vale uma ressalva nessa situação, visto que uma ArrayList cresce a medida que os itens vão sendo inseridos:
Exemplo:
1. import java.util.*;2.3. public class TestList {4. public static void main(String[] args) {5. long inicio, fim;
6. int n = 3000000;7. inicio = System.currentTimeMillis();8. ArrayList array = new ArrayList();9. for (int i = 0; i < n; i++) {10. array.add(new Integer(i));11. }12. fim = System.currentTimeMillis();13. System.out.println( "Tempo inserir: " + (fim - inicio)/1000.000 );14. inicio = System.currentTimeMillis();15. Iterator o = array.iterator();16. while (o.hasNext()) {17. Integer x = (Integer)o.next();18. }19. fim = System.currentTimeMillis();20. System.out.println( "Tempo iterar: " + (fim - inicio)/1000.000 );21. }22. }
Resultado do programa acima:
Tempo inserir: 2.563Tempo iterar: 0.172
Note que houve uma demora relativamente maior no processo de inserção, porém observe que foram inseridos três milhões de objetos que foram inseridos - acredito que o tempo consumido nos dois processos foi muito bem aproveitado pela classe.A classe ArrayList tem um construtor sobrecarregado que recebe um argumento onde pode-se definir a capacidade da estrutura, ou seja, se for especificado 1000, a classe irá reservar 1000 endereços nulos para o preenchimento dos dados, isso evita a realocação constante de seu array.
Vector - Tem as mesmas características de ArrayList, porém seus métodos são sincronizados. Se aplicarmos o mesmo teste anterior notaremos uma diferença na inserção, vejamos:
1. import java.util.*;2.3. public class TestVector {4. public static void main(String[] args) {5. long inicio, fim;6. int n = 60000;7. int j = 0;8.9. inicio = System.currentTimeMillis();10. Vector array = new Vector(0,1);11. for (int i = 0; i < n; i++) {12. array.add(new Integer(i));13. }14. fim = System.currentTimeMillis();15. System.out.println( "Tempo inserir: " + (fim - inicio)/1000.000 );16.17. inicio = System.currentTimeMillis();18. Iterator o = array.iterator();19. while (o.hasNext()) {20. Integer x = (Integer)o.next();21. j++;22. }23. fim = System.currentTimeMillis();24. System.out.println( "Tempo iterar: " + (fim - inicio)/1000.000 );25. }26. }
Resultado do programa acima:
Tempo inserir: 109.938Tempo iterar: 0.015
Observe que o tempo de inserção foi extremamente superior ao de ArrayList mesmo com uma quantidade 50 vezes inferior, portanto a inserção usando a classe Vector é muito lenta, você provavelmente nunca precisará usá-la, visto que sua única diferença em relação à classe ArrayList é que seus métodos são sincronizados, e esse recurso você pode conseguir se utilizar métodos estáticos da classe java.util.Colletions.Só pra não ficar nenhuma dúvida, se o mesmo programa sobre a classe Vector fosse especificado 3 milhões com em ArrayList, seria necessário um tempo equivalente a 50 * 109.938 = 5496,9 s o que é equivalente a 91,615 minutos.
LinkedList - A diferença entre LinkedList e ArrayList é que os elementos de LinkedList são duplamente encadeados entre si. Isso é essencial quando se deseja implementar uma fila ou pilha. Por causa da duplicidade de encadeamente, é possível por exemplo inserir no final da lista, no início sem a necessidade da realocação do array, visto que cada nó tem uma referência para seu sucessor e seu predecessor, logicamente que isso faz com que o processo de inserção seja um pouco mais lento, pois a cada objeto inserido é registrado o "endereço dos vizinhos" consequentemente uma lista duplamente encadeada é bem maior que uma lista simples, vejamos:
1. import java.util.*;2.3. public class TestVector {4. public static void main(String[] args) {5. long inicio, fim, j;6. j = 0;7. inicio = System.currentTimeMillis();8. LinkedList array = new LinkedList();9. for (int i = 0; i < 1500000; i++) {10. array.add(new Integer(i));11. }12. fim = System.currentTimeMillis();13. System.out.println( "Tempo inserir: " + (fim - inicio)/1000.000 );14. inicio = System.currentTimeMillis();15. Iterator o = array.iterator();16. while (o.hasNext()) {17. Integer x = (Integer)o.next();18. j++;19. }20. fim = System.currentTimeMillis();21. System.out.println( "Tempo iterar: " + (fim - inicio)/1000.000 );22.23. }24. }
Resultado:
Tempo inserir: 2.485Tempo iterar: 0.109
Note que a metade dos itens do primeiro exemplo foi inserido e no entando o tempo gasto foi praticamente o dobro.
Resumindo as listas - O que precisamos saber é que o índice em uma lista é relevante, toda lista é ordenada, ou seja, podemos iterar em uma ordem especifica, seja ela pela ordem de inserção ou pela ordem do índice. A não se esqueça que não existe lista classificada !
7.2.3 - Set
Voltemos a 5a. série do ensino médio:
A = { 0, 1, 2 }B = ( 1, 2, 3 }A U B = { 0, 1, 2, 3 }
Note que os elementos repetidos {1,2} foram suprimidos de um dos conjuntos para não haver repetição. Isso você já deveria saber, pois deve ter estudado no início do ensino médio. Bom o que precisamos saber agora é que toda classe que implementa a interface Set: NÃO ACEITA DUPLICATAS !!! Esse conceito é fundamental para entendermos as classes Set´s !
Como tocamos em um assunto essencial, vejamos como a classe funciona:
X -> Testa o método equalsY -> Pega o código hash
Se X ou Y for falso o objeto é inserido.
Vejamos um caso que sempre será inserido: Se o método equals não for substituído todos os elementos serão inseridos, a menos que você tente inserir o mesmo objeto duas vezes, vejamos:
1. public class Test {2. public static void main(String[] args) {3. HashSet conjunto = new HashSet();4. A x, y, z;5. x = new A();6. y = new A();7. x.a = 10;8. y.a = 20;9. z = x;10. conjunto.add(x);11. conjunto.add(y);12. conjunto.add(z);13. }14. }15.16. class A {17. int a = 0;18. }
A pergunta é: Quantos objetos eu tenho nesse conjunto ??? Acertou se você respondeu dois, vamos tentar entender: note que só existem dois objetos distintos: x e y o z é uma referência a x, portanto, quando o método add foi chamado para o caso de z foi calculado o código hash (digamos que deu 7621), a segunda questão que a classe faz é saber se existe algum objeto no depósito 7621 que seja igual a z, como sabemos (já estudamos isso) que o código hash de dois objetos igual sempre será o mesmo, nesse caso x e z, podemos pressupor que o objeto x está também no depósito 7621, consequentemente o método equals deve (pelo menos é o que esperamos) retornar true, portanto o objeto z não será inserido no conjunto. Talvez você esteja rindo desse exemplo, mais vamos complicar um pouco:
1. import java.util.*;2.3. public class Teste {4. public static void main(String[] args) {5. HashSet conjunto = new HashSet();6. A x, y, z;7. x = new A();8. y = new A();9. z = new A();10. x.a = 10;11. y.a = 20;12. z.a = 10;13. conjunto.add(x);14. conjunto.add(y);15. conjunto.add(z);16. }17. }18.19. class A {20. int a = 0;21.22. public int hashCode() {23. return 10;24. }25. }
Note que nesse caso, substituímos o método hashCode, apesar de ser uma substituição ridícula, ela funciona. Seguindo o mesmo raciocínio do exemplo anterior, quantos elementos foram inseridos ? Tentamos entender: cada vez que o método add é chamado, a classe HashSet chama o método hashCode para tentar encontrar um objeto equivalente, bom nesse caso, o hashCode está retornando 10, com isso podemos saber o endereço de um possível elemento já inserido, porém o método equals que prevalece nesse caso é o da classe Object (que você deve lembrar - retorna true se ambas as referências forem para os mesmos objetos) e o método equals nesse caso irá retornar false, com isso mesmo que se tenha a intenção de serem semelhantes os objetos x e z não o são, visto que para isso será necessário substituir tambem o método equals, vejamos no próximo exemplo:
1. import java.util.*;2.3. public class Teste {4. public static void main(String[] args) {5. HashSet conjunto = new HashSet();6. A x, y, z;7. x = new A();8. y = new A();9. z = new A();10. x.a = 10;11. y.a = 20;12. z.a = 10;13. conjunto.add(x);14. conjunto.add(y);15. conjunto.add(z);16. Iterator o = conjunto.iterator();17. while (o.hasNext()) {18. A azinho = (A)o.next();19. System.out.println( azinho.a );20. }21.22. }23. }24.
25. class A {26. int a = 0;27.28. public int hashCode() {29. return 10;30. }31.32. public boolean equals(Object o) {33. boolean rc = false;34. if (o == null) {35. rc = false;36. }37. else {38. if ((o instanceof A) && ((A)o).a == this.a) {39. rc = true;40. }41. }42. return rc;43. }44. }
Resultado:
2010
Nesse caso, alteramos a classe A e determinar que quando o membro a tiver o mesmo valor será considerada igual (semelhantes as classes Wrappers) - por isso que nesse caso foram inseridos somente dois objetos no conjunto.
Bom agora que acreditamos que ficou claro essa questão da unicidade dos elementos nas classes Set´s, vejamos suas implementações usadas.
HashSet - é um conjunto não-ordenado e não-classificado, utiliza o código hash do elemento que está sendo inserido para saber em qual depósito deve armazenar, com isso podemos notar que um cálculo de código hash ineficiente é a morte para a boa performance durante o processo de inserção/recuperação. Nunca use essa classe quando precisar de uma ordem na iteração.
LinkedHashSet - é um conjunto ordenado e duplamente encadeado, com isso podemos iterar pelos seus elementos em uma ordem, sempre use essa classe quando precisar de ordem na iteração, porém saiba que é um pouco mais lenta que HashSet na inserção visto que leva mais tempo para registrar os vizinhos (elemento posterior e inferior).
TreeSet - essa é uma das duas classes do framework de coleção da api Java que é classificada e ordenada - essa classificação se dá pela ordem natural da classe que está sendo inserida (isso pode ser alterado mas foge do nosso escopo), vejamos algumas classificações naturais para as classes mais usadas:
Classe Ordem Natural
Byte signed numericalCharacter unsigned numericalLong signed numericalInteger signed numericalShort signed numericalDouble signed numericalFloat signed numericalBigInteger signed numericalBigDecimal signed numerical
File system-dependent lexicographic on pathname.String lexicographicDate chronological
7.2.4 - Map
As classes que implementam a interface Map tem funcionalidades distintas da aprendida até aqui, vejamos porquê. Aprendemos que em uma lista o índice é relevante para se pesquisar ou até mesmo inserir um objeto no meio no fim ou em qualquer posição da lista, já nas classes Set´s, a unicidade é a característica fundamental dessas classes sendo necessário uma correta relação dos métodos equals e hashCode para seu funcionamento, já as classes Map´s faz uma mapeamento de chave X valor, ou seja, você tem um objeto chave para um objeto valor. Vejamos um exemplo de seu uso:
1. import java.util.*;2.3. public class TestMap {4. public static void main(String[] args) {5. HashMap map = new HashMap();6. map.put( "um", new Integer(1) );7. map.put( "dois", new Integer(2) );8. map.put( "tres", new Integer(3) );9. map.put( "quatro", new Integer(4) );10. }11. }
Note que um objeto (nesse caso String) é mapeado para cada um valor do conjunto, portanto nas classes Map´s a unicidade da chave é relevante, se você tentar inserir um item como podemos ver abaixo, você não terá um novo item no conjunto pois a chave é idêntica, o valor somente é substituído.
map.put( "dois", new Float(30.0f) );
Podemos concluir que a chave do conjunto Map é um Objeto de uma classe Set, ou seja, a chave deve ser única, o processo para saber se a chave está no conjunto é idêntica ao processo explicado nas classes Set´s, com isso, uma boa implementação dos métodos hashCode e equals é imprescindível para a boa performance desse conjunto.
Vejamos isso na prática:
1. import java.util.*;2.3. 1. public class TestMap {4. 2. public static void main(String[] args) {5. 3. HashMap map = new HashMap();6. 4. map.put( "um", new Integer(1) );7. 5. map.put( "dois", new Integer(2) );8. 6. map.put( "tres", new Integer(3) );9. 7. System.out.println( "Antes: "+map.size());10. 8. map.put( "um", new Float(1f) );11. 9. System.out.println( "Depois: "+map.size());12. 10. }13. 11. }
Resultado:
Antes: 3
Depois: 3
Note que mesmo adicionando um objeto diferente na linha 8, o resultado do tamanho do conjunto não foi alterado. Fica subitamente entendido que se a classe usada na chave (nesse caso String) não substituir os métodos equals e hashCode, todo objeto será adicionado no conjunto, o que não faz muito sentido, portanto sempre utilize um objeto de uma classe onde seus métodos equals e hashCode tenham sido substituídos.
HashMap - é um conjunto Map não-ordenado e não classificado. Permite a existência de chave e valores nulos. Vejamos um exemplo esdrúxulo, porém funcional:
1. import java.util.*;2.3. public class TestMap {4. public static void main(String[] args) {5. HashMap map = new HashMap();6. String um, dois;7. um = null;8. dois = null;9. map.put( um, new Integer(1) );10. map.put( dois, new Integer(2) );11. System.out.println( "Tamanho: "+map.size());12. }13. }
O resultado será: Tamanho 1
Hashtable - essa classe é equivalente à HashMap com a diferença que seus métodos são sincronizados, e, além disso, não permite valores/chaves nulos.
1. import java.util.*;2.3. public class TestMap {4. public static void main(String[] args) {5. Hashtable map = new Hashtable();6. String um = null;7. String dois = null;8. map.put( "um", um );9. map.put( "dois", dois );10. System.out.println( "Tamanho: "+map.size());11. }12. }
[color=red:7fc9c06e81]Erro: java.lang.NullPointerException at java.util.Hashtable.put(Hashtable.java:386) at TestMap.main(TestMap.java: 8) Exception in thread "main"[/color:7fc9c06e81]
Só pra relaxar: Note que a nomeclatura de nomes da Java para essa classe foi esquecida, pois o t em Hashtable deveria ser maiúsculo.
LinkedHashMap - é uma versão ordenada (ordem de inserção/acesso) da interface Map, embora seja um pouco mais lento para inserção e remoção, visto que deve sempre registrar seus sucessor e predecessor, porém a iteração é bem rápida, e, isso tudo por ser uma classe duplamente encadeada.
TreeMap - é a outra classe da Framework Collection Java que é classificada e consequentemente ordenada, vejamos uma aplicação dessa classe:
1. import java.util.*;2. public class TestMap {3. public static void main(String[] args) {4. TreeMap map = new TreeMap();5. long inicio, fim;6. inicio = System.currentTimeMillis();7. int n = 500000;8. for (int i=0; i < n; i++) {9. map.put( "um"+i, new Integer(i) );10. }11. fim = System.currentTimeMillis();12. System.out.println( "Tempo inserir: " + (fim - inicio)/1000.000 );13. }14. }
Resultado: Tempo inserir: 3.937
Porém o resultado estaria em ordem (nesse caso lexicographic) pois se trata de uma classe String.
Bom isso encerrado o estudo das classes de coleções que a Framework Java nos oferece.
7.3 - Coleta de Lixo
A memória sempre foi o "calcanhar de aquiles" para as linguagens de programação. Uma linguagem de programação se diz tipada, por poder definir tipos de dados, por exemplo, uma variável inteira/integer é um tipo, cada linguagem de programação tem uma representação para o tipo inteiro, em pascal um tipo inteiro corresponde a um interval que provavelmente não equivale o mesmo intervalo em Java, e essas definições são essencialmente para o melhor aproveitamento da memória, pois com a definição dos tipos podemos (os programas podem) estimar o uso de memória, saber quanto um programa ou uma rotina vai usar, enfim a memória é um elemento essencial e primordial para o sucesso de qualquer programa, por isso devemos saber aproveitá-la.O gerenciamento da memória não é uma tarefa fácil, saber quando um objeto está pronto para ser dilacerado (sempre quis usar essa palavra), anular uma referência, re-referenciar um objeto, sugerir a execução do coletor de lixo, todos esses conceitos serão entendidos (pelo menos é o que esperamos) a partir de agora.
Como o coletor de lixo funciona
Você poderá encontrar dezenas de teorias de como o coletor funciona, mas não caia nessa, pode ser que sim ou que não, ou sei lá ! Mas vamos entender uma coisa: um programa Java roda simultaneamente vários processos ou vamos chamar segmentos (não gosto muito desse nome, prefiro chamar thread), e um segmento pode estar ou não ativo, e um objeto está pronto para ser extirpado quando nenhum segmento não pode alcançar esse objeto, simples não ?Você pode dar uma mão para o coletor de lixo, porém não caia na idéia de que pode chamá-lo quando bem entender, você pode sugerir: hein tá na hora da limpeza, mas não é garantido que ele venha. Portanto se você se deparar com uma questão perguntando qual a maneira mais precisa de se executar o coletor de lixo ? Não hesite em marcar: IMPOSSÍVEL !!!
Anulando uma referência:
1. 1. public class Test {2. 2. public static void main(String[] args) {3. 3. StringBuffer b = new StringBuffer("hello");
4. 4. System.out.println(b);5. 5. b = null;6. 6. } }
A partir da linha 5, o objeto b não referencia mais nada da memória, portanto o coletor pode muito bem eliminar a String "hello" que deverá estar ocupando lugar. Isso é muito gentil por parte dos programadores, anular uma referência sempre que não venha mais precisar do objeto.
Vejamos outro exemplo:
1. 1. public class Test {2. 2. public static void main(String[] args) {3. 3. StringBuffer sb1 = new StringBuffer("hello");4. 4. StringBuffer sb2 = new StringBuffer("my friendy");5. 5. System.out.println( sb1 );6. 6. sb1 = sb2;7. 7. }8. 8. }
Após a execução da linha 6, a string "hello" ficará perdida na memória, estando disponível para o coletor de lixo executar o seu trabalho.
Objetos dentro de um método
Todos os objetos criados localmente dentro de um método estarão qualificados para a coleta após a execução do método. Vejamos um exemplo:
1. public void show() {2. String s1 = "s1";3. String s2 = "s2";4. System.out.println(s1+s2);5. }
Após a execução do métodos acima, os dois objetos s1 e s2 estarão qualificados para a coleta, agora vejamos um outro exemplo:
1. public String show() {2. String s1 = "s1";3. System.out.println(s1+s2);4. return s1;5. }
Note que o objeto s1 está sendo utilizado no retorno do método, portanto esse objeto não pode ser coletar, mesmo porque, ele ainda está sendo referenciado.
Isolando uma referência
Vamos complicar um pouco as referências para ver o que acontece com os objetos:
1. public class Test {2. Test t;3.4. public static void main(String[] args) {5. Test t2 = new Test();6. Test t3 = new Test();7. Test t4 = new Test();8.9. t2.t = t3;10. t3.t = t4;11. t4.t = t2;12.13. t2 = null;14. t3 = null;15. t4 = null;16. }17. }
O que achas que acontece nesse caso ?? Calma vamos entender:
Apenas três objetos foram criados na memória: t2, t3, t4.
Quando os objetos t2, t3 e t4 foram anulados, tornaram-se qualificados para a coleta, mesmo existindo outras referências para esses objetos.
Sugerindo a coleta
1. import java.util.Date;2. public class Memory {3. public static void main(String[] args) {4. Runtime rt = Runtime.getRuntime();5. System.out.println("Memoria total: "+rt.totalMemory());6. System.out.println("Memoria Antes: "+rt.freeMemory());7. Date d = null;8. for (int i=0; i < 5000; i++) {9. d = new Date();10. d = null;11. }12. System.out.println("Memoria Depois: "+rt.freeMemory());13. rt.gc();14. System.out.println("Memoria Final: "+rt.freeMemory());15. }16. }
Note que a linha rt.gc() simplesmente sugere, não garante que a coletar efetivamente seja feita.
Bom depois dessa lixaiada, terminamos mais um capítulo !! :!: :!: :!:
Leia também:Fundamentos da LinguagemModificadoresOperadores e atribuições
Controle de FluxoOrientação a ObjetosJava Lang e WrappersObjetos e ConjuntosClasses InternasThreads (Segmentos)
{Funções de conversão}Introdução
JAVA foi originalmente concebida para o desenvolvimento de pequenos aplicativos e programas de controle de aparelhos eletrodomésticos e eletroeletrônicos, Java mostrou-se ideal para ser usada na rede Internet. O que a torna tão atraente é o fato de programas escritos em Java poderem ser executados virtualmente em qualquer plataforma, mas principalmente em Windows, Unix e Mac. Em meio a essa pluralidade, Java é um idioma comum, falado por todos. Isto significa que Java é ideal para expressar idéias em forma de programas universalmente aceitos. Soma-se a isso o fato de programas Java poderem ser embutidos em documentos HTML, podendo assim ser divulgados pela rede. Diferente da linguagem C, não é apenas o código fonte que pode ser compartilhado pela rede, mas o próprio código executável compilado, chamado bytecodes.
Java foi desenvolvida por um grupo de pesquisadores da SUN Microsystems por volta de 1990, pouco antes da explosão da Internet. Essa linguagem possui estrutura muito semelhante à da linguagem C, da qual descende imediatamente. Java tem em comum com a linguagem C++ o fato de ser orientada a objetos e mantém com esta um alto grau de semelhança. Esse paradigma de programação consiste de um grau a mais na abstração da programação, em comparação com a programação estruturada, e tem se mostrado extremamente útil na produção de programas cada vez mais sofisticados, em menor tempo e com maior qualidade. A programação orientada a objetos (OOP) é hoje universalmente adotada como padrão de mercado, e muitas linguagens tradicionais foram aperfeiçoadas para implementar esse paradigma, como C++, Object Pascal, etc.
Principais características da linguagem Java
Orientação a Objetos: Java é linguagem totalmente orientada a objetos. Existem outras
linguagens de programação que são orientadas a objetos, tais como, Object Pascal (Delphi), C++,
etc. Orientada a Objetos significa toda a estrutura de código é baseada em objetos, que são
instâncias do que chamamos de classes;
Portabilidade: Um dos recursos mais interessantes da linguagem Java é o sua capacidade de ser
portável, ou seja, ela executa em várias plataformas (Windows, Linux, Mac, etc). Quando um
programa em Delphi é feito em ambiente Windows por exemplo, ele não rodará em outros sistemas
operacionais. Java permite que através do que chamamos de JVM (Java Virtual Machine), o código
seja portável;
Sintaxe similar a outras linguagens: Java possui a sintaxe ( forma como o código é escrito)
muito parecido com outras linguagens de programação utilizadas, tais como C, C++, C# e PHP. Isso
possibilita um rápido aprendizado de seus comandos mais comuns;Variáveis em Java: quais são?
Variáveis são espaços na memória onde podemos armazenar algum tipo de dado. É bom lembrarmos que cada variável precisa ter um tipo, como tipo inteiro, caractere, real, etc. Basicamente, as variáveis em Java podem ser divididas em dois grandes grupos:
Tipos Primitivos
Java possui oito tipos primitivos:
Tipo Objeto
Variáveis do tipo objeto: um objeto pode ser entendido como uma coleção de variáveis do tipo primitivo e também de métodos que atuam sobre essas variáveis. Os objetos são amplamente utilizados em ambiente Java, já que esta é uma linguagem orientada a objetos. Ao contrário das variáveis do tipo primitivo, nós podemos criar as variáveis do tipo objeto.
Java também tem o tipo String. O tipo String armazena frases (mais de um caractere). O tipo string é
utilizado em outras linguagens, tais como Pascal e Delphi, como um tipo simples.
Declarando variáveis
A declaração de variáveis no Java pode ser feita, em geral, em qualquer parte do código fonte, desde que faça parte de um método, mas por hábito já definido/usado em outras linguagens usa-se declarar as variáveis no topo do método, conforme exemplo a seguir:
Gravando e manipulando valores com variáveis e objetos
Para manipulação de tais valores, antes, precisamos armazená-los, ou seja, gravar os valores informados pelo usuário em variáveis já declaradas.
Para fazer isso com variáveis do tipo texto (String) é fácil, basta usar uma função para “pegar” o conteúdo digitado num objeto jTextField, por exemplo. Veja o trecho de código a seguir:
private void jButton1MouseClicked(MouseEvent evt) {
String Descricao;
Descricao = jTextField1.getText();
}
Neste trecho de código, estamos declarando uma variável com o nome “Descricao”, do tipo String, e tal variável recebe o conteúdo digitado no objeto jTextField1 através da funçãogetText().
Isso é simples por que uma variável do tipo texto está recebendo conteúdo do tipo texto também.
Mas e se precisarmos gravar números para depois realizarmos contas?
Vamos olhar a imagem a seguir:
Repare que no método construído existe:
Três variáveis declaradas, uma delas é do tipo int (v_qtde) e 2 delas é do tipo double (subtotal,
v_valor);
Cada variável recebe o conteúdo de um objeto jTextField diferente (em destaque);Porém, as variáveis são de tipos diferentes do tipo String, por isso, é necessário fazer o uso de funções de conversão de valores, no caso, de String para Inteiro e String para Double (real), são elas:
Integer.parseInt() (String para Inteiro)
Double.parseDouble() (String para Double)Nas duas linhas após a atribuição de valores às variáveis, é feita a manipulação dos valores e o resultado é informado ao usuário através de outro jTextField, ou seja, os dados se transformaram
em INFORMAÇÃO, veja:
subtotal = subtotal + (v_qtde * v_valor);
parcial.setText(Double.toString(subtotal));
Mas agora apareceram duas novas funções que são facilmente explicadas, são elas:
setText (altera o conteúdo do objeto jTextField)
Double.toString() (converte valor de Double para String)Sempre que for necessário alterar o conteúdo de um objeto jTextField ou qualquer outro objeto que tenha a propriedade Text listada em suas Propriedades, usa-se a função setText. Veja a lista de propriedades do objeto parcial (jTextField) usado no exemplo abaixo:
Resumindo
Funções para converter valores:
Funções para manipular conteúdo de objetos jTExtField:
Exemplo
Ler o salário base e a quantidade de anos que o funcionário trabalha na empresa. A cada ano que passa, o funcionário receberá um aumento de R$100,00. Informar o salário atual do funcionário com base nessas informações.
Tela do programa:
Código fonte (Botão: Calcular Salário Atual):
Exercícios para Treinar
1. Desenvolver um programa que leia dois números. Mostrar o resultado da soma, subtração, divisão e multiplicação deles. (Lembrete: para armazenar o resultado da divisão, utilize uma variável do tipo double).
2. Ler um número qualquer e imprimir 5% do mesmo.
3. Qual o valor da expressão: (a + b²) - (a / c) ? . (Ler os valores correspondentes à a,b e c, e calcular a expressão.
4. Desenvolva um programa que ajude a um funcionário do estoque a determinar qual o valor total dos livros que estão estocados. O programa deverá o numero de livros estocados, e o valor unitário deles. Multiplique os dois valores para achar o total. Deste total, descontar 10%, referente ao custo de armazenamento dos livros.
Recommended
