O documento apresenta um exemplo de código Java que demonstra o clone de objetos. Nele, um objeto é clonado usando o método clone() e é mostrado que o objeto clonado possui referência diferente do objeto original, indicando que se trata de objetos distintos.

1. Cópia

2. public static void main(String[] args) throws
CloneNotSupportedException {
Objeto meuObjeto = new Objeto();
Objeto seuObjeto = meuObjeto;
System.out.println(meuObjeto);
// resultado: br.com.douglas.Objeto@56cbfb61
System.out.println(seuObjeto);
// resultado: br.com.douglas.Objeto@56cbfb61
Objeto objetoDele = meuObjeto.clone();
System.out.println(objetoDele);
// resultado: br.com.douglas.Objeto@1134affc
}
public class Objeto implements Cloneable {
// atributos e métodos
@Override
protected Objeto clone() throws CloneNotSupportedException
{
return (Objeto) super.clone();
}
}

3. Mutable e
Immutable

4. Mutable
- É possível mudar os atributos e
estados depois que o objeto é
criado
// classe mutável
public class Pessoa {
// Campos imutáveis
private final String nome;
private final String cpf;
// Campo mutável
private EstadoCivil estadoCivil;
public Pessoa(String nome, String cpf) {
this.nome = nome;
this.cpf = cpf;
this.estadoCivil = EstadoCivil.SOLTEIRO;
}
public String getNome() { return nome; }
public String getCpf() { return cpf; }
public EstadoCivil getEstadoCivil() { return estadoCivil; }
public void setEstadoCivil(EstadoCivil estadoCivil) {
this.estadoCivil = estadoCivil;
}
}

5. Immutable
- Não se pode alterar os dados
depois de criado o objeto
- Objetos mais simples
- ThreadSafe
public final class Carta {
private final Integer valor;
private final Naipe naipe;
public Carta(Integer valor, Naipe naipe) {
this.valor = valor;
this.naipe = naipe;
}
public Integer getValor() {
return valor;
}
public Naipe getNaipe() {
return naipe;
}
}

6. Referencias

7. Referências, em Java, se diferenciam por como o coletor de lixo lida com elas
1. Strong Reference (Padrão)
2. Weak Reference
3. Soft Reference
4. Phantom Reference

8. public static void main(String[] args) {
Carro c;
// 0 objetos criados
c = new Carro();
// 1 objeto criado
c.ano = 2014;
c.nome = "Brasilia";
c = new Carro();
// 2 objetos criados - 1 inacessível
if(5>3) {
Carro c2 = new Carro();
}
// 3 objetos criados - 2 inacessíveis
Carro c3;
for (int i = 0; i < 5; i++) {
c3 = new Carro();
}
// 8 objetos criados - 6 inacessíveis
}

9. Strong Reference
- Padrão
- Só é elegível para ser coletado
quando o objeto passa a apontar
para null
Clazz c = new Clazz();
// StrongReference - não elegível para coleta - Clazz@2c8d66b2
c = null;
// elegível para coleta

10. WeakReference
- Se a JVM detectar só
WeakReferences linkadas com o
objeto, ele será marcado como
elegível para coleta
- Deve ser criado usando
java.lang.ref.WeakReference
- Objeto pode ser recuperado usando
get()
Clazz c = new Clazz();
// StrongReference - Clazz@2c8d66b2
WeakReference<Clazz> weakClazz = new
WeakReference<>(c);
c = null;
// elegível para coleta
c = weakClazz.get();
// c agora aponta para o objeto anterior - Clazz@2c8d66b2
Stack Heap
Clazz@2c8d66b2
c
weakClazz

11. Soft Reference
- Uma referência do tipo Soft é
elegível para coleta, mas só é
coletado se a JVM precisar de mais
memória.
- Deve ser criado usando
java.lang.ref.SoftReference
Clazz c = new Clazz();
// StrongReference - Clazz@2c8d66b2
SoftReference<Clazz> softClazz = new SoftReference<>(c);
c = null;
// elegível para coleta
c = softClazz.get();
// c agora aponta para o objeto anterior - Clazz@2c8d66b2

