Easy_Java_01

Prévia do material em texto

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 Rehem
Core, Tutorial
05 – Trabalhando com texto em Java
Conhecendo as classes String, StringBuffer e StringBuilder
[ Michel de Lara ]
Editorial
Edição
Editor
Eduardo 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 Queiroz
publicidade@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
eduspinola@gmail.com
twitter.com/Java_Magazine
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 DevManNeste artigo serão demonstradas algumas 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-
teresutilizada 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 
construtor de modo a criar um novo objeto 
String. Com relação à criação de objetos na 
memória, há uma diferença considerável 
no modo como as linhas 8 e 9 o fazem. Essa 
diferença será explicada mais adiante, na 
seção “Como são criados objetos da classe 
String”;
Trabalhando com texto em Java
6 Easy Java Magazine • Edição 01
Listagem 1. Maneiras de declarar e inicializar Strings
1 package principal;
2 
3 public class ClassePrincipal {
4 
5 public static void 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 = new char[] {‘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 (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”));
Um detalhe interessanteé que o método 
contains() também é Case Sensitive. No caso 
do código acima, o resultado será true, 
porém, se a String passada como parâmetro 
estivesse escrita “Marcos”, o resultado 
seria false.
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.
Tabela 2. Outros métodos úteis presentes na classe String
Trabalhando com texto em Java
8 Easy Java Magazine • Edição 01
Uma 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” (Case Sensitive) 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 nopool 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;
Figura 1. Como acontece a criação de Strings no pool
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:
public static final 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”;
3StringBuilder sql = new StringBuilder 
 (“SELECT cpf, nome “);
4 sql.append(“FROM “);
5 sql.append(tabela);
6 sql.append(“ WHERE sexo = ‘M’”).append(orderBy);
Vejamos o que acontece a partir da linha 3. 
É criado um objeto StringBuilder e atribuído 
à variável de referência sql. Nas linhas 
seguintes, são feitas várias chamadas ao 
método append(), de modo que novos dados 
são adicionados ao objeto criado. Perceba 
que, ao contrário dos objetos String, o Strin-
Trabalhando com texto em Java
10 Easy Java Magazine • Edição 01
gBuilder 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 concatenar 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.
Figura 2. Modificações ocorridas em um único objeto StringBuffer na memória
Edição 01 • Easy Java Magazine 11 
Michel de Lara
michel.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 
tradução.
Livros
A trajetória de uma das mais bem sucedidas 
plataformas de desenvolvimento do mundo
Bruno Souza, FaBiane nardon e Serge reheM
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 DevManA Plataforma Java é um dos am-bientes de desenvolvimento de aplicações mais utilizados no 
mundo hoje. Desde as primeiras novidades 
– como JavaBeans, JDBC, Applets, AWT/
Swing, RMI – passandopelas 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 
desenvolvedores de software. O sistema 
deveria envolver arte e design, e poder ser 
implementado por um pequeno grupo de 
pessoas em menos de um ano. A meta não 
era nada fácil.
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.
* “Java” é uma gíria norte-americana para café (NT).
Como o Java recebeu esse nome?
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 touchscreen 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 dois 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.”
Daniel de Oliveira
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 presentes 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 comunidade 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.
Uma curiosidade é que saiu do Brasil a 
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 inteiramente o pro-
cesso do JCP, através da JSR 59. Liberada 
em fevereiro de 2002, este importante mar-
co trouxe novidades 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).
Grupos de Usuários e Comunidades Open Source
Quando foi lançada, a Tecnologia Java 
inovou em vários sentidos, como na 
possibilidade de software multiplatafor-
ma, na criação de ambientes visuais, no 
download de aplicações para o browser 
web, entre outras. Mas uma inovação 
Edição 01 - Easy Java Magazine 17 
Figura 3. Brasileiros JavaOne 2005. Fabiane Nardon (de Rosa, em pé) segura o Duke 
que acabara de receber pelo Sistema de Saúde de SP
JavaTools Community: “O que poucas pessoas sabem é que 
tudo o que consegui na minha carreira de “especialista” em 
Java foi por causa de uma mochila. Em 2001 encontrei com 
Bruno Souza e ele estava com uma mochila muito bacana, 
com o logo do Java. Então perguntei o que fazer para 
conseguir uma mochila daquelas, e o Bruno disse: “Fácil! 
Manda uma palestra para o JavaOne e se aceitarem, você 
ganha a mochila”. Eu achei a ideia um pouco maluca, mas 
como já trabalhava com Java há alguns anos, resolvi arriscar. 
Para minha surpresa, a palestra foi aceita e lá fui eu para 
San Francisco buscar minha mochila. Agendaram a minha 
palestra para as 23 horas. Lembro que pensei que nesse 
horário nem teria plateia, mas a sala estava lotada, a ponto 
de algumas pessoas sentarem no chão para assistir. Acho que 
foi uma das palestras mais legais que já fiz. Depois disso, os 
JavaOnes me renderam mais 8 mochilas, um Duke’s Choice 
Award, uma participação no keynote com o Scott McNealy, 
um documentário e dezenas de novos amigos. Mas aquela 
primeira mochila ainda é a mais legal de todas.”
Fabiane Nardon 
que ajudou a mudar o mundo do softwa-
re foi o fato da versão Alpha 2 de Java 
ter sido colocada na internet com todo o 
código fonte, tanto da máquina virtual, 
como do conjunto de bibliotecas. Apesar 
de nessa época já existir a definição de 
Software Livre, era ainda praticamente 
desconhecida a ideia de uma empresa 
disponibilizar sua grande inovação com 
todo o código fonte.
Java naquele momento ainda não era 
software livre (isso só veio a acontecer 
no Projeto OpenJDK), mas a possibilida-
de de aprender com o código disponível 
e participar da evolução da tecnologia 
criou ao redor de Java uma verdadeira 
paixão: desenvolvedores do mundo in-
teiro se sentiram de fato parte da grande 
inovação tecnológica daquele momento. 
Nascia a comunidade mundial de desen-
volvedores Java.
Ao mesmo tempo, a internet trazia 
novas formas de comunicação e compar-
tilhamento, e dessa combinação, nasce-
ram os Grupos de Usuários Java, grupos 
de desenvolvedores que divulgaram 
a tecnologia Java ao redor do mundo. 
Fóruns, listas de discussões, sites web, 
tutoriais, vídeos, podcasts, blogs, e mais 
recentemente, twitters e redes sociais, 
são algumas das formas que essa enor-
me comunidade utilizou para divulgar e 
“evangelizar”. Mas não só a informação 
foi multiplicada: seguindo o exemplo do 
código fonte de Java, explodiram projetos 
open source ao redor da tecnologia, pro-
jetos que reuniram desenvolvedores de 
milhares de empresas e de todas as partes 
do mundo. Java evoluía na velocidade e 
no alcance da internet, abrindo espaços e 
oportunidades para desenvolvedores de 
todos os lugares.
Vários projetos importantes surgiram, 
como projetos gerenciados por ONGs, 
como os da Apache Foundation (Tomcat, 
Ant, Jakarta e muitos outros) e ObjectWeb 
(hoje OW2, que mantém os projetos JO-
nAS, Shark e C-JDBC), e grande número 
de projetos independentes como servi-
dores de aplicações (JBoss, OpenEJB e 
Jetty), sistemas de persistência (Hiberna-
te, JORM), frameworks (Struts, Wicket e 
Velocity) e muitos, muitos outros projetos 
que fomentaram a evolução da tecnolo-
gia Java.
Nesse grande movimento de comuni-
dades, alguns projetos se sobressaíram 
e ganharam grande destaque no Brasil. 
O Projeto Javali, tocado pelo SouJava, 
deu início ao esforço mundial de libera-
ção da plataforma Java como software 
livre. Outro projeto importante é o JEDI, 
mantido pelo DFJUG, que está ajudando 
a educar milhares de desenvolvedores 
brasileiros.
JEDI – Java Education and Development Initiative
O Java Education & Development Ini-
tiative é um curso de Engenharia de Sof-
tware completo, gratuito, que conta hoje 
com mais de 210.000 alunos nas Filipinas, 
Indonésia e Vietnam. No Brasil, conta 
com mais de 44.000 alunos. É composto 
de 12 cursos, mais de 120vídeo-aulas, 
além de apostilas, exercícios, tutorias, lis-
tas de discussão e provas de certificação, 
e você não paga nada por isto. Na Uni-
versidade das Filipinas, nasceu através 
do Java Research & Development Center, 
a iniciativa JEDI, em fevereiro de 2005. 
Desde então, vem sendo desenvolvido 
como um projeto colaborativo, que conta 
com o apoio da comunidade Java em todo 
o mundo. O aluno tem gratuitamente ao 
seu dispor manuais, slides de apresenta-
ção das aulas, provas, exercícios, material 
de referência e vídeo-aulas; contando 
ainda com os softwares, o treinamento 
de instrutores, o acesso a suporte e a lista 
de discussão da comunidade. O Brasília 
Java Users Group – DFJUG – é responsável 
pela coordenação do JEDI em países de 
língua portuguesa.
A História da Tecnologia Java
18 Easy Java Magazine - Edição 01
“Em uma bela manhã de trabalho, com um rouxinol 
cantando na minha janela (sentia que algo diferente iria 
acontecer), recebi uma proposta indecorosa do Daniel 
propondo a tradução de um curso que era um sucesso nas 
Filipinas. Resolvemos que não poderíamos adotar o mesmo 
modelo, já que aqui seria melhor aulas independentes 
no modelo e-learning, fora de sala de aula. Tínhamos as 
apostilas e os slides da primeira lição, mas faltava algo, 
e após dois Cheddar McMelt e um Milk-Shake grande de 
chocolate surgiu uma daquelas ideias malucas: vídeo-aulas, 
feitas em Estúdio. Daniel comprou um quadro com um 
universo alternativo, e iríamos fazer tudo como um grande 
filme de Ficção Científica. Após gravarmos um simples vídeo 
de cinco minutos para uma apresentação na Politec e levar 
mais de oito horas de gravações, a ideia murchou como um 
balão vazio. Mas uma parte ficou: voz e imagem. A imagem 
não seria mais a nossa, e sim a dos slides com filmes que 
capturassem o que se estava fazendo no computador! 
Testamos uma série de programas e passamos a gerar as 
aulas em Flash. O toque final foi um ambiente Moodle para 
comportar tudo. E deste modo nascia o JEDI no Brasil.”
Fernando Anselmo 
Editor-Chefe da Revista Visão Ágil: “Passei grande parte 
dos anos 90 programando em Delphi e Clipper, mas no 
final da década, com a necessidade de criar soluções web e 
multiplataforma, passei a apostar em soluções mais abertas 
como PHP e Java. Nesse momento, usava a plataforma 
Java apenas para criar pequenos Applets e muitos Servlets 
monstruosos (risos). De lá para cá, acompanhei e apoiei o 
surgimento de muitas comunidades Java, colaborei com 
projetos OpenSource e com o time do NetBeans.org, escrevi 
artigos e fiz muitas palestras sobre Java. Devido ao meu 
trabalho de Coaching em Agile, venho me distanciando 
cada vez mais do uso diário da linguagem, mas continuo 
estimulando o uso da plataforma Java e torcendo pelo 
sucesso de toda a comunidade construída em torno dela.”
Manoel Pimentel
Ano No Mundo No Brasil
1995 Tecnologia Java nasce oficialmente. Primeiros brasileiros começam a estudar Java.
1996 JDK 1.0 lançado e ocorre o primeiro JavaOne.
Primeiro JavaCard é lançado.
Primeiro evento de Java no Brasil, o JavaDay.
1997 JavaCard 2.0 lançado e o JavaOne deste ano 
atrai 8.000 desenvolvedores, tornando-se 
oficialmente a maior conferência de desenvol-
vimento de software do mundo.
JDK 1.1 é lançado.
Banco do Brasil adota Java.
1998 Java Community Process (JCP) é formalizado.
J2SE 1.2 é lançado.
Primeiro SmartCard com Java é lançado pela 
VISA.
Fundado o DFJUG
1999 Código fonte do Java 2 é distribuído e o J2EE 
beta é lançado.
JavaOne reúne 20.000 desenvolvedores
Fundado o SouJava. Em pouco tempo, o SouJava e o 
DFJUG se tornam os maiores grupos de usuários Java do 
mundo.
2000 Mais de 400 grupos de usuários Java no 
mundo.
J2SE 1.3 é lançado.
Java é a linguagem do ano pela Revista Info.
2001 Primeiro JavaOne fora dos EUA é feito no 
Japão.
Pesquisa do Gartner mostra que 62% das companhias 
brasileiras já usam Java.
2002 J2EE atinge dois milhões de downloads.
J2SE 1.4, a primeira versão desenvolvida sob o 
JCP, é lançada.
Lançada a Java Magazine número 1. Matéria de capa: “O 
Brasil tem Java”.
Sistema Brasileiro de Pagamentos (SPB) é lançado com a 
tecnologia Java.
2003 Java.net, o portal para a comunidade Java, é 
lançado.
Projeto do Cartão Nacional de Saúde ganha o Duke’s 
Choice Award no JavaOne.
2004 Java 5 é lançado. IRPF em Java é lançado e ganha o Duke’s Choice Award.
2005 Número de desenvolvedores Java atinge 4.5 
milhões.
Java chega a Marte através do Mars Rover, que 
possui Java embutido.
Iniciativa JEDI é lançada nas Filipinas.
Sistema de Saúde de São Paulo ganha o Duke’s Choice 
Award.
Brasileiros criam o Juggy, mascote dos grupos de usuá-
rios Java, que é adotado por JUGs do mundo todo.
2006 Anunciado que Java será open source. A plata-
forma Java EE é aberta como open source sob 
o projeto GlassFish.
Java 6 é lançado.
Tradução das APIs do OpenJDK para português. 
Jonathan Schwartz, CEO da Sun, encontra Lula.
2007 Java se torna totalmente Open Source.
Ocorre o primeiro CommunityOne, uma 
conferência conjunta com o JavaOne focada 
em Open Source.
JavaFX é anunciado.
Uma brasileira é escolhida para o OpenJDK Interim 
Governance Board.
Iniciativa JEDI chega ao Brasil (e mais oito países que 
falam a língua portuguesa) coordenado pelo DFJUG.
2008 Java é embutido em diversos dispositivos, 
como canetas inteligentes e Blu-Rays.
Diversas ferramentas para JavaFX são disponi-
bilizadas.
Linguagens como Groovy, Scala, JRuby e Jyn-
thon ganham destaque no JavaOne.
 JavaBahia realiza em seu blog, pelo 1º ano, a cobertura 
