Programa exempo para consulta em bd Mysql com programa C

#include<stdio.h>

#include<mysql/mysql.h>

#

#Author Edson Pessotti --> edpess@gmail.com

#

#Vamos criar variáveis para fazermos o login no Mysql.

#

#define HOST "localhost"

#define USER "guest"

#define PASS "guest"

#define DB "curso"

int main(void)

#

MYSQL conexao;

MYSQL_RES *resp;

MYSQL_ROW linhas;

MYSQL_FIELD *campos;

char query[]="SELECT * FROM curso;";

int conta; //Contador comum

#Aqui o login e feito passando as variáveis que  criamos.

#

mysql_init(&conexao);

if (mysql_real_connect(&conexao,HOST,USER,PASS,DB,0,NULL,0))

{

printf("Conectado com Sucesso!\n");

if (mysql_query(&conexao,query))

printf("Erro: %s\n",mysql_error(&conexao));

else

{

resp = mysql_store_result(&conexao);// A variável resp recebe a consulta

if (resp) //se houver consulta se houve um retorno ela é verdadeira.

{

//passa os dados dos campos para a variável campos

//escreve na tela os nomes dos campos dando

//um tab somente

campos = mysql_fetch_fields(resp);

for (conta=0;conta<mysql_num_fields(resp);conta++) {

printf("%s",(campos[conta]).name);

if (mysql_num_fields(resp)>1)

printf("\t");

}

printf("\n");

//enquanto retornar registros, conta até o número de colunas que a tabela tem e escreve na

//tela com um tab, depois pula a linha e tenta pegar outro registro
#

while ((linhas=mysql_fetch_row(resp)) != NULL)

{

for (conta=0;conta<mysql_num_fields(resp);conta++)

printf("%s\t",linhas[conta]);

printf("\n");

}

}

mysql_free_result(resp);//limpa a variável do resultado: resp

}

mysql_close(&conexao);

}

else

printf("Conexao Falhou\n");

if (mysql_errno(&conexao))

printf("Erro %d : %s\n", mysql_errno(&conexao), mysql_error(&conexao));

}

}

return 0;

Inserção de dados em uma tabela no banco de dados MYSQL utilizando a linguagem C.

Inserção de dados em uma tabela no banco de dados MYSQL  utilizando a  linguagem C.

Este é um exemplo de query padrão, onde  estamos inserindo valores na tabela curso, a tabela possue  três campos nome , sexo , idade.

mysql_query(&conexao, "insert into curso(nome, sexo, idade) values('Ricardo Rodrigues

Lucca', 'M', 12);

Sempre que vamos  inserir dados  em uma tabela utilizamos uma query como a dada acima.

Como  vimos, na variável do tipo char que é passada como parâmetro, informamos que estamosquerendo inserir algo (insert into) em algum lugar (aprendendo(nome, sexo)) com os

valores X. Se quiséssemos escrever no nome "Moro na rua 24 de julho. E dane-se o mundo!",

teríamos que fazer da seguinte forma a pesquisa:

"insert into aprendendo(nome, sexo) values ('Moro na rua 24 de julho. E dane-se o mundo',

'!');"

A função ficaria:

