Treinamento Básico de Java · •Em Java, existe APENAS herança simples •Todos os objetos em...
Transcript of Treinamento Básico de Java · •Em Java, existe APENAS herança simples •Todos os objetos em...
Treinamento Básico de Java Karen Frigo Busolin
Março / 2010
1
Java
Java não é somente uma linguagem de programação
orientada a objeto, mas também é um conjunto de
tecnologias que auxilia no desenvolvimento de
softwares de forma robusta e segura.
2
Características
• Independente de plataforma ▫ Programa é compilado em bytecode. Não é possível executar o
bytecode por ele mesmo, pois ele não é um código nativo,
sendo assim, para executá-lo é necessário uma JVM.
▫ A JVM é uma aplicação nativa que interpreta o bytecode.
3
Características (continuação)
• Fácil Utilização
▫ estilo simples
▫ construída à partir de conceitos de linguagem de programação moderna
▫ conceito de objetos
▫ possui rica API
• Segurança
▫ JVM é reponsável pela execução dos progamas
▫ manipulação automática da memória mais segura
▫ não é possível acessar a memória diretamente
4
Características (continuação)
• Escabilidade
▫ fácil adaptação com aumento de oportunidades
• Suporte
▫ comunidades, sites oficiais, sourceforge, fóruns, etc
▫ JDK sempre com atualizações
• Robusta
▫ atende suas expectativas
▫ realiza automaticamente o gerenciamento de memória, utiliza o garbage collector
▫ proporcinal um mecanismo de tratamento de exceções
• Multithread
▫ realizar mais de uma ação ao mesmo tempo
5
Definições
• JRE (Java Runtime Environment) ▫ Inclui JVM e core libraries
▫ Propósito: executar o bytecode
• JDK (Java SE Development Kit) ▫ Inclui JRE, compilador e outras ferramentas
▫ Propósito: compilar os programas Java
• API (Application Programming Interface) ▫ Java API é a coleção de softwares que provê as
funcionalidades para os programas.
▫ O software é agrupado em grupo de bibliotecas de
componentes que são relacionados, como gráficos, textos,
I/O, segurança, etc
6
Sub - Plataformas
• JSE (Java Platform, Standard Edition) ▫ J2SE é basicamente o JDK (núcleo da plataforma Java)
▫ Desenvolver programas client-server e desktop
• JEE (Java Platform, Enterprise Edition) ▫ É o J2SE voltado para desenvolvimento de aplicacções multi
camadas
▫ Algumas inovações foram incluidas suporte de web services e
ferramentas de desenvolvimentos (SDK)
• JME (Java Platform, Micro Edition) ▫ Proporciona um ambiente para aplicações móveis, como
celulares, PDAS, TVs
▫ J2ME inclui a JVM e algumas classes (limitadas)
7
Configuração Ambiente
• Instalar JDK
• Configuração da Variável de ambiente
JAVA_HOME e PATH
• Verifica versão java na máquina: java -version
• Utéis\Configurando variáveis de ambiente.docx
8
Fundamentos
• Dois modelos de tipos de dados: Tipos de valor (primitivos)
Tipos de referência (objetos)
• Passagem de parâmetros em Java é feita
APENAS por valor O valor de um primitivo é ele mesmo
O valor de uma referência é o endereço em que ele reside
9
Fundamentos (continuação)
• Em Java, uma variável deve: Ser declarada antes de ser usada
Ter um tipo definido
Iniciar o valor dela antes de começar a usá-la
Só pode ser usada dentro do escopo onde ela foi
declarada
• Variáveis/Herança: super: refere-se a superclasse imediata
this: refere-se a instância do objeto
• Retorno: void: define que um método não retorna nada
10
Tipos de Dados Primitivos
11
Tipo Bits Fórmula Faixa Descrição
byte 8 -2^7 à 2^7 -1 -128 ~ +127 Inteiro de 8 bits com sinal
short 16 -2^15 à 2^15 - 1 -32768 a +32767 Inteiro de 16 bits com sinal
int 32 -2^31 à 2^31-1 -2147483648 a +2147483647 Inteiro de 32 bits com sinal
long 64 -2^63 à 2^63-1 -9223372036854775808 a
+9223372036854775807 Inteiro de 64 bits com sinal
char 16 2 ^ 16 - 1 0 a 65535 Caracter Unicode (16 bits sem sinal)
float 32 Ponto flutuante de 32 bits com sinal
double 64 Ponto flutuante de 64 bits com sinal
boolean Valor indicando true ou false
Tipos de Dados Primitivos (continuação)
12
Orientação a Objetos (OO)
• Sistemas OO são: Mais fáceis de manter
Mais fáceis de entender
Mais fáceis de estender
Mais fáceis de reutilizar
• Logo, OO serve para: Aumentar a produtividade do programador
Aumentar a qualidade do software
Diminuir a complexidade
13
Classe
• É o tal componente responsável tanto pelo
encapsulamento de dados quanto pela
definição das operações do sistema
• Em outras palavras, é a abstração de
características e comportamentos de
entidades do mundo real
14
Objeto
• É uma mera instância válida de uma certa
classe.
• O Objeto terá seu própio estado e irá
acessar os comportamentos definidos pela
classe.
• Em Java, criamos objetos assim:
▫ MeuObjeto obj = new MeuObjeto();
15
OO é basicamente baseada nos princípios
• Abstração
• Encapsulamento
• Herança
• Polimorfismo
16
Abstração
• Sua compreenção do problema, sem
restrições ou características técnicas
• É através da abstração que definimos
regras de negócio
17
Encapsulamento
• É quando a forma de como algo foi construído
ou como ele funciona não necessita ser
conhecida (caixa preta)
18
Herança • É a capacidade de herdar características de outra classe, a palavra
chave reservada utilizada é extends • Sub-classe é especialização da super-classe:
Cria-se uma relação do tipo “is-a”;
• Em Java, existe APENAS herança simples • Todos os objetos em Java são filhos de java.lang.Object • O que é “herdável”?
Membros (métodos e atributos) públicos ou protected; Mesmo comportamento;
• O que não é “herdável”? Membros privados; Construtores;
Para acessar, na sub-classe, a funcionalidade do construtor da super-classe, usa-se a palavra reservada super;
19
Polimorfismo
• É a habilidade de uma certa entidade se comportar de
maneiras diferentes em contextos diferentes
• Permite que um mesmo código de uma classe seja
usado por diferentes classes
• Permite que uma classe se comporte como outras
classes:
Há uma relação do tipo “is-like-a” entre as classes
• Resulta, de modo geral, em implementações mais
abstratas
20
Polimorfismo (continuação)
• Sobrescrita de Métodos
ocorre quando na classe filha, um método
existente na classe pai é redefinido, ou seja,
sobrescrito com o novo conjunto de código a ser
executado
• Sobrecarga de Métodos
É a escrita de diferentes métodos com o mesmo
nome, porém contendo quantidade ou tipo de
parâmetros diferente
21
Polimorfismo (continuação)
22
Polimorfismo (continuação)
23
Mais sobre Encapsulamento
• Nem sempre é bom dar livre acesso aos membros da sua classe:
Aumenta a dependência entre seus objetos Dificuldade de manutenção
• O ideal é que seus dados só possam ser acessados através de métodos;
Aumenta o seu controle sobre o que o usuário pode ou não fazer com seu objeto (get / set)
• Portanto, só oferecemos ao usuário o que é realmente do objeto
24
Mais sobre Encapsulamento (continuação)
25
• Exemplo get e set de bean e servico
Packages
• Define um conjunto coerente (isto é, com a
mesma finalidade) de componentes (classes,
interfaces, beans, brokers, serviços, factories,
etc.)
• Definido pela palavra reservada package java.util.*
meupacote
26
Modificadores de Acesso
27
private Define que um método ou variavel seja acessado somente pela própria classe
protected: Permite que uma subclasse acesse um membro da superclasse, mesmo estando em
pacotes diferentes
public Permite que um identificador possa ser acessado de qualquer outra classe.
null (default) Valor default. Permite qualquer classe que esteja no mesmo pacote acesse o
identificador
static Defina um identificador de classe e não de instância, ou seja, o método ou o
atributo pertencente a classe, e não ao objeto, dessa forma, não necessita de uma
instância para que possa ser acessado
final Faz com que um identificador não possa ser alterado
Se aplicado a um atributo, indica que o valor deste não pode ser alterado
(constantes)
Se aplicado a um método, indica que o método não pode ser sobrescrito por
classes filhas
Se aplicado a uma classe, indica que a classe não pode ser herdada por outra
classe
Operadores
++, --, +, -
=, +=, -=, *=, /= (Atribuição)
% (módulo)
== e !=
~, <<, >>, |, &, ^ (xor) (Binários)
||, &&, ! (Lógicos – booleanos)
(condição) ? value-if-true : value-if-false
28
Promoção aritmética
▫ Ocorre com as operações aritméticas entre
tipos primitivos numéricos diferentes
▫ O menor tipo é automaticamente
convertido para o maior tipo
▫ CASTING: “converte” o conteúdo de uma
variável para outro tipo: Ex: long lng = (long) doubleValue; // Lembre-se
que existirá perda de precisão neste exemplo.
Ex: PessoaFisicaBean pessoaFisica =
(PessoaFisicaBean) pessoa
29
Conversão entre tipos
• nunca poderá convertar um tipo de maior
valor (bits) em um número de menos valor
automaticamente
30
Controle de fluxo
• Condicional
if (condição) { true-commands } else { false-
commands }
switch(int) {
case 1: commands; break;
case 2: commands;
case 3: commands; break;
default: commands;
}
31
Controle de fluxo (continuação)
• Comandos de repetição
while(condição) { commands }
for (início; condição; incremento)
{ commands }
do { commands } while(condição)
break / continue
32
• O método main é a chave para a JVM executar uma aplicação em
Java
Estrutura
33
Nome de classe
Função que escreve mensagem
Função main() pode ser criada em
qualquer classe!
Estrutura (continuação)
34
• Válido ▫ public static void main(String[] args) { ... }
▫ static public void main(String[] args) { ... }
▫ public static void main(String[] a) { ... }
▫ public static void main(String [] a) { ... }
▫ public static void main(String a[]) { ... }
▫ public static void main(String a []) { ... }
• Não Válido ▫ public static void main([]String args) { ... }
Esse array é usado para
receber parâmetros da linha
de comando, quando um
programa Java está sendo
executado.
Exercícios
• Desenvolver vários programas utilizando
tipos primitivos e comandos de repetição
• 1o Programa: Imprimir
• 2o Programa: Calcular idade em segundos
• 3o Programa: Calcular a média aritmética anual de uma classe, sabendo que são duas notas por semestre
• …. Vários programas
OBS: Lembre-se o arquivo deve ser salvo com o mesmo nome da classe com a extensão .java
35
Sobre classes
• Atributos São características do objeto (tipos de dados primitivos e/ou referência a
outros objetos)
• Métodos Executam alguma ação, retornando ou não algum valor
Todos os métodos em java são funções, ou seja, todos os métodos retornam valores. Caso seja necessário criar um método que nao retorne valor (comportamento de procedimento), declara-se como retorno, “void”
• Construtores
Construtores não serão herdados
Também são métodos, porém especiais, porque são executados uma única vez (na criação do objeto). Servem para inicializar os atributos da classe
36
Tipos de Artefatos
• Interface ▫ Possui apenas a declaração de métodos e constantes ▫ A classe que a implementa deve obrigatoriamente
implementar todos os métodos ▫ Serve basicamente como um “contrato” com a classe que
a implementa
• Classe Abstrata ▫ Pode conter métodos abstratos (não implementados) ▫ Pode conter métodos concretos (já implementados) ▫ Só podem ser utilizados em classes filhas (extendidas)
37
Tipos de Artefatos (continuação)
• Classe Base
▫ Capaz de gerar objetos ▫ Quando implementa uma interface, todos os métodos
estão implementados ▫ Quanto estende uma classe abstrata, na última classe a
ser extendida, tem obrigatoriadade de implementar todos os métodos abstratos
• Classe Concreta
▫ É a classe que possui o modificador “final”, esta classe não pode ser extendida
38
Regras de nomeclatura • Classes:
Primeira letra maiúscula e nomes compostos com a primeira letra maiúscula
Ter a extensão “.java” • Atributos:
Caracteres em minúsculo e nomes compostos com a primeira letra maiúscula
Nomes devem começar com uma letra ou $ _ • Constantes:
Devem conter os caracteres em maiúsculo, e nomes compostos separados com um “_”.
O nome deve começar com uma letra ou um dos caracteres especiais “$ ou _”;
• Métodos: Idem as convenções de definição de atributos
39
Não iniciar
com
número !!
Não pode
utilizadar
keyword !! Java é case sensitive
Regras • Classes:
Primeira letra maiúscula e nomes compostos com a primeira letra maiúscula
Ter a extensão “.java” • Atributos:
Caracteres em minúsculo e nomes compostos com a primeira letra maiúscula
Nomes devem começar com uma letra ou $ _ • Constantes:
Devem conter os caracteres em maiúsculo, e nomes compostos separados com um “_”.
O nome deve começar com uma letra ou um dos caracteres especiais “$ ou _”;
• Métodos: Idem as convenções de definição de atributos
40
Exceção
• Nem sempre um comportamento modelado
executa aquilo que esperamos: Podem acontecer anomalias devido entradas
indevidas
Anomalias que levam a erros
Erros que diminuem a qualidade da aplicação
• Quando este comportamento executa algo
inesperado, dizemos que houve uma exceção
41
Mas para quê tratá-las?
• Programas se tornam: Mais fáceis de desenvolver
Mais fáceis de manter
Menos propenso a bugs
Mais tolerante a falhas
42
Como tratá-las?
• Java usa um mecanismo para demarcar o
escopo em que possíveis exceções serão
tratadas (bloco try/catch/finally): try: indica que o código a seguir pode lançar uma
exceção
catch(<tipo_exceção>): bloco de código usado para
tratar uma exceção lançada dentro de um bloco try
finally: código a ser executado após um try/catch;
sempre é executado
43
Exceções: Exemplo 1
public double dividir(int a, int b){ try{ return a/b; }catch(Exception e){ e.printStackTrace(System.out); return 0; } }
44
Exceções: Exemplo 2
public double dividir(int a, int b){ try{ return a/b; }catch(ArithmeticException e){ e.printStackTrace(System.out); return 0; } }
45
Relançando Exceções
• É possível relançá-la adiante
• Para isso: A declaração do método em que a exceção puder
ser lançada tem que ser marcada como “lançadora
de exceção” (throws)
O método em si tem que relançar a exceção
adiante
Na classe de último nível utilizada a exceção deve
ser tratada
46
Exceções: Exemplo 3
public double dividir(int a, int b) throws ArithmeticException { try{ return a/b; }catch(Exception e){ log.log(e.getMessage()); throw(new ArithmeticException(e.toString())); } }
47
Dicas
• Jamais uma exceção Nunca deixe o bloco catch vazio
• Não transforme exceções em um controle de fluxo
• Inclua mensagens com detalhes sobre as possíveis
causas da exceção
• Documente as exceções lançadas por um método e em que situações elas podem ser lançadas
• Prefira usar exceções-padrão
48
Arrays
• Coleção de objetos do mesmo tipo
• Todo array é um objeto, ainda que seja de tipos primitivos, ou seja, um array de “int” por exemplo, é um objeto
• Podemos ter arrays de todos os tipos, de bean, de int, de String, etc.
49
Arrays - Características
• Seus elementos são do mesmo tipo
• Arrays são imutáveis, ou seja, não são redimensionáveis
• Todo array possui o atributo length, que indica o tamanho do array (necessariamente não significa quantos elementos existem no array, e sim o dimensionamento que lhe foi dado em sua criação)
• São indexados
50
Exemplo 1 - Array
A construção de arrays se faz com o uso de [ ]
int [] i1 = new int[3] <-- Array de inteiros com 3 pos.
int i2 [] = new int[5] <-- Array de inteiros com 5 pos.
Obs.: Os identificadores acima não são tipos primitivos.
São arrays, e dessa forma são objetos, possuindo o atributo “length” que determina o tamanho do array.
51
Exemplo 2- Array
Outras formas de criar e inicializar arrays:
int[] i = new int[] {1, 2, 3, 4, 5};
int[] j = {4, 5, 6}; // unidimensional c/ 3 elementos
int[][] i2 = {{1, 2}, {3, 4}}; // bidimensional ou matriz
52
Redimensionando Arrays
• Arrays não são redimensionáveis. Para adicionar um elemento em um array, é necessário criar um novo array contendo os elementos do array anterior, mais o novo elemento, e associá-lo ao ponteiro original
• O array original é descartado
53
Exemplo 1 – Redim. Array
public int[] adicionaElementoArrayInt (int[] array, int novoElemento) {
int [] novoArray = new int [array.length + 1];
for (int i=0; i < array.length; i++) {
novoArray [i] = array [i];
}
novoArray [novoArray.length -1] = novoElemento;
return novoArray;
}
54
Exemplo 2 – Redim. Array
public int[] removeElementoArrayInt (int[] array, int elemento) {
int[] novoArray = new int[array.length - 1]; int i = 0;
boolean encontrado = false; while (i < array.length -1) {
if (!encontrado) { if (array [i] != elemento)
novoArray [i] = array [i++]; else
encontrado = true; } else {
novoArray [i] = array [i++]; }
} if (!encontrado) {
return array; } else {
return novoArray; }
}
55
Exemplo 3 – Redim. Array
/**
* Redimensiona um array com um novo tamanho
* @param oldArray o array de origem, para ser redimensionado
* @param newSize o novo tamanho do array.
* @return o novo array com os mesmo conteúdo, só que com
* seu tamanha redimensionado.
*/
public static Object redimensionaArray(Object oldArray, int newSize) {
int oldSize = java.lang.reflect.Array.getLength(oldArray);
Class elementType = oldArray.getClass().getComponentType();
Object newArray = java.lang.reflect.Array.newInstance(elementType, newSize);
int preserveLength = Math.min(oldSize, newSize);
if (preserveLength > 0) {
System.arraycopy(oldArray, 0, newArray, 0, preserveLength);
}
return newArray;
}
56
Localização
• Capacidade de configurar um sistema para se adaptar a culturas e normas de uma certa localidade
• Locale: classe que representa certas normas de uma determinada localidade geográfica;
Determinação de uma localidade ou idioma é dada através de siglas definidas pelo padrão ISO
• java.text: pacote que contém formatadores para datas, horários, números e mensagens de maneira independente de cultura ou norma
• O uso conjunto da classe Locale com os formatadores da classe java.text resultam em sistema mais adaptáveis a outras culturas
57
Datas
• Java possui três classes para trabalhar com datas: ▫ Date (java.util.Date e java.sql.Date – que herda de java.util.Date):
Representa um exato instante de tempo com precisão de milissegundos
Não faz operações com datas
▫ GregorianCalendar: Implementação da classe abstrata Calendar;
Permite fazer operações com datas, além de permitir a obtenção de informações precisas a respeito de ano, mês, dia, hora, ...
58
Exemplo – Datas e Localização //obtém o instante em que a classe foi instanciada
Date agora = new Date();
GregorianCalendar calendar = new GregorianCalendar();
// faz com que a data apontada pelo calendário seja “hoje”
calendar.setTime(agora);
int dia = calendar.get(Calendar.DATE); // obtém o dia
int mes = calendar.get(Calendar.MONTH); // o mês
int ano = calendar.get(Calendar.YEAR); // o ano
// meu aniversário: 28/07/1982
int[] data = {28, 6, 1982}; // meses começam a partir do 0
calendar.set(data[2], data[1], data[0]);
calendar.add(Calendar.YEAR, 1); // 28.jul.1983
int diaDaSemana = calendar.get(Calendar.DAY_OF_WEEK);
Locale localeBrasil = new Locale("pt", "br");
java.text.SimpleDateFormat frmtBr = new java.text.SimpleDateFormat("EEEE',' dd 'de' MMMM 'de' yyyy", localeBrasil);
java.text.SimpleDateFormat frmtEUA = new java.text.SimpleDateFormat("EEEE',' MMMM dd yyyy", Locale.US);
System.out.println(frmtBr.format(calendar.getTime()));
System.out.println(frmtEUA.format(calendar.getTime()));
NumberFormat fmtVlrBr = NumberFormat.getCurrencyInstance(localeBrasil);
System.out.println("Preço: "+fmtVlrBr.format(10.6));
NumberFormat fmtVlrEUA = NumberFormat. getCurrencyInstance(Locale.US);
System.out.println("Preço: "+fmtVlrEUA.format(10.6));
59
JavaBeans
• Um JavaBean é um componente reutilizável que tem
como finalidade representar um modelo de dados
• Utilizado para armazenar os dados de um determinado
assunto. Ex.: PessoaBean, SolicitacaoReembolsoBean,
etc.
• Deve possuir apenas atributos privados e métodos
get/set, exceto a implementação dos métodos toString,
equals, hashCode
• Devem implementar a interface Serializable ??
60
Exemplo de JavaBean abstract class BaseCodigoDescricao {
int codigo;
private String descricao;
public int getCodigo() {
return codigo;
}
public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public void setCodigo(int codigo) {
this.codigo = codigo;
}
public String toString() {
return new StringBuffer("Código: ").append(this.codigo)
.append("; Descrição: ").append(this.descricao).toString();
}
public int hashCode() {
final int PRIME = 31;
int result = 1;
result = PRIME * result + codigo;
return result;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final BaseCodigoDescricao other = (BaseCodigoDescricao) obj;
if (codigo != other.codigo)
return false;
return true;
}
}
61
Coleções - Collection Framework
• Estrutura de dados de coleções (listas, mapas, conjuntos, pilhas)
• Coleções são estruturas de dados que permitem o armazenamento arbitrário de inúmeros objetos para diversos fins;
• Algumas permitem elementos duplicados, outras não;
• Algumas são ordenadas, outras não;
• Algumas permitem a inserção do elemento null, outras não.
• Não aceitam tipos primitivos (só empacotados)
• Em Java, existem 3 tipos de coleções: Lists;
Sets; Maps;
62
Coleções
• Nas Collections, as operações de busca por elementos são realizadas com base nos métodos equals e hashCode;
• Caso estes métodos não sejam devidamente sobrescritos, não será obtido o resultado esperado quando invocados os métodos disponíveis nas Collections, como “contains, remove, indexOf…”;
• Equals deve retornar true somente quando os objetoscomparados forem iguais
• O número hashCode deve ser diferente para objetos diferentes, quando comparados;
• A collection Set baseia-se no número hashCode dos objetos para realizar buscas, ganhando em performance por isso. Números hashCode não garantem igualdade de objetos e sendo assim, quando o número hashCode de um objeto for encontrado na Colletcion, o método equals será invocado para confirmar a igualdade dos mesmos. Caso o número hashCode de um objeto não seja encontrado, o método equals não será invocado, e a busca retornará “false”.
63
64
65
66
Coleções - List
• java.util.List representa uma coleção ordenada de objetos sobre a qual se tem o controle da posição de inserção dos elementos;
• Permite a inserção de elementos repetidos (a.equals(b)) dentro da mesma coleção;
• Esta interface estende java.util.Collection;
• Classes que implementam esta interface: ArrayList – lista seqüencial/indexada; LinkedList – lista encadeada (mas pode ser usada como fila, pilha ou
de-queue); Vector – lista seqüencial sincronizada (existe uma classe Stack que
herda Vector); AbstractList – esqueleto para implementação de listas seqüenciais;
67
Exemplo de List
List lst = new ArrayList(); lst.add(0, "Java");
lst.add(new Integer(0)); String a = (String)lst.get(0);
System.out.println("item da posição 0: " + a); System.out.println("-------------------------------\nElementos de lst:");
for (Iterator it = lst.iterator(); it.hasNext();) { System.out.println(it.next());
} LinkedList linkedLst = new LinkedList();
linkedLst.addFirst("João"); linkedLst.addLast(null);
linkedLst.addLast("Maria"); String b = linkedLst.getFirst().toString();
System.out.println(b); System.out.println("-------------------------------\nElementos de linkedLst:");
for (Iterator it = linkedLst.iterator(); it.hasNext();) { System.out.println(it.next());
}
68
Coleções – Set • java.util.Set é uma coleção (sem ordem) de elementos únicos:
ou seja, não há elementos repetidos dentro de um Set;
• Implementa a definição matemática de conjunto;
• Esta interface estende java.util.Collection;
• Classes que implementam esta interface: AbstractSet – implementação mínima da interface Set; HashSet – baseada em uma tabela hash, usa uma função hash para
espalhar os elementos através do conjunto; não garante ordem de iteração de elementos;
LinkedHashSet – define ordem de iteração; TreeSet – conjunto ordenado (implementa a interface
java.util.SortedSet) de elementos (ordem ascedente); elementos neste conjunto precisam implementar a interface java.lang.Comparable;
69
70
Exemplo - Set
Set s1 = new HashSet();
System.out.println(s1.add("João"));
System.out.println(s1.add(new Integer(18))); //true
System.out.println(s1.add("João")); // opa! Já existe “João”: false!
System.out.println(s1.remove("João")); // true
boolean existe = s1.contains(new Integer(18)); // true
System.out.println(existe);
71
Coleções – Map
• java.util.Map associa uma certa chave a um único valor específico; isto é, não pode haver chaves duplicadas em um Map;
• Não estende java.util.Collection;
• (Algumas) Classes que implementam esta interface:
HashMap – tabela hash que permite null seja na chave, seja no valor; usa função hash para espalhar os valores adequadamente pela estrutura, permitindo que as operações get/put tenham tempo constante;
Hashtable – versão sincronizada do HashMap; não permite valores nulos;
TreeMap – é uma implementação da interface SortedMap usando uma árvore red-black; chaves nesta árvore precisam implementar a interface java.lang.Comparable;
72
Exemplo – Map
Map map = new HashMap(); Pessoa p1 = new Pessoa(“João”, “[email protected]”); Pessoa p2 = new Pessoa(“Maria”, “[email protected]”); map.put(p1.getNome(), p1); map.put(p2.getNome(), p2); Pessoa p3 = (Pessoa) map.remove(p1.getNome()); // p3 = p1;
73
Coleções – Observações
• Todas as coleções (exceto Hashtable e Vector) não são sincronizadas;
Isso quer dizer que duas ou mais threads podem alterar simultaneamente a estrutura da coleção;
• Para torná-las sincronizadas, é preciso usar o método Collections.synchronizedXXX() (XXX pode ser List, Map ou Set);
Map m = Collections.synchronizedMap(new HashMap());
Set s = Collections.synchronizedSet(new HashSet());
List l = Collections.synchronizedList(new ArrayList());
74
Sobre comentários
• De uma única linha // // Comentário de linha. Pode ser colocada após o final da instrução
• De uma ou mais linhas /* */ /* Comentário de mais de uma linha.
* Ocupa toda a linha até ser finalizado */
• De Documentação (JavaDoc) /** */ /**
* Documentação que será gerada automaticamente pelo JavaDoc
*/
75
76
Dúvidas / Perguntas