do JavaOne em tempo real.
O IRPF é citado pela Sun como responsável por um dos 
maiores picos de download do Java.
Rogério Santana, do Ministério do Planejamento, divide 
com Bruno Souza uma sessão técnica sobre produção e 
uso do software livre no governo brasileiro.
2009 Sun é comprada pela Oracle. IRPF é lançado só em Java e é utilizado no preenchimento 
de mais de 25 milhões de declarações. Versões em outras 
linguagens são descontinuadas.
2010 James Gosling, o pai do Java, deixa a Oracle. Norma para o Ginga-J, que permite Java na TV Digital 
brasileira, é aprovada.
No Brasil, a comunidade de Grupos de 
Usuários Java (JUGs) é muito forte e ativa, 
tendo inclusive ajudado a fundar a comuni-
dade mundial de JUGs. Ainda neste ponto, 
o Brasil é um importante fomentador: hoje 
existem brasileiros com grande atuação em 
importantes comunidades como a JavaTools, 
JUGs, JSRs, Apache, JBoss, e muitas outras.
Conclusão
A tecnologia Java revolucionou o mercado de 
desenvolvimento de software com uma ideia 
simples: a independência de plataforma. No 
Java no Tempo
Edição 01 - Easy Java Magazine 19 
Brasil, essa ideia ganhou força, já que o país bus-
cava independência tecnológica. Para nós, Java 
surgiu em um momento único, onde a Internet 
começava a ganhar força, e não havia mais um 
atraso entre a tecnologia surgir lá fora e poder 
ser usada aqui. Vários profissionais aprovei-
taram a oportunidade e fizeram do Brasil um 
dos maiores participantes no mercado Java 
mundial. A Tecnologia Java cresceu e evoluiu, 
muito com a participação dos nossos desenvol-
vedores "tupiniquins". Grandes projetos feitos 
no Brasil ganharam destaque mundial, e o país 
foi participante ativo dessa evolução.
Com o Java Livre - o Projeto OpenJDK - a Tec-
nologia Java ganha um novo impulso, e as novas 
versões têm tudo para serem mais inclusivas, 
mais participativas, e com maiores chances 
para profissionais brasileiros. Com Java sendo 
fortemente utilizada desde ambientes de TV 
https://duke.dev.java.net/green/
Uma breve história do projeto Green.
http://www.javaworld.com/javaworld/jw-