12. Phantom Reference
- Não devolve referencias (get() é
sempre null)
- Necessário o uso de uma
ReferenceQueue para receber as
referências
- Um objeto será adicionado a queue
antes de ser removido da memória
public class ClazzFinalizer extends
PhantomReference<Clazz> {
public ClazzFinalizer(Clazz referent, ReferenceQueue<?
super Clazz> q) {
super(referent, q);
}
public void finalizeResources() {
// ação de limpar
System.out.println("Limpando ...");
}

13. public static void main(String[] args) {
ReferenceQueue<Clazz> queue = new
ReferenceQueue<>();
Clazz c = new Clazz();
ClazzFinalizer finalizer = new ClazzFinalizer(c, queue);
System.out.println("Está na queue? " +
finalizer.isEnqueued());
c = null;
System.gc();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Está na queue agora? " +
finalizer.isEnqueued());
Reference<? extends Clazz> clazzFromQueue =
queue.poll();
((ClazzFinalizer)clazzFromQueue).finalizeResources();
}

14. Exceptions

15. Exception x Error
Thowable
Exception Error
RuntimeException
NullPointerException IllegalStateException
VitualMachineError
StackOverflowError
IOException
SQLException

16. main
metodo1
metodo2
metodo3
public static void main(String[] args) {
metodo1();
}
public void metodo1() { metodo2() }
public void metodo2() { metodo3() }
main
metodo1
metodo2

17. Try-Catch
- Tenta executar um bloco de código
e captura a exceção, caso seja
lançada
- Pode conter um bloco finally para
ser executado ao final,
independente do lançamento da
exceção

18. Checked x Unchecked
Sincronizado
(ThreadSafe)
Vector
● Não é obrigado fazer
tratamento
● Erros mais simples de serem
evitados
● Herdam de RuntimeException
Verificadas pelo compilador
Checked
● Tratamento obrigatório
● Erros dificeis de serem
evitados
● Herdam diretamente de
Exception
Não são verificadas pelo
compilador
Unchecked

19. public static void main(String[] args) {
int x = 0;
int y = 15;
int resultado = y/x;
}
public static void main(String[] args) {
try(Banco banco = new Banco()) {
System.out.println(banco);
} catch (Exception e) {
e.printStackTrace();
}
}
Banco banco = null;
try {
banco = new Banco();
System.out.println(banco);
} catch (Exception e) {
e.printStackTrace();
} finally {
banco.close();
}
CHECKED UNCHECKED

20. Threads

21. - Uma unidade de execução em um
processo (programa)
- Permite rodar duas ou mais tarefas
ao mesmo tempo
- Podem ser executados de forma
concorrente ou paralela
Processo
Thread
Processo
Thread
Thread
Thread

22. Concorrente x Paralelo
#1
#2
#1
#2
#1
#1 #2

23. Caracteristicas
- Não possui ordem de execução
- Cada thread possui seu próprio
contador de programa, pilha e
variáveis locais
- Compartilha a memória do processo
em que está sendo executado

