Sumário
[Tutorial] Artigo no estilo tutorial passo-a-passo. [Core] Técnicas Server-side, ferramentas, IDEs, e outros assuntos que fogem às demais categorias.
Olá, eu sou o DevMan! Desta página em diante, eu estarei lhe ajudando a compreender com ainda mais facilidade o conte-údo desta edição. Será um prazer contar com sua companhia! Confira abaixo o que teremos nesta revista:
[Boas Práticas] Um dos objetivos da revista é levar para o leitor não somente as melhores técnicas, mas também as melhores prá-ticas de desenvolvimento, orientadas ao aumento da qualidade e produtividade.
Core
20 – Programação orientada a objetos com Java
Aprendendo a programar em Java – Primeiros passos
[
Adam Victor Nazareth Brandizzi]
Tutorial, Boas Práticas
28 – Utilizando Collections
Dominando as estruturas de dados em Java
[
Carlos Araújo]
Core
12 – A História da Tecnologia Java
A trajetória de uma das mais bem sucedidas plataformas de desenvolvimento do mundo
[
Bruno Souza, Fabiane Bizinella Nardon e Serge RehemEditorial
Edição
EditorEduardo Spínola (eduspinola@gmail.com)
Arte
Capa e Diagramação Romulo Araujo (romulo@devmedia.com.br)
Produção
Gerência de Marketing Kaline Dolabella (kalined@terra.com.br) Jornalista Responsável Kaline Dolabella - JP24185
Revisão e Supervisão Thiago Vincenzo (thiago.v.ciancio@devmedia.com.br) Coordenação Geral Daniella Costa (daniella@devmedia.com.br)
Atendimento ao leitor
A DevMedia possui uma Central de Atendimento on-line, onde você pode tirar suas dúvidas sobre serviços, enviar críticas e sugestões e falar com um de nossos atendentes. Através da nossa central também é possível alterar dados cadastrais, consultar o status de assinaturas e conferir a data de envio de suas revistas. Acesse www.devmedia.com.br/central, ou se preferir entre em contato conosco através do telefone 21 3382-5038.
Publicidade
Cristiany Queirozpublicidade@devmedia.com.br – 21 3382-5038
Anúncios – Anunciando nas publicações e nos sites do Grupo DevMedia, você divulga sua marca ou produto para mais de 100 mil desenvolvedores de todo o Brasil, em mais de 200 cidades. Solicite nossos Media Kits, com detalhes sobre preços e formatos de anúncios.
Ano I • Edição 01 • 2010
Fale com o Editor!
É muito importante para a equipe saber o que você está achando da revista: que tipo de artigo você gostaria de ler, que artigo você mais gostou e qual artigo você menos gostou. Fique a vontade para entrar em contato com os editores e dar a sua sugestão! Se você estiver interessado em publicar
um artigo na revista ou no site Easy Java Magazine, entre em contato com o editor, informando o título e mini-resumo do tema que você gostaria de publicar:
Eduardo Spínola - Editor da Revista eduspinola@gmail.com
É
com grande prazer que anunciamos mais uma grande novidade para a comunidade Java. Após ampliarmos a Java Magazine e lançarmos a primeira revista sobre Java totalmente digital, apresentamos agora a Easy Java Magazine. Uma revista que nasce com todos os cuidados das revistas DevMedia, como já acontece com a Clube Delphi, Java Magazine, SQL Magazine, .Net Magazine, WebMobile, Engenharia de Software Magazine, e a também recente Easy .Net Magazine.O nosso objetivo, como sempre, é de oferecer um excelente conteúdo para todos aqueles interessados em aprender, independentemente do seu nível de conhecimento. E foi pensando nisso, que resolvemos lançar a Easy Java Magazine.
Uma das nossas grandes dificuldades sempre foi conciliar edições com artigos para os diferentes leitores, sejam eles: iniciantes, intermediários ou avançados. Com esta novidade, disponibilizamos um amplo espaço para todos os leitores que estão dando seus primeiros passos na linguagem de programação mais utilizada no mundo e para os leitores, que mesmo já experientes, gostam de se manter atualizados com matérias mais introdutórias, mas não menos importantes.
Após esta breve introdução, que tal conhecermos os artigos desta edição?
Não poderíamos iniciar esta revista de outra forma que não fosse apresentando a História do Java. Para isso, convidamos três nomes que se você ainda não conhece, encontrará em artigos e muito provavelmente conhecerá em eventos Java, são eles: Bruno Souza (também conhecido como Javaman), Fabiane Nardon (líder da JavaTools Community do Java.net) e Sérgio Rehem (líder do Java Bahia). Conhecer o passado te ajudará a compreender o presente e se preparar para o futuro.
O segundo artigo aborda os primeiros passos para dominar a linguagem de programação. Em Programação orientada a objetos com Java, Adam Victor nos ensinará como se estruturam os programas Java e desenvolveremos a nossa primeira aplicação. Para completar este artigo, veja o vídeo que ensina mais alguns recursos importantes da linguagem.
Trabalhar com texto em Java é considerado por muitos um bom desafio. Para facilitar esta tarefa, na matéria elaborada por Michel de Lara, conheça as classes String, StringBuffer e StringBuilder e saiba em detalhes e na prática qual a melhor situação para empregar cada uma. No vídeo deste artigo, veja mais exemplos de uso destas classes.
Para finalizar esta edição, exploraremos um dos mais importantes recursos do Java, as collections, artigo escrito por Carlos Araújo. Aprenda o que são Collections, quais os seus elementos e como utilizá-las adequadamente nas suas aplicações. Na vídeo aula deste artigo, veremos as principais coleções e algumas boas práticas.
Deste modo finalizamos a primeira edição da Easy Java. Se você quiser apresentar elogios, críticas e sugestões, é só entrar em contato.
Seja bem-vindo à Easy Java Magazine! Boa leitura e até a próxima!
Eduardo Oliveira Spínola
Edição 01 • Easy Java Magazine
5
Trabalhando com texto em Java
MICHEL DE LARA
Conheça as classes String, StringBuffer e StringBuilder
De que se trata o artigo:
O artigo retrata sobre a manipulação de texto em Java utilizando as classes String, StringBuffer e
String-Builder, e como melhorar a utilização de memória, o desempenho do código e facilitar a sua manutenção trabalhando com objetos dessas três classes.
Para que serve:
Os métodos disponíveis na classe String podem servir para uma simples junção de texto, comparação de conteúdo, busca de determinados dados em mensagens advindas de sistemas externos, dentre muitas outras funcionalidades. As classes StringBuffer e StringBuilder, por sua vez, podem ser utilizadas
para reduzir a criação de objetos desnecessários na memória, possibilitando que uma mesma String seja modificada diversas vezes.
Em que situação o tema é útil:
Saber como funciona a criação de objetos String no pool e na memória, bem como a utilização e o resul-tado da execução dos métodos desta classe melhora o desempenho do código. Esta melhoria também é conseguida através da utilização das classes StringBuffer e StringBuilder, pois elas trabalham com objetos
String mutáveis que ocupam menos espaço em memória.
Resumo DevMan
N
este artigo serão demonstradasalgumas maneiras de como tra-balhar com “texto” na linguagem de programação Java. Das opções disponí-veis, String, StringBuffer e StringBuilder são cer-tamente as classes mais utilizadas. Cada uma delas apresenta particularidades com relação à criação de objetos na memória e no relacionamento com as variáveis de re-ferência, assim como apresentam também métodos específicos para a manipulação de seus conteúdos.
Por isso, abordaremos como fazer uso destas classes de maneira eficiente e as melhores situações onde utilizar cada uma delas.
O que são Strings?
Em Java, String é uma sequência de carac-teres utilizada para representação e ma-nipulação de texto. Quando é necessário representar informações textuais em uma aplicação, seja ela para Desktop ou Web, como nome de pessoas, informações sobre endereço ou comentários em uma matéria no jornal, instâncias da classe String serão criadas invariavelmente. Isto é, sempre que precisarmos mostrar alguma informação em um sistema, dificilmente vamos conse-guir isso sem o auxílio de Strings.
Em uma visão mais técnica, String é uma classe presente no Java desde a versão 1.0 do JDK que implementa a interface CharSe-quence (além de Serializable e Comparable, mas essas duas não são interessantes para este artigo). Assim, podemos dizer que Strings nada mais são do que uma cadeia ordena-da de caracteres.
Como utilizar Strings em Java
A classe String permite a criação de suas instâncias de diversas maneiras. Ela possui vários construtores que recebem diversos tipos de parâmetros. Pelo fato de ser uma
classe amplamente utilizada, ela também fornece um “atalho” para a criação de forma mais rápida de seus objetos, como pode ser observado no código da Listagem 1.
Vamos à explicação dos pontos perti-nentes:
• Linha 6: A classe String, assim como qual-quer classe em Java, pode ser instanciada com a utilização da palavra chave new. Neste caso, está sendo criado um objeto String vazio que é atribuído à variável de referência minhaString1;
• Linha 7: A variável minhaString1 recebe o valor “Java”. Como a variável já foi de-clarada na linha anterior, neste momento acontece apenas a atribuição do conteúdo à variável;
• Linha 8: Representa a maneira mais rá-pida e fácil de criar um novo objeto desta classe e atribuí-lo a uma variável (no caso, minhaString2);
• Linha 9: Há diversos construtores na classe String. Esta linha demonstra a utiliza-ção de um deles: passar um objeto String no
Trabalhando com texto em Java
6
Easy Java Magazine • Edição 01Listagem 1. Maneiras de declarar e inicializar Strings
1 package principal; 2
3 publicclass ClassePrincipal { 4
5 publicstaticvoid main(String[] args) { 6 String minhaString1 = new String(); 7 minhaString1 = “Java”;
8 String minhaString2 = “Java”;
9 String minhaString3 = new String(“Java”); 10 String minhaString4 = “”;
11
12 char[ ] meusChars = newchar[] {‘J’,’a’,’v’,’a’}; 13 String minhaString5 = new String(meusChars); 14 }
15 }
• Linha 10: Aqui uma String vazia é criada utilizando-se o mesmo mecanismo de “atalho” que foi demonstrado na linha 8, só que o conteúdo para o qual aponta a variável minhaString4 é uma String vazia. Pode-se dizer que, com relação ao conte-údo, as linhas 6 e 10 fazem a mesma coisa: criam uma String vazia;
• Linhas 12 e 13: Como já foi comentado neste artigo, a classe String possui diversos construtores. Não cabe aqui tentarmos demonstrar a utilização de cada um deles. Estas duas linhas demonstram mais um exemplo de como podemos criar objetos String a partir de outros objetos passados como parâmetro no construtor. A vari-ável minhaString5 tem o mesmo conteúdo das variáveis minhaString1, minhaString2 e minhaString3, porém foi inicializada de uma maneira diferente das demais, recebendo um array de char.
Estes são alguns modos de se declarar e atribuir valor às variáveis do tipo String. Agora veremos alguns dos métodos utili-zados para se manipular o conteúdo destas variáveis.
Métodos úteis da classe String
Para se trabalhar com texto, a classe String oferece diversos métodos utilitários. Por questões de espaço, não serão descritos todos aqui. Vamos apenas comentar aque-les que são mais utilizados no dia-a-dia do programador. Logicamente, dependendo do sistema que esteja sendo desenvolvido, alguns métodos serão mais utilizados que outros, mas independente do que seja
ne-cessário, a classe String oferece o suporte necessário para operações envolvendo texto: quebrá-lo em várias partes, fazer busca de determinado conteúdo, conver-ter a String em bytes, verificar se o texto começa ou termina com um dado conjun-to de caracteres, comparar se uma String é igual à outra (o método equals() é definido na classe Object), dentre outros.
public String replace(CharSequence target,
CharSequence replacement)
O método replace() faz a substituição de um determinado conjunto de caracteres por outro, retornando uma nova String. Um exemplo de sua utilização pode ser visto em fóruns de discussão, onde os administradores criam uma lista de palavras de baixo calão que não podem ser publicadas. Caso alguém escreva tais palavras, elas serão automaticamente substituídas por outras, após uma busca adequada (que pode ser feita utilizando o método contains(), explicado mais adiante). Vejamos o código abaixo:
1 String s = “Este comentário foi péssimo!”; 2 s = s.replace(“péssimo”,”ruim”); 3 System.out.println(s);
A saída na linha 3 será “Este comen-tário foi ruim!”. O método replace() é
Case Sensitive, ou seja, faz diferenciação entre maiúsculas e minúsculas. Por-tanto, se na linha 2 estivesse escrito s = s.replace(“Péssimo”,“ruim”) nada seria alterado e a frase inicial seria impressa na saída padrão. Também é válido lembrar que o método replace() busca todas as ocor-rências do primeiro parâmetro e realiza a substituição pelo segundo. Perceba o que acontece com a busca na próxima sentença:
1 String s = “Gosto de comer frango com batata. Não gosto de batata frita.”;
2 s = s.replace(“batata”,”polenta”); 3 System.out.println(s);
Aqui a impressão será “Gosto de comer frango com polenta. Não gosto de comer polenta frita.”
Por fim, o método replace() é sobrecarrega-do e pode receber apenas um caractere (sobrecarrega-do tipo primitivo char) como parâmetro para que seja feita a substituição. Exemplo:
1 String s = “arara”;
2 s = s.replace(‘a’,’e’); // recebendo um char como parâmetro
3 System.out.println(s);
A saída na linha 3 será “erere”.
public String trim()
O método trim() retorna uma String sem os espaços em branco no começo e no final da mesma. É útil quando se trabalha com preenchimento de formulários. Antes de salvar no banco de dados as informações preenchidas pelo usuário na tela, pode-se chamar o método trim() em todos os campos texto preenchidos pelo operador, de modo a evitar que espaços em branco desnecessários sejam gravados, econo-mizando espaço no banco de dados. O código abaixo exemplifica a utilização do método trim():
1 String s = “ Java Magazine “; 2 s = s.trim();
Após a execução do comando na linha 2, a variável de referência s apontará para a nova String criada sem os espaços que existiam na linha 1 (“Java Magazine”). Todavia, como pode ser observado, o espaço em branco do meio da palavra não foi removido.
public boolean contains(CharSequence s)
O método contains() não tem como retorno uma nova String, mas sim um boolean. Ele avalia se a String original contém a String passada como parâmetro para o méto-do. Este método pode ser utilizado para verificar, por exemplo, se determinado nome está na lista de aprovados de um concurso público ou vestibular. Ou ainda, se um dado específico foi recebido em uma mensagem enviada por outro sistema para realizar validação. As linhas abaixo demonstram uma utilização do método contains():1 String s = “001MARCOS PAULO M19803112”; 2 System.out.println(s.contains(“MARCOS”));
Edição 01 • Easy Java Magazine
7
public int length()
O método lengh() retorna um int indicando o tamanho da String, ou seja, a quantidade de caracteres que há na String atual. É co-mum ser utilizado em loops for e blocos de condição if. O trecho a seguir demonstra a aplicação deste método:
1 System.out.println(“ Java “.length());
A linha 1 imprimirá “6”, que é a quanti-dade de caracteres contida na String “ Java ” (aqui o método foi invocado diretamente na instância da classe, sem a utilização de uma variável de referência). Perceba que os espaços em branco também são conside-rados como caracteres. Se fizéssemos uma chamada ao método trim() encadeado com length(), da forma “ Java ”.trim().length(), a linha 1 exibiria o valor “4” na saída padrão.
public String toUpperCase()
O método toUpperCase() retorna uma nova String com o mesmo conteúdo da original, só que com todos os caracteres em letras maiúsculas. Assim como o método trim(), toUpperCase() também pode ser utilizado antes de salvar dados de um formulário na base de dados. Como as pessoas não possuem o mesmo padrão de digitação (algumas digitam todo o texto em minúsculo, Outras Começam Todas As Palavras De Uma Frase Com Letras Maiúsculas, E HÁ TAMBÉM AQUELAS QUE ESQUECEM O CAPS LOCK LIGADO), o método toUpperCase() pode ser a solução para este problema, salvando todos os dados do cliente em letra maiúscula. Veja um exemplo abaixo:
1 String s1 = “rodolfo rodrigues”; 2 String s2 = “Alfredo Augusto”; 3 String s3 = “JONNY DEBRUCE”; 4 System.out.println(s1.toUpperCase()); 5 System.out.println(s2.toUpperCase()); 6 System.out.println(s3.toUpperCase());
A saída será, respectivamente:
RODOLFO RODRIGUES ALFREDO AUGUSTO JONNY DEBRUCE
Existe ainda o método toLowerCase(), o “ir-mão menor” do método toUpperCase(), porém menos utilizado. Ele também retorna uma nova String com o mesmo conteúdo da origi-nal, mas com todos os caracteres em letras minúsculas. Se na linha 6 estivesse escrito
System.out.println(s3.toLowerCase()) a saída seria “jonny debruce”.
public String substring(int beginIndex)
O método substring() retorna uma parte do texto original a partir do índice especi-ficado. Ele recebe como parâmetro um int que indica o ponto de partida (iniciado em zero) pelo qual se deve iniciar a pesquisa. A partir deste índice o método copia tudo que estiver até o final da palavra. Há outra implementação deste método que recebe um índice para indicar o término da pes-quisa, mas ele não será abordado aqui. O método substring() pode ser útil para fazer buscas em Strings e capturar determinadas informações, por exemplo:
1 String s = “Universidade”; 2 System.out.println(s.substring(7));
Como o índice da String inicia em zero, a saída do comando será “idade”. Note que o caractere que estiver ocupando a posição do índice inicial de pesquisa também será incluído na String de resultado. A Tabela 1 demonstra o funcionamento do método para a palavra “Universidade”.
Os métodos apresentados aqui são ape-nas alguns dos muitos presentes na classe String. Porém, sabendo-se trabalhar com os que já foram citados é possível realizar muitas tarefas do cotidiano da
programa-ção em Java.
A Tabela 2 apresenta uma descrição su-cinta de outros métodos úteis presentes na classe String.
Até o momento vimos o que fazer para criar Strings e também como manipular seu conteúdo, agora vamos analisar uma das particularidades das Strings: a imutabilidade.
Como são criados objetos da classe
String
Certamente você já ouviu uma frase parecida com esta: “Strings são imutáveis, seu valor nunca poderá ser alterado”. Certo... vários artigos e livros falam da imutabilidade das Strings, mas o que isso significa na prática? O que isso influencia no meu código e como eu posso tirar proveito disso? Vamos tentar responder a estas questões. Por exemplo, quando você escreve uma linha de código parecida com esta:
String s = “Java”;
O que acontece na prática é:
1. Uma nova String com o valor “Java” é criada no pool de Strings (em breve falaremos sobre pool de Strings); 2. A variável de referência s aponta para o valor criado.
Palavra U N I V E R S I D A D E
Índice 0 1 2 3 4 5 6 7 8 9 10 11
Tabela 1. Caracteres da String “Universidade” copiados pelo método substring()
Método Descrição
public char charAt(int index) Retorna o caractere que estiver na posição do índice passado como parâmetro (iniciado em zero).
public String concat(String str) Retorna a junção da String na qual o método está sendo cha-mado adicionando ao seu final a String passada por parâmetro (“str”).
public int indexOf(int ch) Tem função inversa ao charAt(): retorna a posição (índice) em que se encontra na String o caractere pesquisado.
public boolean startsWith(String prefix) Retorna true se a String iniciar com o valor passado como parâ-metro (Case Sensitive). Caso contrário, retorna false.
public boolean endsWith(String suffix) Mesmo funcionamento do startsWith(), só que verificando o final da String na qual o método foi invocado.
public boolean equalsIgnoreCase(String anotherString)
Compara se duas Strings são iguais. Para que isso ocorra, é necessário que elas tenham o mesmo comprimento e os carac-teres correspondentes nas duas sequências sejam os mesmos, independente se maiúsculos ou minúsculos.
Trabalhando com texto em Java
8
Easy Java Magazine • Edição 01Uma vez criada no pool, a String “Java” não poderá ser alterada. Mas qual é a van-tagem disso? Simples: ela será reutilizada em outras partes do código que façam referência à mesma String (outras variáveis de referência apontarão para a mesma String no pool). É aí que entra o chamado “pool de Strings”. O pool é uma espécie de “lista” que armazena todas as Strings criadas no programa. Dessa forma, toda vez que atribuirmos uma String a uma variável de referência, antes da JVM (Java Virtual Machine) criar uma nova String na memória, ela verifica se este valor já está contido no pool. Caso positivo, não é necessário criar uma nova, fazendo com que a variável de referência apenas “aponte” para a String existente. Então, na verdade, temos um passo anterior aos dois descritos previamente:
1. A JVM verifica se a String “Java” já existe no pool;
a. Se já existe, a variável de referência s apontará para este valor;
b. Senão, uma nova String com o valor “Java” será criada no pool de Strings e a variável de referência s apontará para este valor.
Vejamos outro exemplo:
1 String s1 = “Brasil”; 2 String s2 = “Brasil”; 3 s1 = “Argentina”;
Eis o que aconteceu no código durante a sua execução (vamos assumir que este có-digo está inserido em um método main() que contém somente estas três instruções):
• Na linha 1, a JVM verificou que a String “Brasil” (CaseSensitive) ainda não havia sido criada no pool de Strings, então, criou uma nova String no pool e a variá-vel de referência s1 apontou para a String recém-criada;
• Na linha 2, antes de fazer a atribuição de valor para s2, a JVM foi novamente ao pool e verificou que já existe uma String chamada “Brasil”. Por isso, não foi criada uma nova String no pool;
• A variável s2 passa a fazer referência à mesma String criada anteriormente;
• Na linha 3 a JVM faz o mesmo procedi-mento da linha 1. Como não existe a String “Argentina”, ela cria uma nova String no pool;
• Por fim, a variável s1 aponta para a “Ar-gentina” criada no pool e deixa de apontar para a String “Brasil”.
A Figura 1 demonstra visualmente como todo esse procedimento acontece por trás dos panos.
Ok, mas o que tudo isso tem a ver com a imutabilidade das Strings?
Imagine que em outros pontos do seu código você precise alterar a String “Bra-sil”. Como essa String é compartilhada por outras variáveis de referência (s1 e s2), se não houvesse a imutabilidade, cada alteração feita em uma das variáveis que apontam para este conteúdo seria refle-tida nos demais pontos onde são feitas referências ao mesmo texto, o que poderia nos trazer problemas. Por isso que grande parte dos métodos da classe String não tem retorno void, mas sim String. Dessa forma, eles retornam sempre uma nova String modificada. A original estará lá, intacta no pool, enquanto novas Strings estarão sendo criadas. Vejamos um exemplo para ilustrar o conceito:
1 String s1 = “Meu nome era “; 2 String s2 = “Michel”; 3 String s3 = s1; 4 s1.replace(“era”,”é”);
5 String s4 = s3.replace(“era”,”sempre foi “); 6 s3 = s4 + s2;
7 System.out.println(s3);
Analisando cada uma das linhas:
• Linha 1: Criada no pool de Strings, a String “Meu nome era ” é associada à variável de referência s1;
• Linha 2: Criada no pool de Strings, a String “Michel” é associada à variável de referência s2;
• Linha 3: A variável de referência s3 passa a fazer referência à String definida na linha 1. Deste modo nenhuma nova String é cria-da no pool;
• Linha 4: Neste ponto temos uma das grandes “pegadinhas” dos exames de certificação. O resultado da execução desta linha é a criação de uma nova String, com o conteúdo “Meu nome é ”. Porém, o retorno do método não é atribuído a ne-nhuma variável de referência, deixando a nova String “perdida” no pool, pois não há ninguém que faça referência a ela. Dessa forma, a String referenciada por s1 não é alterada. As Strings “era” e “é” também são adicionadas ao pool de Strings nesta linha;
Edição 01 • Easy Java Magazine
9
• Linha 5: Novamente uma String é criada no pool, como resultado da execução do método replace(): “Meu nome sempre foi ”. Esta nova String é associada à variável de referência s4. Vale a pena ressaltar que as variáveis s1 e s3 ainda fazem referência à String “Meu nome era ”. Se a String refe-renciada por s1 tivesse sido alterada na linha 9, o resultado da linha 10 não seria o esperado, pois como s3 também referencia a mesma String, o método replace() não teria feito nenhuma alteração. Há também a criação da String “sempre foi” no pool;
• Linha 6: Vemos aqui um exemplo de como o Java oferece a sobrecarga do operador “+” para manipulação de Strings. A variável s3 recebe a concatenação (junção) das Strings referenciadas por s4 e s2. Esta é uma das maneiras mais utilizadas para unir duas ou mais Strings. O método concat() também faz concatenação de Strings, porém é menos utilizado pelo fato do operador “+” ser uma maneira mais rápida de fazê-lo;
• Linha 7: É impresso na saída padrão “Meu nome sempre foi Michel”.
Agora vamos entender quantas Strings foram criadas no pool de Strings:
• Linha 1: Uma String “Meu nome era ”;
• Linha 2: Uma String “Michel”;
• Linha 3: Nenhuma String é criada no pool, pois a String na linha 1 é reutilizada;
• Linha 4: Atenção! Aqui são criadas três novas Strings: “era”, “é” e “Meu nome é ”. Porém, nenhuma delas é referenciada por qualquer variável;
• Linha 5: Duas Strings novas são criadas: “sempre foi ” e “Meu nome sempre foi ”. Esta última é atribuída à variável s4. A String “era” já existe no pool e não será criada novamente;
• Linha 6: Mais uma String é criada no pool, “Meu nome sempre foi Michel”.
Como pudemos observar, um total de oito Strings foram criadas no pool, entre-tanto algumas delas não são referenciadas por nenhuma variável e são elegíveis para serem coletadas pelo Garbage Collector
(o funcionamento do Garbage Collector é assunto para outro artigo).
Para aperfeiçoar a utilização das Strings, uma boa prática é valer-se de um
artifí-cio bastante comum que é a criação de constantes (variáveis declaradas como public static final). Com as constantes, as Strings já são criadas no pool e podem ser reutilizadas em várias partes do código, diminuindo assim a criação de objetos desnecessários. Elas dificilmente serão elegíveis para serem coletadas pelo Garbage Collector, pois sempre haverá uma variável referenciando-a. Segue um exemplo de declaração de uma constante:
publicstaticfinal String nomeDaEmpresa = “Info Telecom LTDA.”;
Foi comentado na seção “Como utilizar Strings em Java” que a classe String apre-senta uma particularidade interessante na criação de instâncias da sua classe. Duran-te a explicação dos métodos desta classe, os exemplos demonstram a criação de Strings sem a utilização do construtor e da palavra chave new. Este é um detalhe na criação de objetos que pode fazer grande diferença com relação ao consumo de memória da aplicação. Analisemos o código abaixo:
String s = new String(“Java”);
Nesta linha, acontece a criação de uma String “Java” no pool de Strings e também um novo objeto String na memória comum, que será referenciado por s. Ou seja, sempre que é criada uma String através da palavra chave new, um novo objeto será criado na memória. A não ser que seja fundamental para o seu código, procure evitar a criação de Strings desta forma.
Durante a codificação, porém, pode ser necessária uma constante alteração de objetos String (para a criação de sentenças SQL, por exemplo). Com isso, se optar por manipular as sentenças utilizando objetos String, você poderá ter vários deles abandonados ao final da execução da consulta no pool. Para resolver este pro-blema, há outras duas classes que podem ser usadas para se trabalhar com Strings sem que sejam criados vários objetos String desnecessários e ocupar menos memória: StringBuffer e StringBuilder.
StringBuffer e StringBuilder
Conforme já descrevemos, Strings são imutáveis: elas não têm seus valores
alterados após sua criação. Entretanto, em alguns momentos necessitamos fazer várias modificações em uma mesma String. Para estes casos, as classes StringBuffer e StringBuilder auxiliam na manipulação de Strings sem a criação de vários objetos na memória e, agora sim, alterando o mesmo objeto diversas vezes. Ambas as classes têm o mesmo propósito: trabalhar com objetos de texto que podem ser alterados. No entanto, há uma diferença importante entre elas (além da classe StringBuilder estar disponível apenas a partir da versão 1.5 do JDK), a sincronização.
A classe StringBuffer é considerada uma “classe sincronizada”, ou seja, possui seus métodos sincronizados (somente uma Thread pode acessar por vez). Sabemos que não é possível declarar uma classe com o modificador de acesso syncronized, mas pode-se fazê-lo nos métodos, e é isso que a classe StringBuffer faz.
A explicação técnica sobre sincroniza-ção seria assunto para um artigo sobre “Threads”, mas basicamente podemos dizer que métodos sincronizados são mais “lentos” do que métodos não sincroniza-dos, visto que somente uma Thread pode executar cada método por vez. Assim, a classe StringBuilder seria mais indicada por ter um melhor desempenho do que sua predecessora, para aplicações nas quais a velocidade da execução é importante. A classe StringBuffer, por sua vez, é indicada para aplicações que envolvem utilização de várias linhas de execução simultâneas (threads), como sistemas Web.
Analisemos o trecho de código que uti-liza a classe StringBuilder:
1 String tabela = “funcionario”; 2 String orderBy = “ ORDER BY nome”; 3 StringBuilder sql = new StringBuilder (“SELECT cpf, nome “);
4 sql.append(“FROM “); 5 sql.append(tabela);
6 sql.append(“ WHERE sexo = ‘M’”).append(orderBy);
Strin-Trabalhando com texto em Java
10
Easy Java Magazine • Edição 01gBuilder não necessita que o resultado da execução do método append() seja atribuído novamente à variável sql que está referen-ciando o objeto (por exemplo, na linha 4 não é feito: sql = sql.append(“FROM”)). O retorno do método append() é o mesmo objeto que foi criado na linha 3, modificado de acordo com os parâmetros passados. Dessa forma, apenas um objeto StringBuilder foi criado e alterado durante a execução do código.
Um detalhe a ser notado é que, assim como a classe String, os métodos das duas outras classes têm como retorno um ob-jeto StringBuilder/StringBuffer. Assim, eles podem ser encadeados em várias cha-madas sequenciais. Apesar de dificultar um pouco a manutenção do código, é um artifício válido. Verifiquemos as seguintes instruções:
1 StringBuffer buffer = new StringBuffer(“2468”); 2 buffer.reverse().insert(1,”xxx”).append(“999”); 3 System.out.println(buffer.toString());
A saída deste código é “8xxx642999”. Para entender o que aconteceu, vejamos linha por linha:
• Linha 1: É criado um novo objeto String Buffer com o valor “2468” e atribuído à variável buffer;
• Linha 2: Aqui acontece a execução de três métodos, sendo que o resultado da chamada do método mais à esquerda será o objeto que irá chamar o método seguinte. No caso, o primeiro método a ser execu-tado será o reverse(). Como resultado desse método, temos o mesmo objeto StringBuffer
invertido, com o valor “8642”. Este objeto, por sua vez, faz uma chamada ao método insert(), que irá inserir no índice 1 (lem-brando que os índices iniciam em zero) o valor “xxx”, retornando assim o objeto StringBuffer “8xxx642”. Por fim, o método append()adiciona o conteúdo “999” ao final do objeto;
• Linha 3: Acontece a impressão na saída pa-drão do sistema do valor “8xxx642999”.
O trecho de código demonstrado acima é equivalente a:
1 StringBuffer buffer = new StringBuffer(“2468”); 2 buffer.reverse();
3 buffer.insert(1,”xxx”); 4 buffer.append(“999”);
5 System.out.println(buffer.toString());
A Figura 2 mostra visualmente como acontece a modificação do objeto StringBu-ffer na memória. Perceba que a variável bu-ffer aponta sempre para o mesmo objeto.
Além dos outros métodos que possibili-tam a manipulação de texto (insert(), delete(), reverse(), substring(), trimToSize(), replace() e de-mais), “Builders” e “Buffers” são comumen-te usadas para concacomumen-tenar mensagens (de erro, warning ou sucesso) a serem exibidas ao operador e também na criação de men-sagens que devem ser enviadas a outros sistemas (geralmente sistemas legados, es-critos em outras linguagens, como Cobol e RPG/AS400) via fila MQ series ou RTP (Real Time Protocol), para transferência de dados.
Estas mensagens geralmente possuem um layout pré-definido, contendo as informa-ções esperadas e os respectivos tamanhos dos campos a serem enviados.
Na obra de Katy Sierra e Bert Bates (vide seção Livros) é descrita outra utilização das classes StringBuffer e StringBuilder: “Um emprego comum dos objetos StringBuffer é na E/S (entrada e saída) de arquivos quando fluxos grandes de entrada e com alteração constante estão sendo manipula-dos pelo programa. Nesses casos, grandes blocos de caracteres são manipulados como unidade, e os objetos StringBuffer é (sic) a maneira ideal de manipular um blo-co de dados, passá-lo adiante e, em segui-da, reutilizar o mesmo espaço na memória para manipular o bloco seguinte.”
Aprenda na prática quando utilizar as classes String, StringBuffer e StringBuilder assistindo ao vídeo elaborado para este artigo.
Conclusões
Este artigo demonstrou a diferença entre criar um objeto String utilizando ou não o operador new e o que isso representa com relação aos objetos na memória. Também vimos alguns dos métodos mais usados da classe String, que podem ser usados desde uma simples verificação de senha em uma tela de login até tratamentos complexos em mensagens recebidas por sistemas externos. A imutabilidade das Strings também foi abordada, demonstrando como podemos evitar a criação de objetos desnecessários e o desperdício de memória com a utilização de constantes.
Por fim, comentamos sobre as classes String mutáveis: StringBuffer e StringBuilder. Elas auxi-liam o trabalho com texto fornecendo obje-tos que podem ser modificados poupando espaço na memória. Quando necessitamos trabalhar com blocos de texto que precisam ser modificados frequentemente, estas duas classes são as mais indicadas.
Certamente não abordamos tudo o que envolve a manipulação de texto. Todas as três classes dispõem de inúmeros métodos para manipular texto, e o JavaDoc da Sun fornece um grande auxílio para investiga-ções sobre seus funcionamentos.
Edição 01 • Easy Java Magazine
11
Michel de Laramichel.delara@gmail.com É Tecnólogo em Informática pela UFPR com especialização em Tecnologia da Informação. Atualmente cursa MBA Executivo em Gestão de Projetos na ESIC-PR. Em TI, atua há aproximadamente 5 anos, exercendo atividades de programação e análise de sistemas orientados a objetos. Possui as certifica-ções SCJA (96%) e SCJP 1.4 (93%)
JavaDoc da Sun para a versão 1.4 da
linguagem
java.sun.com/j2se/1.4.2/docs/api/java/lang/
String.html
Guia completo de estudos para certificação
em Java, Philip Heller e Simon Roberts, Ed. Ciência Moderna, 2004
Livro voltado para os estudos das cerificações
SCJP e SCJD. Possui linguagem simples e acom-panha um CD.
Certificação Sun para programador &
desen-volvedor Java 2 (3ª Edição), Kathy Sierra e Bert Bates, Ed. Alta Books, 2003
O livro mais indicado para estudos de certificação
para a versão 1.4 do Java. Também aborda SCJP e SCJD. Contém vários exercícios desafiadores e um conteúdo bem explicado. O livro é bas-tante divertido de ler e não há problemas com
A trajetória de uma das mais bem sucedidas
plataformas de desenvolvimento do mundo
B
RUNO
S
OUZA
, F
ABIANE
N
ARDON
E
S
ERGE
R
EHEM
A História da Tecnologia Java
12
Easy Java Magazine
-
Edição 01
De que se trata o artigo:
Nesse artigo contaremos a história da tecnologia Java. Como surgiu e evoluiu uma das mais
importan-tes tecnologias das últimas décadas, e qual foi a participação de alguns dos brasileiros que ajudaram a construir essa história.
Para que serve:
A tecnologia Java ajudou a criar a internet como conhecemos hoje, e as histórias do nascimento de Java se confundem com a evolução das redes. Conhecer essa história nos ajuda a imaginar os próximos passos e como podemos hoje, no Brasil, influenciar o futuro da tecnologia no mundo.
Em que situação o tema é útil:
A internet eliminou o atraso que existia no passado entre o lançamento de uma tecnologia ou produto e seu uso no Brasil. Com isso, desenvolvedores brasileiros têm oportunidades iguais de criar inovação com
o resto do mundo, e isso fica claro na história da tecnologia Java.
Resumo DevMan
A
Plataforma Java é um dosam-bientes de desenvolvimento de aplicações mais utilizados no mundo hoje. Desde as primeiras novidades – como JavaBeans, JDBC, Applets, AWT/ Swing, RMI – passando pelas inovações na linguagem (Annotations, Generics) e chegando até as tecnologias Enterprise Edition (EJB, Web services, JSF), Java vem constantemente mudando a forma como construímos software, criando muitas oportunidades para o desenvolvedor.
Já no lançamento da tecnologia, no iní-cio de 1995, em um mundo basicamente dominado por uma única visão de como se deveria desenvolver software, a noção revolucionária de independência de plata-forma apresentado pela primeira Máquina Virtual Java (JVM – Java Virtual Machine), integrada à nascente “World Wide Web”, colocou o mercado de desenvolvimento de software em alta rotação. Nos anos se-guintes, impulsionado pelas novas oportu-nidades de um mercado sem monopólios, novas empresas, novos modelos, novos sistemas e novas ideias chacoalharam e viraram de ponta cabeça tudo o que os de-senvolvedores tinham antes como “certo”. Esse período de inovação foi fundamental para abrir caminho para as empresas do mundo Web 2.0 de hoje.
Neste artigo, vamos conhecer alguns fatos e acontecimentos curiosos da traje-tória desta tecnologia. Vamos conhecer não apenas a história da Tecnologia Java, mas também como isso afetou a vida de desenvolvedores no Brasil, e como eles conseguiram participar e influenciar esse mercado, colocando o país como ativo produtor e criador de uma tecnologia que estava revolucionando o mundo. Durante o artigo apresentaremos alguns depoimen-tos ilustrando o quanto Java esteve e está presente na vida pessoal e profissional
dessas pessoas. Embarque nesta viagem junto conosco e comece já a sua própria história.
Como tudo começou
A história de Java começou a ser escrita quando James Gosling, Patrick Naughton e Mike Sheridan se uniram a dois fundadores da Sun, Andy Bechtolsheim e Bill Joy, para pensar sobre a nova onda do mundo digital. Eles não demoraram muito para concluir que seria a convergência de computadores aos dispositivos e eletrodomésticos utili-zados no dia a dia, tudo interconectado e remotamente controlado.
Iniciaram assim um projeto que receberia o nome de Green, com o objetivo de de-senvolver um sistema que os permitissem construir uma rede distribuída e hetero-gênea de dispositivos eletrônicos voltados ao consumidor final, todos conversando entre si. O desafio escolhido foi criar um ambiente de software que fosse super legal (é, esse era um dos requerimentos!), interessante para o mercado consumidor em geral e ao mesmo tempo atraente para
Edição 01 -
Easy Java Magazine
13
Na divisão inicial das tarefas, Mike
Sheri-dan ficou com o desenvolvimento de negó-cios, Patrick Naughton, com o sistema de gráficos, e James (que era o líder do projeto) foi estudar a linguagem de programação adequada para o projeto. Ao logo de um ano e meio, o projeto Green aos poucos foi ganhando novos membros, chegando a ter 13 pessoas (ver Figura 1).
A Linguagem
Para operar num sistema embarcado de recursos limitados, Gosling até começou a modificar e estender o C/C++ (se referia como “C++ ++ --”), mas logo abandonou a ideia em favor de uma linguagem nova, de características peculiares. Destacando algumas:
• Sintaxe parecida com C/C++: a familiari -dade com linguagens tão conhecidas faci-litaria sua disseminação e aprendizado;
• Segura: nada de ponteiros! Uma prote -ção contra programas mal intencionados querendo acessar endereços de memória indevidos;
• Confiável: imagina ter que “dar boot” em
seus eletrodomésticos a todo o momento; • Garbage collected: a coleta de lixo pro-porcionaria maior eficiência no uso da memória;
• Multiplataforma: portável para diferen -tes dispositivos, independente do tipo de CPU;
• Interpretada: para facilitar o trabalho do
“tradutor”, a linguagem deveria ser converti-da para um formato intermediário (os byteco-des) que seria enviado pela rede para executar dinamicamente no dispositivo real.
A nova linguagem chegou a ser chamada de Greentalk (as extensões dos arquivos fonte eram .gt), mas depois recebeu de Gos-ling o nome Oak, inspirado por um carva-lho que existia na frente do seu escritório. Já próximo do lançamento, por conta de uma outra linguagem homônima, o time teve que escolher outro nome. James não tem certeza absoluta de quem disse “Java” primeiro, mas era o quarto nome de uma lista que continha ainda Silk e Lyric.
No quadro “Como o Java recebeu esse nome?” apresentamos a tradução de um e-mail em que James Gosling conta a
Figura 1. The Green Team. Da esquerda para a direita, Al Frazier, Joe Palrang, Mike Sheridan, Ed Frank, Don Jackson, Faye Baxter, Patrick Naughton, Chris Warth, James Gosling, Bob Weisblatt, David Lavallee e Jon Payne. Ausentes: Cindy Long, Chuck Clanton, Sheueling Chang e Craig Forrest. (Fonte: https://duke.dev.java.net/green/GreenBBQ.jpg.)
De: James Gosling
Data: 24 de Agosto de 2007 – 20:16:58
Para: Jonathan Schwartz
Assunto: Como o Java recebeu esse nome?
A história é a seguinte:
Nós precisávamos de um nome. Estávamos usando “oak” (que eu escolhi randomicamente), e embora o time tenha se apegado e ele, os advogados responsáveis pelo registro de marcas o descartaram. Tivemos muitos debates por email sobre nomes, mas nada era resolvido. Acabamos na estranha posição em que a
única coisa que nos impedia de fazer o lançamento era o nome. Nosso líder de marketing conhecia alguém que era um “consultor de nomes” (eu não lembro o nome dele, mas ele era ótimo). Nós não podíamos pagar o preço nem tínhamos tempo para fazer um processo completo de criação de nome de produto. Ele concordou em fazer algo bem atípico, mas efetivo e rápido: ele atuou como um facilitador em uma
reunião onde uma dúzia de nós nos trancamos em uma sala por uma tarde. Neste momento ele começou perguntando questões como “Como esta coisa faz vocês se sentirem?” (Animados!) “O que mais faz com que vocês se sintam assim?” (Café, Java!*). Chegamos a um quadro coberto de palavras aleatórias. Então,
ele nos conduziu em um processo de ordenação onde finalizamos com um ranking de nomes. Acabamos com uma dúzia de nomes candidatos e os enviamos para os advogados: eles trabalharam na lista de cima para baixo até que chegaram a um nome que passou pela pesquisa deles. “Java” era o quarto nome na lista. O primeiro nome era “Silk”, que eu odiei, mas todos os outros gostaram. Meu favorito era “Lyric”, o terceiro
na lista, mas ele não passou pelo teste dos advogados. Eu não lembro quais eram os outros candidatos. Então, quem deu o nome Java? Uma reunião organizada pelo marketing, o consultor que a organizou, e um monte de nós gritando várias palavras aleatórias. Eu honestamente não tenho certeza absoluta de
quem disse “Java” primeiro, mas acredito que tenha sido Mark Opperman.
Com certeza não foi nenhuma mente brilhante de marketing usando um processo coerente e bem pensado.
A História da Tecnologia Java
14
Easy Java Magazine
-
Edição 01
história do nome Java. James explicava para o então CEO da Sun – Jonathan Schwartz – o que ele se lembrava do processo de definição do nome. Jonathan depois postou essa mensagem em seu
Figura 2. Duke pronto para a Copa de 2014!
blog. Para mais referências, consulte os Links no final do artigo.
Nascem o Star7 e o Duke
Em abril de 1991 o projeto ganhou o reforço de Ed Frank, arquiteto da SPARC station 10, que liderou o desenvolvimento do hardware. Em dois meses projetaram e construíram um PDA (Personal Digital Assistance) batizado de Star7 (ou *7). Monitor touch screen LCD colorido de 5 polegadas, rede sem fio de 900 MHz, áudio multimídia e entradas PCMCIA. O grupo conseguiu colocar nesse pequeno dispositivo o SunOS (Unix da Sun), o interpretador Oak, bibliotecas gráficas, objetos de interface, as aplicações, ima-gens, sons e animações, tudo rodando com sucesso em 4 megabytes de memória RAM. O *7 funcionava como uma espécie de controle remoto para vários dispositi-vos. Para facilitar sua utilização, foi criado um agente virtual, uma espécie de Mestre de Cerimônias, um pequeno e animado personagem que dava cambalhotas e aparecia em todas as telas do sistema. No futuro próximo, o pequeno agente se tornaria o conhecido mascote da tecnolo-gia Java, o Duke. Muitos anos depois, os desenhos do Duke foram liberados sob uma licença BSD, permitindo seu livre uso pelos desenvolvedores Java. Graças a este “ato” da Sun, o mascote pode ser customizado, por exemplo, como um torcedor do Brasil na copa do mundo (ver Figura 2)!
O “Green Team” cresceu, e virou uma subsidiária da Sun Microsystems, a Firs-tPerson. Mas logo em seguida, o projeto passou por maus momentos. Tendo perdi-do perdi-dois perdi-dos principais executivos, a Firs-tPerson não foi capaz de montar um plano de negócios consistente. Por conta disso, não conseguiu nem comercializar essa maravilha tecnológica para a indústria de eletrônicos, que era o primeiro alvo, nem para as empresas Time Warner e 3DO, como uma plataforma de set-top box para TV a cabo. O Star7 não sobreviveu (apenas seis aparelhos foram construídos), assim como a versão reduzida do SunOS. Sem sucesso, o projeto acabou incorporado novamente à Sun.
Finalmente, Java
Por volta de 1994, Bill Joy e John Gage analisavam a oportunidade representada pela Internet e pela Web. A web prometia oferecer o nível de interatividade que se esperava anteriormente para a TV Interati-va. Assim, o time tomou a decisão corajosa e, para a época, totalmente maluca, de disponibilizar o código fonte do interpre-tador Oak na internet. Focados em lançar o código fonte e fazer algo voltado para a web, criaram um browser web, chamado WebRunner (depois renomeado para Hot Java), reescreveram o compilador em Oak, e se preparavam para lançar o projeto.
No início de 1995, John Gage, Chief Scientist da Sun, fez uma apresentação não programada e totalmente de surpre-sa durante o evento Sun World. James Gosling lembra que viu John pegando alguns equipamentos e perguntou o que ele precisava. John disse que ia anunciar Java, e James se assustou, passou a mão no cabelo despenteado, juntou cabos e co-nectores, e foi junto. Assim foi anunciada a tecnologia Java para o mundo, no meio de um evento onde a Sun apresentava seus novos servidores. Pode parecer incrível, mas o pequeno desenho do Duke dando cambalhotas na tela levou o mundo da informática à loucura. No dia seguinte, as únicas notícias publicadas sobre o evento traziam a novidade: a web pela primeira vez era capaz de executar aplicações. Nos meses seguintes, Java se torna rapida-mente a tecnologia mais comentada por desenvolvedores do mundo web e causa furor nas mais diversas comunidades.
Logo após o lançamento da versão Al-pha2, a Netscape anuncia que está licen-ciando a tecnologia Java para incorporar ao seu browser web. O anúncio gerou interesse mundial, e foi quando Java começou a ser associada de fato com a Web. Quando a ver-são 1.0 foi finalmente anunciada, em Janeiro de 1996, 15 empresas já haviam licenciado a tecnologia Java incluindo as gigantes IBM, Silicon Graphics, Netscape, Oracle e Toshi-ba. Até mesmo a Microsoft havia anunciado seu interesse em incorporar Java em seu browser. O Quadro 2 - “Java no Tempo” apresenta outros acontecimentos importan-tes da história da tecnologia Java.
SouJava: “No início de 1995, depois de passar alguns anos trabalhando com redes TCP/IP, consegui uma entrevista e fui contratado na Sun Microsystems. No Brasil, a Sun basicamente vendia hardware, e, como desenvolvedor, eu imaginava tentar um espaço para trabalhar com SunOS. Tive muita sorte: na primeira semana, um instrutor americano viu meu interesse por desenvolvimento de software e me apresentou o site interno do WebRunner, onde pude baixar uma versão interna do browser e do interpretador. Poucos dias depois, John Gage apresentou Java ao mundo. Alguns meses mais tarde, quando a imprensa começou a ligar, querendo saber mais sobre a novidade, meu chefe perguntou se alguém sabia do que se tratava. Eu mostrei pra ele as coisas que eu estava desenvolvendo na versão 1.0alpha2, a primeira versão pública de Java.”
Bruno Souza
“Trabalhava no Developers Resource Center da Apple Computers e participei do encontro anual chamado WWDC, em 1995. O que era para ser um encontro para discutir o Sistema Operacional para o Macintosh (System 7), acabou se tornando um enorme Fuzzy. Só se falava de Java, que tinha sido lançada no mês anterior. Era uma loucura e, me lembro bem, falava-se desta nova linguagem até… nos banheiros. Procurei descobrir que “animal” era este que todos diziam que seria uma revolução. Empolgado, decidi dedicar minha carreira e meu futuro a esta nova linguagem. Já de volta ao Brasil, agora morando em Brasília, em Fevereiro de 1998, eu e Lu fundamos o Grupo de usuários Java do Distrito Federal, o DFJUG, que hoje conta com mais de 75.000 associados. Portanto, já são mais de 15 anos de dedicação diária à plataforma Java. Não me arrependo nem um pouco, pois o convívio permanente com esta comunidade só me fez crescer como pessoa.”
Edição 01 -
Easy Java Magazine
15
Os primeiros anos
O lançamento do Java 1.1 incorporou fun-cionalidades importantes como JavaBeans e JDBC, além de uma significativa melhora na performance com os compiladores Just In Time (JIT). A tecnologia Java ganhou maturidade e começamos a ver decisões corporativas de uso da tecnologia Java em projetos como Banco do Brasil, Bank-Boston, Baneb e muitos outros. Diversas universidades em todo o mundo adotam a linguagem Java em seus currículos. O JavaOne, evento mundial da tecnologia Java, que em sua primeira edição contava com 6 mil desenvolvedores, se torna a maior conferência de desenvolvedores do mundo e chega a ter 20 mil desenvolvedo-res pdesenvolvedo-resentes no Moscone Center em São Francisco, EUA.
Java 2
Com o passar do tempo, a tecnologia Java evoluiu de uma linguagem de pro-gramação para uma grande família de tecnologias, todas baseadas na linguagem Java e no conceito multiplataforma. Em dezembro de 1998 era lançada a versão 1.2 (codinome Playground) ou Java 2, como ficou mais conhecida. Foi quando a API gráfica multiplataforma Swing incorporou-se ao núcleo. Também surgia o largamente usado (e útil) framework de coleções do Java.
O que mais chamou a atenção, no entan-to, foi a divisão entre J2SE (Java 2 Platform, Standard Edition), a base da plataforma, J2EE (Enterprise Edition) voltada para aplicações corporativas e J2ME (Micro Edition), uma versão reduzida, específica para pequenos aparelhos. O J2EE rapida-mente se tornou a principal plataforma utilizada pelas grandes empresas do mundo todo, pois pela primeira vez elas tinham uma tecnologia sólida, confiável e multiplataforma para criar suas aplicações empresariais, principalmente web. Em-presas como IBM, BEA e Oracle lançaram seus servidores de aplicação Java EE (o “2” sairia oficialmente do nome em 2006). Logo começaram a surgir servidores de aplicação Open Source, como o JBoss e o Tomcat, que popularizaram ainda mais a tecnologia, ao permitir que qualquer
Mauricio Leal, SouJava: “Há anos, eu programava em Clipper e fazia sistemas extremamente complexos. Durante a Faculdade, vi um artigo que me chamou a atenção, apresentando uma tecnologia revolucionária capaz de rodar em vários computadores chamada de Java. Imediatamente pedi para meus colegas que tinham acesso à Internet na Faculdade (naquela época, não havia acesso à Internet como hoje) e fiz o download do primeiro JDK 1.0.1.”
Daniel de Oliveira
Serpro/JavaBahia: “Em 1997 trabalhava no Banco do Estado da Bahia – Baneb e me envolvi com o projeto do Internet Banking, um wrapper para as telas do 3270. Trabalhei com JDBC e Applets, ambiente Visual Symantec Cafe (muito bom para a época!). Saí do banco e fui para o Serpro, retomei o contato com Java em 2000/2001 numa especialização, até participar do IRPF Java, conhecer Bruno Souza e entrar para o JavaBahia. Isso mudou minha vida para valer!”
Serge Rehem
“No começo de carreira em 1996, trabalhando para a também recém-criada Visionnaire, fui encarregado de examinar uma nova linguagem da Sun, que parecia ‘quente’ devido ao embutimento no Netscape. Baixei o JDK 1.0, e logo estávamos dando o primeiro curso de Java do Brasil, antes mesmo da Sun. Começamos a usar Java pra valer quando surgiram a JSP e Swing (adotando ambas desde os primeiros betas) e implementações de CORBA que permitiam às GUIs feitas em Java falar com programas C++... afinal, o Java era muito lento para servidores. Depois do Java2 tudo mudou, o Java virou campeão no servidor, entrou também no segmento móvel, por outro lado o Java acabou virando o patinho feio dos desktops... até o surgimento da JavaFX, que tem renovado meu interesse por GUIs. Mas essa é uma nova história!”
Osvaldo Doederlein
SouJava: “No início éramos muito questionados sobre performance, devo ter discutido esse assunto umas 500 vezes! Lembro-me de um projeto de desenvolvimento de um protocolo de criptografia para o BankBoston que foi desenvolvido em C e assembler porque necessitávamos de performance. Com o lançamento da versão Java 1.1.8, que trouxe o BigInteger e o Just In Time (JIT) Compiler, fizemos uma nova implementação em Java, que era mais rápida que o código em assembler. Nos últimos 15 anos implementei vários projetos de Internet Banking, processamento de CDR de alto volume e outros que exigiam alto poder de processamento, e sempre com excelente performance. Hoje é divertido lembrar do tempo em que as discussões não se resumiam a existência de foreach na linguagem”.
Fabio Velloso
empresa e desenvolvedor tivesse acesso a esses poderosos recursos.
O Java ME também foi adotado em massa pelos fabricantes de telefones celulares, e se expandiu para outros aparelhos, como PDAs, impressoras e hoje temos até uma caneta capaz de rodar aplicações Java. Só nos aparelhos celulares, existem hoje mais de 2 bilhões de dispositivos compatíveis com Java ME.
Java Community Process – JCP
Em 1997, a Sun tentou padronizar a es-pecificação de Java através do comitê ISO/ IEC JTC1. Depois de muita discussão e pedidos de esclarecimentos por parte dos membros da ISO para aprovar a solicitação feita pela Sun, a própria empresa decidiu retirar sua solicitação e criar um comitê próprio, específico para atender as ne-cessidades da Tecnologia Java. Assim, em 1998, nasceu o Java Community Process (JCP). O JCP foi criado com o objetivo de ser um processo aberto e participativo para desenvolver e revisar as especificações da tecnologia Java, suas implementações de referência e suas suites de teste. A abertura do JCP permitiu com que mesmo empresas concorrentes da Sun se tornassem partici-pantes ativas da evolução da Tecnologia Java. Diferentemente da maioria dos processos de padronização existentes, é possível até mesmo participar como indi-víduo, sem representar uma organização, e sem pagar nada. Isso fez do JCP um ponto de atração para a discussão e evolução da tecnologia Java.
Com a criação do JCP, aumentou ainda mais o interesse na tecnologia Java, pois ela tinha se tornado uma tecnologia construí-da pela comuniconstruí-dade de empresas interes-sadas em Java e não mais algo dominado apenas pela Sun. Assim IBM, Oracle, JBoss e outras 800 empresas entraram com força no JCP e começaram a nascer diversas Java Specification Requests (JSR). JSRs são os documentos que descrevem formalmente as especificações da tecnologia Java. Hoje existem cerca de 350 JSRs que definem desde APIs bem conhecidas, como JDBC e JSPs, até APIs mais desconhecidas, como a OSS Discovery API e a Pricing API.
A História da Tecnologia Java
16
Easy Java Magazine
-
Edição 01
JEEBrasil/JavaBahia: “O ano era 1999, estava quase no meio da minha graduação quando conheci de verdade Java. Comecei a trabalhar na reescrita de dois grandes sistemas para a UFRN. O primeiro foi desenvolvido em Applet e o segundo em JSP. A satisfação em trabalhar com essa tecnologia foi tanta que em poucos dias (isso mesmo, dias!) nossa equipe teve a ideia de lançar o JSPBrasil. Era um projeto com o objetivo de disponibilizar material didático sobre a tecnologia Java/JSP. O JSPBrasil evoluiu para J2EEBrasil e JEEBrasil. Minha satisfação em trabalhar e contribuir para a comunidade continua a mesma (diria até que aumentou)”.
Ulisses Telemaco
SEA Tecnologia: “Comecei a programar em 1991, nos idos do Logo, DBaseIII, Foxpro e Clipper. Em 96, entrei na faculdade e me apresentaram o Pascal e o C. No mesmo ano, no auge da programação visual, resolvi aprender o badalado Delphi (Dominando o Delphi 2 – Bíblia, Maco Cantu) e empaquei num capítulo que tratava da tal Programação Orientada a Objetos. Sem conseguir avançar muito, matriculei-me numa disciplina de mesmo nome que fora então oferecida na universidade e fui apresentado à linguagem Java (Core Java 1st Ed). No ano seguinte, conheci o Bruno Souza em sua tradicionalíssima palestra de apresentação da tecnologia, naquela que foi, se não me engano, uma das primeiras reuniões do DFJUG. Nos 10 anos seguintes, consolidei minha carreira sobre a plataforma da Sun. Envolvi-me em vários projetos, participei de concursos, dei aulas, viajei, fui a muitos eventos, conheci profissionais brilhantes, trabalhei em ótimas empresas e até criei uma pra mim! Devo muito à tecnologia do WORA, mas devo muito mais aos amigos que construí nesta vibrante comunidade. A propósito, o livro de Delphi continua marcado no capítulo de POO até hoje e nunca mais foi aberto. Está aqui para doações (:-P ”
Alexandre Gomes
primeira inscrição individual do JCP. A participação de um brasileiro era impor-tante para levar as discussões nacionais para dentro do processo. Sendo assim, Bruno Souza se cadastrou quando ainda era necessário pagar uma taxa de 100 dólares. De acordo com Onno Kluyt, responsável pelo JCP na época, Bruno foi o primeiro e único a ter pago uma taxa para participar do JCP (cerca de um ano depois a cobrança foi abolida). Felizmente não foi o único brasileiro a participar, e outros tiveram atuações importantes, como Osvaldo Doederlein (colaborador da Java Magazine desde a primeira edição), que participou das discussões do Java SE, Michael “MisterM Santos”, que con-tribuiu na especificação de Data e Tempo, e Yara Senger, cujo projeto exemplo de JSF foi incorporado à implementação de referência.
Java 1.4, J2SE5, Java SE 6
O Java 1.4 (codinome Merlin) foi a primei-ra versão que seguiu inteiprimei-ramente o pro-cesso do JCP, através da JSR 59. Liberada em fevereiro de 2002, este importante mar-co trouxe novidades mar-como o Java WebStart (que permite baixar e executar aplicações Desktop direto do navegador, com apenas 1 clique!), a nova palavra reservada assert, a incorporação de parser XML e processador XSL (JAXP), extensões de criptografia e se-gurança (JCE, JSSE, JAAS), encadeamento de exceções e remodelagem das expressões regulares. Era um novo ânimo para os desenvolvedores, pois desde 1998 nem a plataforma nem a linguagem tinham sofrido grandes evoluções (a versão 1.3 – codinome Kestrel, de 2000 – trouxe, por exemplo, o Java Sound e o Java Platform Debugger Architecture (JPDA), pouco para causar maiores impactos).
O J2SE 5.0 ou Java 1.5, codinome Tiger, lançado em setembro de 2004 apresentou mudanças ainda mais significativas na linguagem, com destaque para anotações (“marcações” em classes, atributos e métodos, que vem – por exemplo – subs-tituindo a necessidade de arquivos de configuração), generics (notação de tipos para coleções que diminuem a obrigação de conversão explícita de tipos –
typecas-Globalcode: “Quando eu estava no meio do curso de Ciências da Computação, me apaixonando por Java, estudando Applets (final de 1999, início de 2000), um amigo veterano começava a orientação científica com uma tecnologia sensacional: Servlets! Em 2001, durante o estágio na Accenture, em um projeto Java EE que esbanjava internacionalização, fomos fazer um curso na Sun, um marco fundamental na minha vida, pois conheci Design Patterns, EJBs, o JavaMan (Bruno Souza) e o SouJava... e tive aula com o homem com quem eu iria me casar: Vinicius Senger! Em 2003, participando do segundo JavaOne, já na Globalcode, quase casada com o Vinicius, conhecemos o projeto Rave, que transformou-se em JavaServer Faces e foi recentemente incorporado à especificação Java EE 6. A história nos levou à colaboração e à criação do projeto JSF 2 Scrum Toys, que está sendo distribuído com o GlassFish e NetBeans.”
Yara Senger
ting), e enums (espécie de lista ordenada de valores, muito usadas para especificar constantes do tipo numérico). Além des-tas, uma sintaxe avançada da instrução for (uma espécie de for each) também foi incorporada, facilitando a iteração entre membros de coleção.
A última versão estável da Plataforma Java é a Java SE 6 (codinome Mustang; observe que a Sun retirou o “.0”), de de-zembro de 2006. Ganhos significativos de performance na JVM e no Swing foram os maiores benefícios. O Java SE 6 Update 10, de outubro de 2008, remodelou a ar-quitetura de Plug-ins (Applets passam a ter recursos semelhantes aos destinados a aplicações Java WebStart), o Swing ga-nha um novo e mais moderno Look&Feel (o Nimbus) e surge o Java Kernel, um conjunto mais enxuto do Java Runtime Environment (JRE), contendo as classes mais comumente utilizadas deixando as outras para serem carregadas conforme a demanda. No momento da escrita deste artigo, o Update 20 (15 de abril de 2010) era o mais recente.
JavaOne e Duke’s Award
Com o JavaOne se tornando cada vez mais importante, atraindo milhares de desenvolvedores a cada ano, a Sun de-cidiu criar um prêmio para os melhores projetos Java do ano, para ser entregue em grande estilo durante o JavaOne. E assim nasceu o Duke’s Choice Award. Simbolizado por um pequeno troféu na forma do mascote Duke, o prêmio passou a ser ambicionado por todos os desenvolvedores Java. E mais uma vez o Brasil teve destaque, ganhando três Dukes: em 2003, com o projeto do Cartão Nacional de Saúde, em 2004 com o sistema de Imposto de Renda Pessoa Física e em 2005 com o sistema de saúde de São Paulo (Figura 3).
