domingo, 30 de setembro de 2007

Momento Nerdz Revival

eu: yo, dude
are you back?
Guilherme: I`m bach
bacj
porra
volta

Acessibilidade na Web: Custo ou benefício

Um vídeo muito interessante, deveria ser mostrado na primeira aula de qualquer curso de webdesign (principalmente aqueles que usam flash =P).





Ótimo vídeo feito pelo pessoal do Acesso digital

quinta-feira, 27 de setembro de 2007

quarta-feira, 26 de setembro de 2007

Como gerar números aleatórios

Como eu disse no post anterior, não existem números aleatórios em computação. Mas existem maneiras de conseguir números pseudoaleatórios com uma randomicidade (viva o neologismo) satisfatória.

Existem dois jeitos de se conseguir números aleatórios.

a) Monitoramento de ambiente: O programa monitora algum evento externo, como temperatura, umidade do ar, velocidade do vento, etc, e utiliza essa variável como base para uma função de geração de números;
b) Pseudoaleatoriedade: Projetar uma fórmula que satisfaça 3 condições essenciais:

  1. Não repetição: A fórmula não deve formar ciclos, nem produzir números repetidos propositalmente.
  2. Distribuição numérica razoável: A fórmula deve produzir uma boa faixa numérica, não se restringindo a poucos números.
  3. Imprevisibilidade: A fórmula deve ser produzida de modo que o próximo número gerado não possa ser previsto sem o prévio conhecimento da fórmula.
O Java, ou mais precisamente a classe java.util.Random usa a opção "b", mas utiliza como seed (o número inicial que gerará todos os outros) a variável mais simples a qual ele tem acesso. A máquina virtual do java captura a quantidade de milissegundos entre 01/01/1970 e o momento exato em que a função foi chamada e aplica a seguinte fórmula:


numeroinicial = (numeroinicial ^ 0x5DEECE66DL) & ((1L << 48) - 1);


A partir desta fórmula, os números randômicos serão obtidos da seguinte maneira:


synchronized protected int next(int bits) {
numeroinicial = (numeroinicial * 0x5DEECE66DL + 0xBL) & ((1L <<>>> (48 - bits));
}


Já o C usa a seguinte fórmula:


int rand()
{
random_seed = random_seed * 1103515245 +12345;
return (unsigned int)(random_seed / 65536) % 32768;
}


Legal né?

Links:
How stuff works
Random number generators

Té mais o/

A classe Math do Java

A classe Math do Java pode ser muito útil pra todo mundo (mas principalmente pra trabalhos acadêmicos e aplicativos que envolvem manipulação gráfica ou inteligência artificial).

Por isso, aqui vai uma descrição sobre cada função da classe Math:

(andei procurando isso em português, achei pouca coisa, então reposto aqui)

Constantes:

  • Math.E - equivale à constante e, a base dos logaritmos naturais.
  • Math.PI - equivale à constante pi (π). (pra quem não lembra, π é a razão circunferência / diâmetro)

Funções:

  • Math.sin(a) - seno de um ângulo (em radianos).
  • Math.cos(a) - cosseno de um ângulo (em radianos).
  • Math.tan(a) - tangente de um ângulo (em radianos).
  • Math.asin(a) - arco seno de um ângulo*.
  • Math.acos(a) - arco cosseno de um ângulo*.
  • Math.atan(a) - arco tangente de um ângulo*.
  • Math.toRadians(a) - converte um ângulo dado em graus para seu equivalente em radianos.
  • Math.toDegrees(a) - converte um ângulo dado em radianos para seu equivalente em graus.
  • Math.exp(n) - retorna o número de Euler elevado à nésima potência.
  • Math.log(a) - retorna o logaritmo natural de a.
  • Math.sqrt(a) - retorna a raiz quadrada de a.
  • Math.ceil(a) - retorna o valor double maior e mais próximo de a ("arredonda pra cima").
  • Math.floor(a) - retorna o valor double menor e mais próximo de a ("arredonda pra baixo").
  • Math.rint(a) - retorna o valor mais próximo de a (arredondamento normal).
  • Math.atan2(x, y) - converte as coordenadas retangulares (x, y) em coordenadas polares (r, θ).
  • Math.pow(x, y) - retorna o valor x elevado à potência y.
  • Math.round(a) - retorna o valor mais próximo de a.
  • Math.random() - retorna um valor "aleatório" entre 0 e 1**.
  • Math.abs(a) - retorna o valor absoluto de a ( |a| )***.
  • Math.max(a, b) - retorna o maior valor entre a e b.
  • Math.min(a, b) - retorna o menor valor entre a e b.

* - o arco de uma função é sua função reversa. Ou seja, equivale à função elevada a -1.
Ex.:
sen(π/2) = 1
arcsen(1) = π/2


** - não existe aleatoriedade real no mundo da computação. Depois eu explico como funciona o algoritmo de aleatoriedade do java...

*** - o valor absoluto de um número positivo é o próprio número. O valor absoluto de um número negativo é o próprio número multiplicado por -1.

sexta-feira, 21 de setembro de 2007

Acelerando o boot do Linux

Em alguns computadores, o Linux pode ter uma perda de desempenho gigantesca em comparação com o Windows, principalmente no que diz respeito à inicialização.

Pra minimizar isso, estão lançando o Texas Flood pra algumas versões do Linux (Debian-based). Segundo o guia do hardware, o treco diminui em até 7 segundos o boot do KDE \o/

Pros interessados, tó o link.

Download java php mysql etc

Ali no menu ao lado, vai estar uma lista de links, com os principais programas para download. Divirtam-se. =D

Coisas legais do Eclipse

O Eclipse 3.3 vem com um monte de coisinhas legais, que facilitam na hora de programar... Aqui vão algumas delas:

  • Eclipse suporta CamelCase: Se você quiser capturar ou disparar um IndexOutOfBoundsException, basta digitar IOOB e apertar Ctrl+espaço. Vale o mesmo pra coisas como System.out.println (syso), System.err.println (syse), NullPointerException (NPE), etc...
  • Criar getters e setters: Básico de qualquer classe desenvolvida usando orientação a objeto. Pra criar getters e setters, basta clicar com o botão direito, escolher Source -> Generate getters and setters, e na telinha seguinte, selecionar as variáveis (apenas globais) que deseja tornar acessíveis a outros métodos do "jeito limpinho OO". Dá pra fazer isso tambem digitando get (ou set) e apertando Ctrl+espaço, mas isso vai criar um get só. Útil quando há poucas variáveis "públicas"...
  • Criando hashCode() e equals(): Usando o menu Source, também dá pra criar hashCode() e equals(), muito importante pra manter entidades em sua "forma canônica".
  • O QuickFix é seu amigo: Quando o seu código estiver precisando de uma ajuda, aperte Ctrl+1, o assistente pode sugerir algumas coisas legais, como trocar uma estrutura switch por if-elses, trocar if-elses por operadores ternários, inserir try-catchs em lugares perigosos, etc.
  • Matching brackets: Sabe quando o código não tá lá muito indentado, ou quando há muitos blocos de código e você não sabe qual } finaliza o que? Pois é, pra achar a chave que fecha o bloco, basta colocar o cursor após a chave inicial, apertar Ctrl+shift+P, e pronto, todo o código fica selecionado.
  • Letras difíceis de lembrar: Chato esse negócio de rodar programas usando Alt+shift+x, j, e outros atalhos que uma pessoa normal precisaria de um curso intensivo de 2 meses pra lembrar, né? Muda tudo! Windows -> Preferences -> General -> Keys. Algumas distros Linux não suportam alguns atalhos (meu Kurumin não conseguiu interpretar Ctrl+F11 :/ ), por isso, trocar os atalhos pode ser muito útil.

O básico é isso. O resto vai se descobrindo com o tempo (ou não). Mas não usem NetBeans, por favor. Nerds unidos por um código mais limpo ;)

Ah, esses chineses...

Chineses e suas promoções legais...


Promoção tocha
Achei que quem decidia isso era o comitê olímpico do Brasil... =/

quarta-feira, 19 de setembro de 2007

Trabalhando com Datas no Java

Agora vamos explorar outro terreno fértil do Java: Datas!

Muita gente usa a classe Date (java.util.Date) pra trabalhar com cálculo de datas. Porém, com o tempo, a classe Date foi ficando velha, foi ficando aquém das necessidades dos usuários. Tanto que, dos 6 construtores da classe, só dois ainda não estão marcados como deprecated, e dos métodos, apenas 10 dos 28 estão ativos ainda (incluindo métodos herdados de Object, como clone() e equals()).

Porém o Date ainda não morreu. O ideal, segundo alguns autores, é utilizar a classe Date (não confundir com java.sql.Date) para armazenar valores de data, não para realizar cálculos e coisas do gênero. Para isso, é recomendável o pacote Calendar e seu filhote, GregorianCalendar \o/

Falar é fácil, vamos aos códigos:

Pegar a data de hoje:


//Usando Date
Date hoje = new Date();
//Usando GregorianCalendar
Date hoje = GregorianCalendar.getInstance().getTime();


Converter String em Date:


String s = "21/08/1989"; //Dia em que Raul Seixas morreu :(
SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy");
try {
Date d = format.parse(s);
} catch (ParseException e) {
e.printStackTrace();
}


Converter Date em String:


Date d = GregorianCalendar.getInstance().getTime(); //ou qualquer data =D
SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy");
String s = format.format(d);


Adicionar dias, meses e anos a uma data:


GregorianCalendar data = new GregorianCalendar(2007, 9, 20); //20/09/2007
data.add(GregorianCalendar.DAY_OF_MONTH, 1); // 21/09/2007
data.add(GregorianCalendar.MONTH, 2); // 21/11/2007
data.add(GregorianCalendar.YEAR, 1); // 21/11/2008


Observação: Para subtrair dias meses e anos, basta utilizar números negativos no segundo parâmetro:


GregorianCalendar data = new GregorianCalendar(2007, 9, 20); //20/09/2007
data.add(GregorianCalendar.DAY_OF_MONTH, -1); // 19/09/2007


Somar duas datas usando GregorianCalendar:


GregorianCalendar gc1 = new GregorianCalendar();
gc1.setTime(getData());
GregorianCalendar gc2 = new GregorianCalendar();
gc2.setTime(getHora());
gc1.add(Calendar.YEAR, gc2.get(Calendar.YEAR));
gc1.add(Calendar.MONTH, gc2.get(Calendar.MONTH));
gc1.add(Calendar.DAY, gc2.get(Calendar.DAY_OF_MONTH));
gc1.add(Calendar.HOUR, gc2.get(Calendar.HOUR_OF_DAY));
gc1.add(Calendar.MINUTE, gc2.get(Calendar.MINUTE));
gc1.add(Calendar.SECOND, gc2.get(Calendar.SECOND));


Recuperar parte da data (dia, mês, ano, etc):


GregorianCalendar gc = new GregorianCalendar(2007, 9, 20);
int dia = gc.get(GregorianCalendar.DAY_OF_MONTH)); // 20
int ano = gc.get(GregorianCalendar.YEAR)); // 2007
int era = gc.get(GregorianCalendar.ERA)); // 1 (1 = "depois de Cristo")


Impedir datas erradas:

Suponhamos que o animal do usuário consiga enviar uma data "20/99/2007"; O GregorianCalendar tem um artifício que previne que ocorra uma exceção. Nesse caso, ele entenderia mais ou menos como (2007 anos + 99 meses + 20 dias), o que resutaria, no nosso caso, em 20 de abril de 2015!

Pra evitar isso, existe uma função chamada setLenient(boolean b), que se for chamada com o parâmetro false, garante que a data não será aceita como válida (gerando uma exceção do tipo IllegalArgumentException, facilmente tratada). O único cuidado é que IllegalArgumentException é filhotinha de RuntimeException, ou seja, é uma exceção que só acontece quando o programa é executado.


Era isso. Qualquer coisa que eu lembrar eu acrescento depois. Qualquer dúvida, entrem em contato!

Té o/

terça-feira, 18 de setembro de 2007

Prometeus, the midia revolution

Um vídeo bem interessante sobre a revolução que estaria acontecendo na mídia em geral. Aspectos bem importantes são abordados, embora eu ache que nem todas as previsões são corretas.

Google não compraria a microsoft... Acho que a microsoft vai à falência em menos de 10 anos (lei antitruste + crescimento do linux + endurecimento à pirataria + sistemas online + conscientização de que conhecimento não tem dono, muito menos deve ser vendido em pacotes Home, Professional e Server).

Mas enfim, lá vai o vídeo (legendado em português, pra facilitar):





Se você ainda não é um prosumer, torne-se um. =]

Lentes de raio-x: Enfim a indústria fotográfica fez isso.

Uns japoneses malucos fizeram um filtro pra verificar a autenticidade de cédulas de dinheiro. O problema, descobriu-se depois, é que essa lente permite ver através das roupas das pessoas. (!)

Funciona mais ou menos assim: A lente impede a passagem de radiação visível e ultravioleta, permitindo a passagem apenas de raios infravermelhos. O raio infravermelho atravessa camadas finas de tecidos e coisas do tipo e bate na lente da câmera, transformando-se em imagem.

Melhor do que falar é mostrar, então tó:

Sem filtro:
Lente de raio x sem filtro

Com filtro:
Lente de raio x com filtro

Legal né? E o mais interessante é que esse não é um daqueles projetos do governo americano ou da NASA que nós, seres normais, nunca teremos acesso. O treco já tá à venda, mais ou menos uns 600 paus.

Aguardem uma avalanche de loiras peitudas aparecendo no youtube sendo filmadas com essa lente...

Site do fabricante: Kaya Optics

Té mais o/

reCAPTCHA, enfim.

Eu (e todo humano que se preza) sempre odiei o tal Captcha. Principalmente pelo fato de a maioria dos captchas serem absolutamente ilegíveis (pra quem não sabe, captcha é aquele trequinho cheio de numeros e letras que a pessoa tem q digitar pra acessar algum formulario ou enviar coisas pela internet).

Mas tem um projeto que é bem interessante: o reCaptcha. Ele funciona da seguinte maneira: Os criadores do projeto estão ajudando a digitalizar um monte de livros, pro Internet Archive. O problema é que os OCR's dos scanners não são perfeitos. Daí eles tiveram a seguinte idéia: colocar duas palavras no captcha.

A primeira é uma palavra que o scanner conseguiu reconhecer, e a segunda é uma palavra estranha ou desconhecida (em 90% das vezes, mal reconhecida pelo scanner). Daí pedem pro usuário digitar as duas. Se ele digitou a primeira corretamente, são grandes as chances de a segunda também estar certa. Então eles descobrem qual é a palavra estranha e adicionam ela à digitalização do livro.

Legal né?

Aqui tá o site do reCaptcha, pra darem uma olhada: reCaptcha

Té mais o/

segunda-feira, 17 de setembro de 2007

Sony T200 com detector de sorrisos

Confesso que fiquei impressionado com esse recurso da sony T200, ela identifica um sorriso na foto e captura automaticamente. Legal né? Clica na imagem abaixo que vai pra um link onde tem um video que demonstra o treco.

Novo? não sei... sei que eu fiquei impressionado e com medo do que podem inventar =) e se vc também gostou, vc pode comprar uma dessas pela bagatela de R$1199,00 no Mercado Livre


That's all folks!

Albatross18 Season 3

Tá chegando a nova temporada do meu MMOPG favorito: o Pangya! (Albatross18, nos EUA).

Taí um vídeo mostrando como vai ser o treco:



Façam o download do jogo, é bem legal =D

Extrair um valor utilizando String.replaceAll()

Há pouco tempo, eu e o Highlander postamos coisas baseadas em JFormattedTextField. Muitas das coisas que são colocadas em JFTF são posteriormente armazenadas em banco de dados ou arquivos de texto (alguém ainda usa arquivo de texto pra armazenar coisas).

Porém, é semanticamente errado armazenar um telefone ou um cpf utilizando Varchar (ou algo semelhante). Por isso, é necessário extrair a parte numérica da String, pra depois poder utilizá-la da maneira correta.

Aqui vai um jeito simples de extrair coisas, usando o método replaceAll:

Exemplo: extrair os números de um cpf:


String cpf = "123.456.789-10";
cpf = cpf.replaceAll("[\\D]", "");
int tal = Integer.parseInt(cpf);


No caso, eu usei o \D (o Java considera a barra invertida um caracter especial, usado em caracteres de escape, então é preciso inserir duas barras, pra ele considerar uma).

O replaceAll faz a substituição de um pedaço da String por outro, utilizando expressões regulares. No código acima, poderia ter sido utilizado a seguinte expressão:

cpf.replaceAll("[^0-9]", "");

ou seja, tudo que não estiver na faixa entre 0 e 9.

Aqui vão alguns macetes de expressões regulares:

[] (colchetes) - Agrupadores.
^ (acento circunflexo) - Negação.
. (ponto) - Qualquer caracter.
- (hífen) - Indica faixa de caracteres. 0-4 equivale a 0,1,2,3,4, por exemplo.
\\d - Todos os dígitos de uma String. Equivale a [0-9].
\\D - Todos os não-dígitos de uma String. Equivale a [^0-9].
\\s - Caracteres "whitespace" (espaço, tab, retorno de carro, etc).
\\S - Caracteres "não-whitespace". Equivale a [^\\s].
\\w - Letras, números e "_". Equivale a [_0-9a-zA-Z].
\\W - Outros caracteres. Equivale a [^\\w]

Esses daí são os principais. Se quiser saber mais sobre expressões regulares em Java, aqui tem um tutorial bem interessante, feito pela Sun...

Té mais
o/

quarta-feira, 12 de setembro de 2007

Conversão de formatos nativos (ou não) em Java

Você é daqueles que sempre teve problema pra converter int pra String, String pra long, char pra String e o escambau?

Aqui vai um pequeno manual que vai incrementar (e muito) sua capacidade de fazer gambiarras estilosas:

Converter int pra String (funciona também com float, double e long):


String strI = Integer.toString(42);
String strF = Float.toString(42F);
String strL = Long.toString(12L);
String strD = Double.toString(3.1415);


Converter String pra int (e float, double e long):


int i = Integer.valueOf("12").intValue();
//ou int i = Integer.parseInt("12");
float f = Float.valueOf("12").floatValue();
double d = Double.valueOf("12").doubleValue();
long l = Long.valueOf("12").longValue();


Converter decimal (base 10) pra binário (base 2):


String bin = Integer.toBinaryString(42);


Converter decimal pra hexadecimal:


int i = 42;
String s = Integer.toString(i, 16);


ou, do jeito mais legal:


int i = 42;
Integer.toHexString( 0x100 | i).substring(1).toUpperCase();


Converter hexadecimal pra decimal:


int i = Integer.parseInt("CAB0", 16);


Converter decimal pra base n:


int i = Integer.parseInt(Integer.toString(42), n);


Converter código ASCII pra String:


int i = 64;
String aChar = new Character((Char)i).toString();


Converter boolean pra int (he he he, operadores ternários rules):


boolean b = true;
int i = b ? 1 : 0;


É isso, se eu lembrar, eu posto mais coisas aqui...

Té o/

terça-feira, 11 de setembro de 2007

Criando jars no Eclipse

Quem já tentou criar um .jar no Eclipse notou que a experiência não é das mais compensadoras. Criar o HelloWorld.jar é facílimo, ao melhor estilo NN(NN)F.

O problema surge quando você tenta exportar o ProgramaComercialComAcessoAMilharesDeBibliotecasEDriversExternos.jar

Eu precisei fazer isso, e nunca consegui sem passar umas duas horas tentando e acabar mexendo no manifest.txt na unha.

Daí eu conheci o FatJar (que nome lindo, FatJar. Tudo que é gordo impõe respeito). É um plugin do eclipse que faz o trabalho sujo pra gente.

Como instalar o fatjar:

Extraia a pasta "plugins" do arquivo zip que você baixou, recorte esta pasta e cole dentro da pasta do eclipse (se você usa windows, vai aparecer uma telinha dizendo que os arquivos duplicados serão sobrescritos, aperte "sim") e reinicie o eclipse.

Depois é só acessar:

File > Export > Other > Fat jar exporter.

(Se não existir o "Fat jar importer", vá na linha de comando, ache a pasta do eclipse e execute o comando eclipse -clean)
O resto é quase igual ao exportador "nativo" do Eclipse.

Se você precisa de um jar pra entregar na próxima aula, ou pra entregar amanhã, quando eles vão encerrar a fase de desenvolvimento do software, esse plugin pode ser a diferença entre você se dar bem ou ficar com aquela cara de coitado tentando fazer todo mundo acreditar que o cachorro comeu o seu pen drive.

Faça o download do FatJar aqui.
Veja a página do projeto aqui.

PS: O único contra que eu achei foi o fato de ele não se importar com aquilo que você quer. Se você usa apenas uma parte de uma biblioteca "abrangente" (um driver de conexao com banco de dados de uma biblioteca que oferece suporte a várias versões, por exemplo), ele enfia no seu jar a biblioteca toda, e não só aquela classezinha de 1kb que você precisa. Mas isso é absolutamente contornável, e bem mais fácil de ser resolvido do que fazer o treco todo na mão.

segunda-feira, 10 de setembro de 2007

JFormattedTextField em JTable

Uma outra coisa legal sobre JFormattedTextField (que, de agora em diante, será chamado de JFTF) é que ela pode ser usada em outros componentes do Java. Aqui eu vou mostrar como fazer uma célula do JTable ficar formatadinha certinho:


public class TabelaJFTF extends JFrame{
MaskFormatter cep;
JFormattedTextField jftf;
public TabelaJFTF(){
super("Testando JTable com JFTF");

////// Parte que interessa /////
try{
cep = new MaskFormatter("#####-###");
cep.setPlaceholderCharacter('_');
}
catch(ParseException excp){
e.printStackTrace();
}
// Jogando a máscara no JFTF
jftf = new JFormattedTextField(cep);
// Título das colunas
String[] colunas = {"Nome", "Cidade", "CEP"};
// conteúdo da tabela
// (pode ser um select, qqr coisa)
Object[][] conteudo = {
{"Nome 1", "Cidade 1", "12345-678"},
{"Nome 2", "Cidade 2", "91011-121"}
};
JTable tabela = new JTable(conteudo, colunas);
TableColumn col = tabela.getColumnModel().getColumn(2);
// Aqui a mágica acontece!
col.setCellEditor(new DefaultCellEditor(jftf));
tabela.setPreferredScrollableViewportSize(new Dimension(350, 50));

///// Parte que não interessa
Container c = getContentPane();
c.setLayout(new FlowLayout());
JScrollPane scrollPane = new JScrollPane(tabela);
c.add(scrollPane);
setSize(400, 300);
setVisible(true);
}
}


Pra ver se funcionou, chame a classe TabelaJFTF:


TabelaJFTF tabela = new TabelaJFTF;
tabela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);


Lembrando que, desse jeito, o valor só será formatado automaticamente quando a célula for editada, ou seja, quando a tabela é exibida, as colunas serão exibidas como foram declaradas no construtor da tabela.

Por agora é isso.

Té o/

domingo, 9 de setembro de 2007

JFormattedTextField

Hi dears....
Meu primeiro post será sobre JFormattedTextField =) isso é uma mão na roda na hora de trabalhar com CEP (00.000-000), CPF(000.0000.000-00), Telefone((00)0000-0000), enfim, com "fields" formulários que precisem de um "formato".
Ok, o JformattedTextField é um JTextField metido a besta que trabalha com máscara.... pelo menos é o que eu sei dele...
Mascara é uma parada que tu coloca o formato que tu quer que o teu text field tenha, por exemplo pra cpf utiliza algo mais ou menos assim:


MaskFormatter mascaracpf = new MaskFormatter("###.###.###-##");
JFormattedTextField cpf = new JFormattedTextField(mascaracpf);

Ai com a mascara criada da pra fazer um leque de coisas, como por exemplo setar os caracteres válidos praquele campo:

mascaracpf.setValidCharacters("0123456789");

e mais um monte de coisas como setar o numero de caracteres no campo, e enfim, coisas q vc descobre com o eclipse =)~
beleza,

Edit:
Pra deixar tudo no mesmo post, aqui vão algumas dicas pra usar JFormattedTextField:

Quando você cria o MaskFormatter, pode usar, ao invés de '#', outros caracteres, dependendo do tipo de restrição que você deseja implementar no JFormattedTextField. Esses caracteres são:

# = Qualquer número poderá ser inserido (0-9)
U = Qualquer letra (a-z). A máscara converterá letras minúsculas em maiúsculas.
L = Qualquer letra (a-z). A máscara converterá letras maiúsculas em minúsculas.
? = Qualquer letra (a-z). A máscara manterá a capitalização da letra.
A = Qualquer letra ou numero (0-9 a-z).
H = Qualquer caracter hexadecimal (0-9 a-f).
* = Qualquer coisa, incluindo caracteres especiais.

Pra evitar trabalho (evitar trabalho SEMPRE é bom), aqui tem algumas máscaras já prontinhas pra usar:

Telefone (internacional): "+##(##)####-####"
Telefone (nacional): "(##)####-####"
Data de nascimento: "##/##/####"
CEP: "##.###-###" ou "#####-###"
CPF: "###.###.###-##"
Placa de carro: "UUU-####"
CNPJ: "##.###.###/####-##"
Título de eleitor: "#########/##"

beijo na bunda e até segunda!

quarta-feira, 5 de setembro de 2007

Houston, we have a button!

Olha que fofinho:


DVD de 1 Tera... E um dia vão achar isso pouco...

A empresa israelense Mempile, com sede em Jerusalém, anunciou que desenvolveu um protótipo de disco ótico tão fino quanto um DVD capaz de armazenar 1 terabyte de dados.

Isso foi possível, porque o disco semitransparente conta com 200 camadas de 5GB cada. Com essa capacidade a mídia é capaz de guardar mais de 250 mil MP3s, 115 filmes em alta qualidade de DVD ou 40 de HD, comparou o TG Daily.




Bizarro.

terça-feira, 4 de setembro de 2007

Media retargeting.. Em breve no seu Photoshop

"The technique, termed seam carving, can be used to decrease, or increase the size of an image, perform image manipulations, such as object removal and even serve as an image saliency operator."
Traduzindo: A técnica, denominada seam carving (algo como "escultura de junção"), pode ser usada para diminuir ou aumentar o tamanho de uma imagem, fazer manipulação de imagens, como remoção de objetos e mesmo servir como um operador de saliências de imagem.

Essa técnica está sendo desenvolvida pelo pessoal da MERL (Mitsubishi Eletric Research Laboratories), e promete revolucionar o mercado de edição gráfica.

O vídeo é auto-explicativo. Qualquer um que já implementou um algoritmo vai ficar emocionado ao ver isso...



Como limitar a quantidade de caracteres de um JTextField

Oi povo.
Muita gente tem dúvida nisso, então eu vou postar um jeito fácil de fazer um limitador de texto pra colocar em JTextFields.

Primeiro, cria-se uma classe.

LimitadorTexto.java:


import javax.swing.text.*;

public class LimitadorTexto extends PlainDocument {

private int limite = 0;

public LimitadorTexto(int l){
this.limite = l;
}

public void insertString(int offs, String str, AttributeSet a)
throws BadLocationException {

int sobra = limite - getLength();
int comprimento = ( sobra > str.length() ) ? str.length() : sobra;
super.insertString(offs, str.substring(0, comprimento), a);
}
}



Pronto. Agora é só usar:


import LimitadorTexto;

...

private JTextField nome = new JTextField(new LimitadorTexto(x), "", 10);



Daí é só trocar o "x" pelo número de caracteres que você precisa.

(Achei esse código no Fórum Portal Java).

Amanhã eu posto um outro jeito legal de fazer isso, com direito a bloqueio de caracteres indesejáveis e tudo.

Té.

blogauthors++

Que o jogo comece!

Bora postar um código


public static void main (String [] args) {
System.out.println("Hello world!");
}

Habemos Preclog!

Tá, criei o blog.

Agora vou começar a postar. O quê? Não sei.

A princípio, tava pensando em postar código Java aqui. Algumas coisas, só pra eu não esquecer de algumas gambiarras que deram certo.

Mas daí eu pensei. Por que não postar outras coisas? Daí eu resolvi postar outras coisas. Coisas legais, que vão ensinar alguém a fazer alguma coisa (mesmo que esse alguém seja eu).

Era isso.

Té o/