24. public class ServidorTarefas {
private final ServerSocket servidor;
private final ExecutorService threadPool;
private AtomicBoolean estaRodando;
private BlockingQueue<String> filaDeComandos;
/** Constructor */
public ServidorTarefas() throws IOException {
System.out.println(" ---- Iniciando servidor ---- ");
servidor = new ServerSocket(12345);
threadPool =
Executors.newCachedThreadPool(new
FabricaDeThreads());
this.estaRodando = new AtomicBoolean(true);
this.filaDeComandos = new
ArrayBlockingQueue<>(2);
incializarConsumidores(2);
}
public static void main(String[] args) throws
IOException {
ServidorTarefas servidor = new ServidorTarefas();
servidor.rodar();
servidor.desliga();
}
public void desliga() throws IOException {
this.estaRodando.set(false);
servidor.close();
threadPool.shutdown();
}
public void rodar() throws IOException {
while(estaRodando.get()) {
try {
Socket socket = servidor.accept();
System.out.println("Aceitando novo cliente na porta " +
socket.getPort());
DistribuirTarefas distribuirTarefas = new
DistribuirTarefas(threadPool, filaDeComandos, socket, this);
threadPool.execute(distribuirTarefas);
} catch (SocketException e) {
System.out.println("O servidor desligará depois que todos os
clientes desconectarem.");
}
}
}
private void incializarConsumidores(int numConsumidores) {
for (int i = 0; i < numConsumidores; i++) {
TarefaConsumir tarefa = new TarefaConsumir(filaDeComandos);
this.threadPool.execute(tarefa);
}
}

25. public class ClienteTarefas {
public static void main(String[] args) throws Exception {
Socket socket = criaConexao();
PrintStream saida = new
PrintStream(socket.getOutputStream());
// ***** Execução das threads *****
Thread threadDeSaida = criaThreadDeSaida(socket, saida);
threadDeSaida.start();
criaEExecutaThreadDeEntrada(socket);
threadDeSaida.join();
socket.close();
}
private static Socket criaConexao() throws IOException {
Socket socket = new Socket("localhost",12345);
System.out.println("Conexão estabelecida n Pode enviar
comandos!");
return socket;
}
private static Thread criaThreadDeSaida(Socket socket,
PrintStream saida) {
return new Thread(() -> executaComandosNoServidor(socket,
saida), "ThreadDeSaida");
}
private static void imprimeRespostaDoServidor(Socket socket) {
try {
Scanner respostaServidor = new
Scanner(socket.getInputStream());
while(respostaServidor.hasNextLine()){
System.out.println(respostaServidor.nextLine());
}
} catch (Exception e) {
System.out.println("IOException: " + e.getMessage());
}
}

26. private static void executaComandosNoServidor(Socket socket, PrintStream saida) {
pegaInputEPrinta(saida);
saida.println("Encerrando o cliente " + socket);
saida.close();
}
private static void pegaInputEPrinta(PrintStream saida) {
Scanner teclado = new Scanner(System.in);
while(teclado.hasNextLine()) {
String linha = teclado.nextLine();
if (ehComandoVazio(linha)) break;
saida.println(linha);
}
}
private static boolean ehComandoVazio(String linha) {
return (linha.trim().equals(""));
}
private static void criaEExecutaThreadDeEntrada(Socket socket) {
Thread threadEntrada = new Thread(() -> imprimeRespostaDoServidor(socket), "ThreadDeEntrada");
threadEntrada.start();
}

27. Synchronized
- Permite controlar o fluxo (só uma
thread tem acesso ao método)
- Se uma segunda thread tenta
acessar o método, terá que esperar
que a primeira termine
public synchronized void remove() {
// executa remoção de alguma coisa
}
synchronized (this) {
// faz alguma coisa
}

28. Semaphore
- Permite controlar o acesso a algum
recurso através de um contador
- Podemos determinar quantos locks
queremos disponibilizar
- Se todos os locks estão ocupados, a
thread é bloqueada e espera a
liberação de algum lock
- Após a execução da thread, o lock é
liberado para a próxima thread
public class TesteSemaphore {
Semaphore semaphore = new Semaphore(3);
public void run() {
try {
System.out.println("Adquirindo lock");
System.out.println("Permits restantes: " +
semaphore.availablePermits());
semaphore.acquire();
System.out.println("Permit adquirido");
try {
// Fazendo alguma coisa complexa
// e capturando a exceção que possa ser
lançada
} finally {
System.out.println("Liberando lock ...");
semaphore.release();
System.out.println("Permits disponíveis: " +
semaphore.availablePermits());
} catch (InterruptedException e) {
System.out.println("Deu ruim");
}
}

29. Estruturas de Dados

30. Array (Vetor)
- Declaração de Arrays:
“Uma coleção sequencial, de tamanho fixo, que guarda elementos do mesmo tipo”
int[] numeros = new int[10]; -> Cria um array de 10 inteiros
LoremIpsum
15
7
9
23
4
35
0
8
42
18
LoremIpsum
0
0
0
0
0
0
0
0
0
0
numeros[0] = 42;
numeros[1] = 18;
numeros[2] = 4;
numeros[3] = 35;
numeros[4] = 0;
numeros[5] = 8;
numeros[6] = 15;
numeros[7] = 7;
numeros[8] = 9;
numeros[9] = 23;

31. Implementações de List:
1. ArrayList
2. Vector
1. Stack
3. LinkedList:
1. SinglyLinkedList (SLL)
2. DoublyLinkedList(DLL)
Listas (java.util.List)
“Uma sequencia ordenada de objetos”

32. ArrayList - Vector
- Recebe itens repetidos
- Usa um Array para organizar e armazenar os dados
- Consultas rápidas mas inserções/remoções lentas
- Aumenta e diminui dinamicamente para manter a otimização de dados

33. Sincronizado
(ThreadSafe)
Vector
● Dobra o tamanho da lista caso
todos os espaços sejam
preenchidos
● + Lento
● JDK 1.0
Não sincronizado
(ThreadUnsafe)
ArrayList
● Aumenta 50% do tamanho da
lista caso todos os espaços
sejam preenchidos
● + Rápido
● JDK 1.2
Sincronizado
(ThreadSafe)
Vector

34. Stack (Pilha)
- LIFO (Last-in-First-Out)
- Não é possível adicionar ou remover a partir de um index
- Sempre recebemos o ultimo item adicionado

35. #1
#2
#3
#4
#5
push(E e)
#1
#2
#3
#4
pop()
#5
#1
#2
#3
#4
peek()
#4

36. Queue(Interface)
- FIFO (First-in-First-Out)
- Não é possível adicionar/remover a partir de um index
- Sempre recebemos o primeiro item adicionado
- Geralmente criada usando uma LinkedList
- Queue<String> fila = new LinkedList<>();

37. #3
#2
#1
#4
offer(E
e)
#3
#2
#1
pop()
remove()
#3
#2
#1
peek()
#1
add(E e)

38. LinkedLists
- Usa referências para organizar a ordem
- Rápidas inserções mas lentas consultas
- Aumenta e diminui dinamicamente para manter a otimização de dados
- ThreadUnsafe

39. SLL x DLL
Celula Celula Celula
CelulaCelulaCelula
Celula Celula Celula
Celula Celula Celula
CelulaCelulaCelula
Celula Celula Celula

40. Sincronizado
(ThreadSafe)
Vector
● Usa 2 links de referência (anterior
e próxima)
● Ocupa mais espaço na memória
● Acesso aos elementos mais
eficiente
SLL
● Usa só um link de referência
(próxima celula)
● Ocupa menos espaço na
memória
● Acesso aos elementos menos
eficiente
DLL
Dados Link Dados LinkLink

41. Set (Interface)
- Não podem conter itens repetidos
- Implementação mais usada: HashSet
- Não é possível adquirir um item a partir de um index.
- Para recuperar algum elemento, é necessário usar um Iterator (ou um foreach, a partir
do Java 5)

42. Set<Aluno> set = new HashSet<>();
Aluno douglas = new Aluno("Douglas", 3729);
Aluno mauricio = new Aluno("Mauricio", 2587);
Aluno isadora = new Aluno("Isadora", 3652);
set.add(mauricio);
set.add(douglas);
set.add(douglas);
set.add(isadora);
System.out.println("************ Usando foreach ************");
for (Aluno aluno : set) {
System.out.println(aluno.getNome());
}
System.out.println("************ Usando metodo foreach() ************");
set.forEach(aluno -> {
System.out.println(aluno.getNome());
});
System.out.println("************ Usando iterator ************");
Iterator<Aluno> iterator = set.iterator();
while (iterator.hasNext()) {
Aluno aluno = iterator.next();
System.out.println(aluno.getNome());
}

43. Map (Interface)
Mapeia valores para suas chaves

44. #1
#2
#3
Chave Valor
x
z
y

45. HashMap
- Usa um algoritmo de espalhamento
- Rápidas consultas e inserções
Implementação mais usada da interface Map

46. Aluno(Chave)
José Maria João
Matricula(Valores
)
369 ...
123
258