mysql_query(&conexao, "insert into curso(nome, sexo, idade) values ('Edson Peixotto’, ‘M’ , 25);"

a função indica que estamos inserindo nos campos nome , sexo e idade referidos no primeiro parenteses, os respectivos dados passados no segundo parenteses, ' Edson Peixotto’ , ‘M’ , 25 ,  no banco de dados  nome e sexo foram definidos como  varchar por isso estamos passando os valores entre aspas, porque são strings, já a idade foi definida no banco como numérica int, por isso e passada sem  aspas.

Quando  e feita a inserção de dados e preciso tomar cuidado com o tipo de dado que estamos inserindo para não travamento, tentar inserir um numero dentro de um String e vise-versa,  se for preciso deve ser feito a conversão antes da inserção.

Programinha exemplo:

#include#include<stdio.h>

#

#Author Edson Pessotti --> edpess@gmail.com

#

<mysql/mysql.h>

void main(void)

{

MYSQL conexao;

mysql_init(&conexao);

#Aqui checamos se a conexão foi bem sucedida.

#

if ( mysql_real_connect(&conexao, "localhost", "guest", "guest", "banco", 0, NULL, 0) )

{

printf("conectado com sucesso!\n");

#

#Aqui e feita a inserção dos valores na tabela curso.

mysql_query(&conexao,"INSERT INTO curso(nome, sexo, idade) values('Edson Peisotto,  'M' , 25),;");

}

mysql_close(&conexao);

}

else

{

printf("Falha de conexao\n");

printf("Erro %d : %s\n", mysql_errno(&conexao), mysql_error(&conexao));

}

Auto assinando um arquivo .jar

Geralmente, em aplicações standalone no Java, distribuímos arquivos empacotados em JAR. Por questões de segurança, muitos clientes barram a execução arquivos JAR que não estejam assinados. Quando se usa Java Web Start, via JNLP, também o JAR é barrado. Sendo assim, para resolver esse problema, podemos auto-assinar no JAR. Vamos ver como se faz isso:

Empacote o JAR

A primeira coisa a se fazer é compilar e buildar sua aplicação e em formato JAR. Se você usa Ant, Maven, Gradle… Basta buildar usando eles e gerar o JAR. Depois de gerado o JAR, empacote com esse comando:

jar -cf MyAwesomeApp.jar *.*

Criando a KeyStore

Agora vamos criar a KeyStore para poder assinar o JAR.

keytool -genkey -keystore myKeyStore -alias jdc

Assim que você rodar o comando, será perguntado diversas coisas como organização, nome, etc etc etc. Preencha as informações.

Assinando o JAR

E finalmente, assinando o JAR:

jarsigner -keystore myKeyStore MyAwesomeApp.jar jdc

agora você já pode fazer deploy, usar JNLP etc. Mas fique atento que JARs auto-assinados gera um warning na JVM quando vai executa-los.

Fonte →

https://www.ricardogiaviti.com.br/2017/08/como-auto-assinar-um-arquivo-jar/

Codigo Java como gerar uma assinatura digital, para assinar um arquivo.

O objetivo deste artigo e demonstrar como gerar uma assinatura digital, para assinar um arquivo.

Para tanto vamos precisar de um par de chaves um Privada e Outra Publica.

Com a chave Privada assinamos e criptografar-mos o documento, esta chave como o nome diz e privada e não pode ser revelada, para que o destinatário possa abrir o documento e comprovar a autoria do mesmo verificando o mesmo e validando a assinatura enviamos a chave Publica, desse modo poderemos enviar a mesma chave para diversos destinatários, desse modo somente quem possuir a chave publica poderá poderá abrir e validar a assinatura.

Podemos criar uma par de chaves de varias maneiras, pelo shell do linux, sites softwares etc, o JAVA e muito utilizado em aplicações WEB para esses fim, e possui muitas classes para criar chaves encriptografar ler arquivos de diversos formatos, e também possui um tipo de dado para chaves.

Algumas classes utilizadas para criptografia criação de Chaves e validação de assinaturas:

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.PrivateKey;

import java.security.PublicKey;

import javax.crypto.Cipher;

import java.security.InvalidKeyException;

import java.security.KeyFactory;

import java.security.Signature;

import java.security.spec.PKCS8EncodedKeySpec;

Para criarmos uma assinatura digital precisamos de uma instância da classe java.security.Signature. Para isso podemos chamar o metodo Signature.getInstance(), com seus devidos parâmetros de algoritimos e Provedor, neste exemplo esta sendo utilizado o algotirimo SHAcithDSA e o provedor SUN.

Antes utilizarmos o objeto Signature para iniciar com a PrivateKey, no exemplo também e demonstrado como se obter a PrivateKey, e iniciaremos a assinatura chamando com o método initSign().

Agora já estamos aptos a gerar uma Assinatura Digital. Dentro do arquivo que pretendemos assinar, para isso temos trabalhar com dados tipo Byte[], usamos o método Files.readALLBytes().

E então para assinar digitalmente o documento, temos que atualizar-lo, isso se fazer com o método update() passamos os bytes para a Signature, e para gerar a assinar no documento fechamos com o método sign() , este método retorna uma array de bytes da assinatura.

Exemplo de Código:

import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.*;

public class GenerateDigitalSignature {
    public static void main(String[] args) {
        try {
            // Get instance and initialize a KeyPairGenerator object.
            KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA", "SUN");
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG", "SUN");
            keyGen.initialize(1024, random);

            // Get a PrivateKey from the generated key pair.
            KeyPair keyPair = keyGen.generateKeyPair();
            PrivateKey privateKey = keyPair.getPrivate();

            // Get an instance of Signature object and initialize it.
            Signature signature = Signature.getInstance("SHA1withDSA", "SUN");
            signature.initSign(privateKey);

            // Supply the data to be signed to the Signature object
            // using the update() method and generate the digital
            // signature.
            byte[] bytes = Files.readAllBytes(Paths.get("ENDEREÇO DO "));
            signature.update(bytes);
            byte[] digitalSignature = signature.sign();

            // Save digital signature and the public key to a file.
            Files.write(Paths.get("signature"), digitalSignature);
            Files.write(Paths.get("publickey"), keyPair.getPublic().getEncoded());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

O Ryzen 9 3950X

O Ryzen 9 3950X possui 16 núcleos e uma arquitetura baseada em 7nm

Veja também:AMD e Samsung assinam parceria para trazer Radeon aos smartphonesComo o atraso da Intel reacendeu a briga com a AMD após anosNovo chip da AMD iguala desempenho de um Core i9 pela metade do preço

Durante o evento Next Horizon Gaming da AMD, a empresa apresentou sua nova leva de peças de hardware que, no papel, parece ser capaz de se tornar os hardwares mais poderosos que temos no mercado. Eles anunciaram sua terceira geração de processadores Ryzen e um deles parece bem impressionante.

O grande destaque ficou para o processador Ryzen 9 3950X, que traz 16 núcleos, e custa US$750 (aproximadamente R$2893). Além do generoso número de cores, o processador possui um clock de 3.5GHz, um cache de 72MB e um TDP (Projeto de Força Térmica) de 105W, considerado algo inédito no mercado.


O grande destaque desse processador é sua arquitetura baseada em 7nm e que conta com soquetes tamanho padrão, que se encaixam na maioria das placas mãe AM4 disponíveis no mercado. De acordo a AMD, esses 7nm não são apenas mais econômicos e eficientes, mas mais rápidos nas tarefas por conta de seus núcleos adicionais e apresentam melhor desemprenho em jogos.

A AMD disse também que planeja continuar oferecendo compatibilidade de entrada de placas de vídeo até 2020. Essa resolução da empresa é para evitar que os consumidores comprem uma nova placa juntamente das peças usadas para a atualização de sua CPU. “Será preciso um grande ponto de inflexão na tecnologia para sairmos do soquete AM4”, diz David McAfee, da AMD, acrescentando que, provavelmente, será necessária uma grande mudança na arquitetura da placa mãe antes da AMD se preocupar em atualizar sua conexão.

Um dos focos desse equipamento está voltado para os streamers. O processador permite que esses criadores de conteúdo consigam transmitir em alta qualidade, sem perda de desempenho ou a queda de quadros que geralmente acontece durante essas transmissões.


A AMD está bastante confiante de que vai conseguir adquirir uma parte do mercado que a arquirrival Intel, outra fabricante de processadores, não consegue alcançar, já que eles mal conseguem chegar a processadores de 10nm. Travis Kirsch, da AMD, afirmou: “não acho que há alguma razão para as pessoas comprarem processadores da Intel após fazermos isso”. Em sua fala, ele se refere ao que os novos processadores podem oferecer em relação ao seu concorrente.

Construindo um GRidView em Gambas3.

Controlando o GridView.

O controle do GridView, funciona como outros controles da caixa de ferramentas, e herda seus atributos a partir da Classe de Controle, o GridView implementa um controle que exibe os dados dentro do GridView. Essa classe é criada, O padrão da Syntaxe da linguagem Gambas para o GridView é:

DIM hGridView AS GridView

hGridView = NEW GridView ( Parent AS Container )

O código acima criará um novo GridView,

Esta Classe age como um array somente de leitura.

Para ter acesso aos dados de uma célula desejada e preciso declarar da seguinte maneira:

Declarar uma GridCell variável que poderá ser obtida GridView array (the GridCell is a virtual class): Para isso decflaramos duas variáveis: uma para o GridView e outra para o GridCell.

DIM hGridView AS GridView

DIM hGridCell AS .GridCell

Agora referimos a célula indexada por dois parâmetros inteiros.

hGridCell = hGridView [ Row AS Integer, Column AS Integer ]

Primeiro declaramos o GriudView depois a célula, e então obtemos o valor da célula desejada, indexando com indexes da linha e coluna respectivamente.

Criaremos um exemplo:

Nese caso vamos criar um GridView com quatro linhas e três colunas, e vamos popular as trẽs primeiras linhas com texto e a última linha com figura

Vamos acessar a ultima linha com texto para demonstrar com o acesso aos dados funciona, nosso programa terá três botões Quit, Clear e Reset

O botão quit irá fechar o programa.

O botão Clear invocara o método GridView.Clear para limpar o conteúdo da Grid

O botão reset irá recompor o Grig com os dados originais

Agora vamos começas a digiar o código. Dê um duplo click no form.

' Gambas class file

PUBLIC SUB Form_Open()

Form1.Caption = " GridView Example "

END

Quando o programa começa se existir um construtor ele será executado primeiro.

Nosso constutor irá carregar nossos três ícones e popular o grid.

Primeiro e preciso declarar a três variáveis globais para as figuras como segue:

PUBLIC SUB _new()

DIM hPic1 AS Picture

DIM hPic2 AS Picture

DIM hPic3 AS Picture

Agora vamos instanciar nossa figura como um objeto.

hPic1 = NEW Picture

hPic2 = NEW Picture

hPic3 = NEW Picture

Agora carregando as figuras para os objetos.

hPic1.Load("GridPic.png")

hPic2.Load("GridPic2.png")

hPic3.Load("GridPic1.png")

Agora podemos definir as configurações do grid, numero de linhas numero de colunas e seu tamanho;

Definindo numero de linhas e colunas respectivamente:

GridView1.Columns.Count = 3

GridView1.Rows.Count = 4

Para configurar o tamanho das celulas precisamos definir duas coisas a largura das colunas e a altura das linhas, como segue:

GridView1.Columns.Width = 72

GridView1.Rows.Height = 36

Tudo declarado instanciado, carregado , definido o numero de linhas e colunas e suas dimensões

Agora vamos carregar cada celula com um valor:

GridView1[0,0].Text = "0,10"

GridView1[0,1].Text = "0,11"

GridView1[0,2].Text = "0,25"

GridView1[1,0].Text = "1,90"

GridView1[1,1].Text = "1,109"

GridView1[1,2].Text = "2.99"

Também podemos fazer a carga alinhando o conteúdo dentro das células, como segue.

GridView1[2,0].Alignment = Align.Center

GridView1[2,1].Alignment = Align.BottomLeft

GridView1[2,2].Alignment = Align.TopRight

Primeiro definimos o alinhamento e agora podemos atribuir o conteúdo de cada célula.

GridView1[2,0].Text = "2,0"

GridView1[2,1].Text = "2,1"

GridView1[2,2].Text = "1,2"

Finamente podemos carregar as imagens para as céulas do grida

GridView1[3,0].Picture = hPic1

GridView1[3,1].Picture = hPic2

GridView1[3,2].Picture = hPic3

END

Vamos acrescentar três botões de Controle, Limpar , Ressetar Fechar

PUBLIC SUB Button1_Click()

ME.Close

END

PUBLIC SUB Button2_Click()

GridView1.Clear

END

_new

END

Pronto agora e compilar e rodar o programa para ver como funciona.

VEJA O VÍDEO ABAIXO.

PHP - MYSQL mysql acesso ao banco.

PHP está em constante evolução e prova disso são as novidades que vamos comentar neste artigo. Se trata das novas funções de acesso a bases de dados MySQL que estão disponíveis a partir de PHP 5, com nomes diferentes das funções disponíveis no passado e que também têm algumas mudanças no modo de trabalhar. As novas funções foram criadas para dar resposta a diversas melhorias que o sistema gestor de bases de dados MySQL incorporou recentemente.

Este é um assunto fundamental, sobretudo para as pessoas que conhecem PHP há tempo, que como eu, estávamos acostumados a usar um jogo de funções que atualmente se encontra obsoleto e que não se recomenda utilizar. Realmente, no momento de escrever este artigo as funções de MySQL antigas ainda, se podem usar, mas a previsão é que sejam eliminadas em PHP 5.5, razão pela qual é imprescindível atualizar nossos conhecimentos.

Felizmente, é bastante simples o passo para as novas funções de MySQL, uma vez que o esquema de funcionamento é praticamente o mesmo, assim como os novos nomes de funções, que têm muito poucas variações. Portanto, se você leu o Manual de PHP de CriarWeb.com e aprendeu conosco a trabalhar com as bases de dados, não terá realmente muitos problemas em aprender as novidades que passo a relatar a continuação.

Dois tipos de funções para acesso às bases de dados MySQL

Uma das novidades que PHP nos oferece nas recentes funções de PHP é a incorporação de dois tipos de aproximações ao trabalho com MySQL, que agora pode ser feita por procedimentos (funções normais de sempre) e por objetos.

Nota: Antes só podíamos acessar MySQL por funções comuns, Mas agora também podemos acessar por meio de classes e objetos de programação orientada a objetos (POO). A incorporação no API de métodos baseados em POO torna patente que PHP está tendo muito presente este paradigma de desenvolvimento dentro de seu núcleo e que a tendencia nas nuevas versões de PHP será a de potencializá-lo ainda mais.

Funções baseadas em procedimentos: Como vimos fazendo desde sempre com PHP.

Funções normais e correntes, que recebem parâmetros e que retornam valores.

Funções baseadas em POO: Realmente são construtores para obter objetos e métodos aos que podemos acessar dentro desses objetos para realizar as operações com a base de dados.

Há que esclarecer que ambas aproximações são perfeitamente válidas e que não mudam as coisas que podem ser feitas de uma ou outra. Portanto, elogiar um ou outro modo não implicará em nenhuma vantagem em funcionalidade, nem sequer de rendimento. Na verdade, ambos modos de trabalho são o"mesmo cachorro com diferente coleira". Portanto, é tão válida uma escolha quanto a outra e nossa preferência será mais por gosto ou costume à hora de desenvolver.

Nota: O que não se recomenda em um mesmo projeto é mudar de um outro estilo de acesso à base de dados MySQL de maneira arbitrária. Devemos ter em conta que realmente essa recomendação não se deve a que seu programa não vai funcionar, ou que você possa ter algum problema determinado, mas que é uma questão de estilo e clareza à hora de manter o código de seu proyeto.

Acesso a MySQL com funções por procedimentos

No mencionado Manual de PHP vimos oferecendo exemplos para acesso à base de dados com funções desde sempre. Por isso, neste artigo vamos mostrar as diferenças que existem relacionadas às funções antigas, usando também código por procedimentos. Contudo, como você verá a seguir, as funções são praticamente as mesmas às que se acrescentou um "i". Por exemplo, mysql_connect() passa a ser mysqli_connect(). Os parâmetros são os mesmos em muitos casos, ou muito parecidos.

Nota: este artigo não é um tutorial de acesso a bases de dados com PHP, para isso já dispomos do manual de PHP em CriarWeb.com. Realmente se trata de uma serie de guias para poder reciclar nossos conhecimentos com o PHP de versões anteriores.

Conexão com a base de dados: mysqli_connect()

Agora indicamos também a base de dados à que nos queremos conectar. E atenção, porque o que nos retorna a função não é um link ou identificador da conexão com a base de dados, mas um objeto. Porém, mesmo que você não saiba POO, não se preocupe com este detalhe, pois pouco importa aos desenvolvedores, dado que vamos usar esse objeto como se fosse simplesmente o identificador da conexão, ou seja, vamos usá-lo como fazíamos anteriormente em PHP.

$conexao = mysqli_connect("localhost", "usuario", "chave", "meu_bbdd");

Fechar a conexão: mysqli_close()

Temos que passar como parâmetro sempre o objeto que obtivemos ao iniciar a conexão.

mysqli_close($conexao);

Executar uma consulta: mysqli_query()

Esta função é exatamente igual, embora neste caso recebe obrigatoriamente como primeiro parâmetro o objeto de conexão à base de dados que recebemos ao nos conectarmos. O segundo parâmetro é a sentença SQL que se deseja executar em MySQL.

$resultado = mysqli_query($conexao, "select * from cliente");

Outro aspecto interessante é que nos retorna um valor que pode ser, ou um booleano para saber se a consulta foi executada com sucesso, como no caso de um "insert" ou "delete", ou então um objeto resultado com um conjunto de registros no caso de um "select".

Extrair um registro do conjunto de resultados: 

mysqli_fetch_array()

Esta função é exatamente igual, recebe o conjunto de resultados do que queremos extrairr um registro. Retorna neste caso um "array", mas está igualmente mysqli_fetch_object() que retornaría um objeto.

$fila = mysqli_fetch_array($resultado);

Contar o número de filas de um resultado: 

mysqli_num_rows()

Também é exatamente igual, simplesmente lhe passamos o objeto conjunto de registros do que queremos saber o número de filas ou registros que contém.

$fila = mysqli_num_rows($resultado) 

Conclusão

Em geral, como você está podendo comprovar, o sistema não varia muito em relação ao que você já conhecia. Mudam nomes de funções minimamente e algum parâmetro solto aqui e ali.

Creio que o passo para usar as novas funções MySQL é tão rápido que não tem sentido continuar usando as funções antigas e, ademais, em breve a mudança será obrigatória porque os acessos antigos que fazíamos a MySQL deixaram de funcionar.

JAVA Um sistema de logim com senha embutida no código. Com JOPtionPane.

Um sistema de logim com senha embutida no código. 

 Com JOPtionPane. Primeiro a Class de Login aqui e a Logus.java. 

Ela a senha digitada como parâmetro, através da string nome, faz o teste de correspondência e retorna um boleano.

 import javax.swing.JOptionPane; 

/** * @author Edson Pessotti */ 

public class Logus { 

 private String nome;

 private int resul; 

 private int loginus(String nome) {

 return getResul(); } 

 // @return the resul 

 public int getResul() { return resul; }

 /** * @param resul the resul to set */

 public void setResul(int resul) {

 if (nome == null || nome.equals("") || !nome.equals("A sua senha Aqui")) {

 setResul(1) 

;} 

 else{ setResul(0)

;} 

 this.resul = resul; } 

 /** * @return the nome */ 

 public String getNome() { return nome; }

 /** * @param nome the nome to set */

 public void setNome(String nome) {

 this.nome = nome; loginus(this.nome); } } 

// Agora o Metodo que vai capturar a senha. Neste metodo capturamos a senha e passamos para a //class Logus que testa e retorna um boleano, que de retorno e testado neste metodo, caso correto o //processamento continua, senão fica “no cosa do exemplo amarrado ao um loop “ até acetar 

 public void run() { String nome="";  // string que receberá a senha 

 Logus login = new Logus(); // instância da classe Logus. //

 while (nome == null || nome.equals("")) {

 JPasswordField password = new JPasswordField(10); 

 password.setEchoChar('*'); // Cria um rótulo para o campo JLabel

 rotulo = new JLabel("Entre com a senha:");  // Coloca o rótulo e a caixa de entrada numa JPanel:

 JPanel entUsuario = new JPanel(); 

 entUsuario.add(rotulo); 

 entUsuario.add(password); // Mostra o rótulo e a caixa de entrada de password para o usuario fornecer a senha:  //as letras digitas são substituidas por '*'.

JOptionPane.showMessageDialog(null, entUsuario, "Acesso restrito", JOptionPane.PLAIN_MESSAGE); 

 // O programa só prossegue quando o usuário clicar o botao de OK do showMessageDialog. 

 // Aí, é só pegar a senha: // 

Captura a senha: 

 nome = password.getText();

 login.setNome(nome); 

// Aqui a senha e passada como parametro 

 if (login.getResul()!=0) { } 

else { nome = "sai"; }}

Java manipulando dados de um Jtable

                  Java com JTable

A Classe JTable é a classe responsável por representar um grid no swing, ao meu ver é umas das classes de GUI mais difícil de se trabalhar pela sua flexibilidade. Esta é uma classe que usa o padrão MVC(Model , View e Controller):

Model: é a classe responsável por representar os dados da tabela, sempre que iremos modificar os dados de uma JTable deve ser feito através do objeto model que é implementado pela interface TableModel ( AbstractTableModel e DefaultTableModel).

View: É a apresentação da célula na JTable é implementado pela interface CellRenderer, que através de seus métodos define como seram apresentados os valores.

Controller: é a parte que controla os dados e a apresentação, ele é representado pela própria JTable.

Vejamos agora como criar a mais simples das JTable:

1 2 3 4 5 6 7 8 9 10 11

String[] colunas = new String[]{"Nome","Idade","Sexo"};   String[][] dados = new String[][]{     {"Rodrigo","28","Masculino"},     {"Maria","30","Feminino"} };   JTable tabela = new JTable(dados,colunas); JScrollPane scroll = new JScrollPane(); scroll.setViewportView(tabela); this.add(scroll);

Na lina 1 criamos uma array de strings que serão os nomes das colunas e os usaremos para construir nossa JTable, na linha 3 criamos uma matriz que será utilizada como dados da tabela, sendo o primeiro índice as linhas e o segundo as colunas sendo assim nossa tabela de exemplo tem 2 linha e 3 colunas. No exemplo utilizamos uma matriz de String, mas poderia ser uma matriz de Object ou objeto do tipo Vector

Na linha 8 criamos o objeto JTable passando como argumento para o construtor dos dados e os nomes das colunas, com este construtor ele cria internamente um objeto DefaultTableModel para armazenar os dados que posteriormente podemos pegar utilizando o método tabela.getModel().

Na linha 9 criamos um JScrollPane para colocar a tabela dentro através do seu método setViewportView(JTable), ele serve para a tabela possuir uma barra de rolagem e mostrar os nomes das colunas.

Na linha 11 adicionamos o JScrollPane na janela.

Também poderiamos ter criado a mesma tabela através do seguinte código:

1 2 3 4 5 6 7 8 9 10 11 12

String[] colunas = new String[]{"Nome","Idade","Sexo"}; String[][] dados = new String[][]{     {"Rodrigo","28","Masculino"},     {"Maria","30","Feminino"} };   JTable tabela = new JTable(); DefaultTableModel model = new DefaultTableModel(dados , colunas ); tabela.setModel(model); JScrollPane scroll = new JScrollPane(); scroll.setViewportView(tabela); this.add(scroll);

Como podemos ver criamos um objeto DefaultTableModel(linha 8), com os dados da tabela e os nomes das colunas em vez de passar para para o construtor de JTable, e depois adicionamos o model criado através do método setModel, devemos fazer assim quando quisermos criar nossos próprios models.

Adicionando uma linha:

1 2 3 4

DefaultTableModel model =  (DefaultTableModel) tabela.getModel();   String[] linha = new String[]{"João", "15" , "Masculino"}; model.addRow(linha);

Como vimos, para manipular os dados de um JTable devemos utilizar o objeto model que ela possui, então primeiro devemos pegar o model através do método getModel(), após isto basta criar um array de Strings com os valores correspondentes a cada coluna e adiciona-lo através do método addRow(), do objeto model

Removendo uma linha da tabela

1 2 3

DefaultTableModel model =  (DefaultTableModel) tabela.getModel();   model.removeRow(0);

Para remover uma linha devemos primeiro pegar o model do JTable como antes e depois chamar o método removeRow() que recebe como parâmetro um inteiro que será o número da linha que ele deve excluir, lembrando que as linha são contadas iniciando em 0.

Na maior parte dos caso queremos remover um linha do JTable que esta selecionada, para isso devemos pegar o número desta linha.

1 2 3 4 5

int linha = tabela.getSelectedRow();   if( linha != -1){     model.removeRow( linha ); }

Como vemos na linha 1, para descobrir qual linha está selecionada utilizamos o método getSelectedRow() da JTable, que retorna o numero da linha selecionada ou -1 se não tiver nenhuma linha selecionada.

Bom não adianta nada ter uma tabela se não podemos manipular os valores dela, veremos abaixo como pegar um valor de uma célula do JTable

1 2 3 4

int linha = tabela.getSelectedRow();//pegando linha selecionada String nome = tabela.getValueAt(linha , 0) ); String idade = tabela.getValueAt(linha , 1) ); String sexo = tabela.getValueAt(linha , 2) );

O modo mais fácil de pegar um valor de uma célula de uma JTable é através do método getValueAt(int , int), que recebe como primeiro parâmetros o número da linha e como segundo o número da coluna, lembrando que como as linhas a numeração das colunas começa em 0.

Para colocar um valor especifico em uma célula podemos utilizar o método setValueAt(Object, int, int):

1 2 3 4

int linha = tabela.getSelectedRow();//pegando linha selecionada tabela.setValueAt("Nome alterado" , linha , 0); tabela.setValueAt("0" , linha , 1); tabela.setValueAt("indefinido" , linha , 2);

Ao utilizar getValueAt(int , int) e setValueAt(Objec , int , int ) você pode querer percorrer todas as linhas ou colunas da JTable e para isso os métodos getRowCount() e getColumnCount() que retornam respectivamente o número de linhas e colunas.

Também podemos pegar todos os dados da tabela pegando o objeto Vector que representa os dados da tabela através do método getDataVector()

1 2 3 4 5 6 7

Iterator iterator = model.getDataVector().iterator(); while ( iterator.hasNext() ) {     Vector row = (Vector) iterator.next();     System.out.println(row.get(0));     System.out.println(row.get(1));     System.out.println(row.get(2)); }

Como vimos na linha 1 pegamos o Vector do model e utilizamos um iterator para percorrer as linhas, sendo que cada linha também é armazenada como um Vector, sendo cada um dos objetos armazenados nele o valor de uma célula. Só lembrando, se você modificar o Vector retornado pelo método getDateVector() os dados visualizados na JTable serão modificados.

Esta é a maneira mais simples de trabalhar com JTable, para customizarmos mais ela teremos criar o nosso próprio TableModel e CellRenderer que veremos em próximos posts, eu espero.

Referências

http://docs.oracle.com/javase/6/docs/api/javax/swing/JTable.html
http://docs.oracle.com/javase/6/docs/api/javax/swing/table/DefaultTableModel.html