1) O documento discute estruturas de dados como Map e Set, métodos importantes como put(), get(), e implementações como HashMap e HashSet. 2) Map armazena dados em pares chave-valor e não permite chaves duplicadas, enquanto Set armazena elementos únicos sem ordenação. 3) Threads permitem executar tarefas simultaneamente através de métodos como start(), run(), sleep(), enquanto synchronized garante acesso exclusivo a recursos compartilhados.

1. Estrutura de Dados
Consiste em armazenar e organizar os dados de forma eficiente para usá-los com maior eficacia tanto no
acesso quanto no gasto de memoria.
Map
Faz parte do pacote java.util, é uma coleção de pares de chave / valor “Map<k/v>”.
- Não admite repetições do objeto chave.
- Os elementos são indexados pelo objeto chave (não possuem posição).
- Acesso, inserção e remoção de elementos são rápidos.
Uso Comum: Cookies, Local Storage, qualquer modelo de chave valor.

2. Principais implementações Map
* HashMap – é uma estrutura de dados baseada em espalhamento através de uma função de
cálculo hash de uma informação chave do objeto a ser colocado na coleção de dados. Você tem sempre uma
chave e um valor associado a ela. O acesso é sempre feito pela chave. A forma de acesso é sempre muito rápida
e pode, na maioria dos casos ter complexidade de tempo de acesso qualquer constante (O(1)). Não pode ter
chaves duplicatas e não mantém um ordem específica, é considerada não ordenada.
*TreeMap – mais lento (operações O(log(n)) em arvore rubro-negra) e ordenado pelo compareTo do objeto
(ou Comparator), se eu adicionar com a mesma Chave ele vai sobrescrever a chave anterior e seu valor .
*LinkedHashMap – velocidade intermediaria e elementos na ordem em que são adicionados.

3. Alguns Métodos importantes
*put(key, value): Insere um elemento em determinada chave e pode atribuir um valor a
ela.
*remove(key): Passa a chave.
*containsKey(key): Para verificar se existe uma dada chave.
*get(key): Recupera um elemento pela chave.
*clear(): Para limpar o conjunto.

4. Mais Métodos “Map”
*Size(): Para obter o tamanho.
*keySet(): Retorna um Set<k> com as chaves contidas no map.
*values(): Retorna uma Collection<v> “Coleção do tipo valor”.
- Assim como no set a comparação de um elemento com outro no caso a Chave é
baseada em equals e hashCode e se o equals e hashCode não existir é usada a
comparação de ponteiros.

5. Código Map

6. Set
Representa um conjunto de elementos”na verdade é uma interface” pode ser usado
para armazenar um registro de logs de usuários.
*Não admite repetições.
*Elementos não possuem posição.
*Acesso, inserção e remoção de elementos são rápidos.
*Oferece operações eficientes de conjuntos: interseção, união, diferença.
Principais implementações
HashSet – mais rapido (operações O(1) em tabela hash) e não ordenado.
TreeSet – mais lento (operações O(log(n)) em arvore rubro negra) e ordenado pelo
compareTo do objeto.
LinkedHashSet – velocidade intermediaria e elementos na ordem em que são
adcionados.

7. Alguns Métodos importantes
* add(obj)
* remove(obj)
* contains(obj)
* clear(): Para limpar o conjunto.
* Size(): Para obter o tamanho.
* removeIf(remove do conjunto todo mundo que atender o predicado).
* addAll(other) – união: Adiciona no conjunto os elementos do outro conjunto, sem
repetição.
* retainAll(other) – interseção: Remove do conjunto os elementos não contidos em
other.
* removeAll(other) – diferença: Remove do conjunto os elementos contidos em other.

8. Código Set

9. Diferença entre Set e ArrayList
● Set é uma interface que herda de Collection e é um conjunto, ou seja, não aceita
dados duplicados. ArrayList é uma classe que implementa a interface List, e List é
uma coleção ordenada que é referenciada por um índice.

10. Stack (Pilha)
● Lifo “Last in first out” “ultimo a entrar, primeiro a sair”.
● Stack é uma classe com operações”Métodos” específicos para empilhar e
desempilhar elementos de uma lista.
● Métodos Utilizados
● Push- Coloca um item na pilha.
● Pop- Retira o último item da pilha e retorna uma referência a este objeto.
● Peek- Retorna o objeto que está no topo da pilha.
● IsFull- Para saber se a pilha esta cheia.
● IsEmpty- Para saber se a pilha esta vazia.
● Size- Numero de itens na pilha.

11. Código Pilha

12. Queue (fila)
● Nesta classe, o elemento é inserido na parte de trás da fila. Esta operação é chamada
de enfileiramento. Este mesmo elemento sai a partir da frente da fila, operação
chamada desenfileiramento. Esse procedimento de entrada e saída recebe o nome de
fila.
● Métodos Utilizados
● Enqueue– Coloca um item na fila
● Dequeue– Retira o primeiro item da fila.
● Peek– Retorna o primeiro item.

13. ● Assim como as Pilhas, as Filas têm operações mais restritas do que as operações das
Listas. Nas Filas, os elementos são adicionados na última posição e removidos da
primeira posição. Nas Listas, os elementos são adicionados e removidos de qualquer
posição.
● Então, podemos implementar uma Fila simplesmente colocando as restrições
adequadas nas operações de adicionar e remover elementos de uma Lista. Isso é bem
parecido ao que fizemos com as Pilhas.
Queue continuação

14. Código Fila

15. Try-Catch
● Bloco Try: Contem o código que representa a execução normal do trecho de código
que pode acarretar em uma exceção. // Tenta carregar o código.
● Bloco Catch: Contem código a ser executado caso uma exceção ocorra, deve ser
especificado o tipo da exceção a ser tratada(Upcasting é permitido). //Capturar e
efetuar alguma logica.
● Posso ter mais de um bloco Catch, vou colocar o tipo da exceção que quero
capturar e o apelido dela e dentro do bloco alguma logica caso a exceção ocorra.

16. Try-Catch “Bloco finally”
● Finally serve para tratar algo que você precisa obrigatoriamente fazer, mesmo que
houver um erro.
● O exemplo clássico é quando você quer abrir um arquivo ou uma conexão ao banco
de dados que deve ser fechada quando você acabar de usá-la, mesmo que houver um
erro (por exemplo, um erro de leitura do arquivo). De fato, o finally é tão rigoroso
nesse sentido que sempre será executado mesmo que houver uma exceção ou você
tentar retornar antes da execução.

17. Código Try-Catch

18. Acessos por Referencia e Copia
● Referencia: é um ponteiro que aloca uma referencia no Stack da memoria e
aponta para o objeto no Heap já em tipos primitivos é uma caixa que guarda
diretamente os valores, quando se perde a referencia ao objeto ele é desalocado da
memoria pelo garbage collector logo em seguida, variaveis locais são desalocadas
quando o método terminar.
●
Copia: Quando é estanciado um obj2 e ele recebe o valor de obj1 ele esta
recebendo apenas sua referencia, porem os tipos primitivos são caixas que recebem
seu valor e não apenas uma referencia.

19. Método clone
● Para clonar um objeto implementamos a interface Cloneable.
● A interface Cloneable não tem nenhum métodos e nenhum membro também, e é
usada para indicar que a classe (que implementa a interface) permite uma clonagem
bit a bit de um objeto, processo esse simplesmente chamado de "clonagem". Uma
exceção conhecida como "CloneNotSupportedException" é mostrada se a função
clone() é chamada numa classe em que não se implementou a interface Cloneable.
No processo de clonagem o construtor do objeto não é chamado. Então, clonar
pode ser definido como uma exata cópia do objeto original.

20. Código Cloneable

21. -Mutavel
● Objetos Java normalmente têm um ou mais itens de dados dentro deles , representados como
campos ou variáveis . Muitas vezes, quando o código externo cria um objeto de um determinado​​
tipo , algumas dessas variáveis são valores atribuídos pelo método construtor da classe. Em​​
muitos casos , uma classe vai proporcionar a capacidade , quer internamente, quer
externamente , para alterar estes valores . Se isso for possível , então a classe é mutável.
● muitos casos , classes Java fornecer métodos que alteram os valores das variáveis de classe .​​
Exemplos comuns incluem métodos setter . Um método de ajuste é aquele que define o valor de
uma variável . Por exemplo, em uma declaração de classe com uma variável string chamada "
myName " pode existir o seguinte método setter :
setName public String (String newName ) {
myName=newName;
< p> }
Este método fornece o código externo com a capacidade de alterar o conteúdo de um objeto. Em um
objeto imutável isso não deve ser possível, já que os valores devem permanecer as mesmas , uma vez
que inicialmente foram definidos, normalmente quando o objeto é criado.

22. - Imutável
● um objeto imutável é um objeto no qual seu estado não pode ser modificado após
ser criado. Ele é o oposto de um objeto mutável, que pode ser modificado após sua
criação.
● Strings são classes imutáveis. Ao tentar realizar qualquer alteração em um objeto do tipo
String você sempre vai receber como retorno uma nova String, sem alterar o valor original.

23. Para que uma classe seja considerada imutável em java ela
deve seguir as seguintes características
● Métodos não podem modificar seu estado.
● Definida como final
● Atributos devem ser privados
● Atributos devem ser final
● Caso sua classe tenha composição com objetos mutáveis, eles devem ter acesso exclusivo pela sua
classe, devolvendo cópias defensivas

24. Código Imutável

25. Exemplo de Cópia Defensiva
● Se o objeto não possuir um método clone ou semelhante, sera necessário realizar uma copia
manual do objeto para que possamos continuar trabalhando com imutabilidade.
Ainda e um pouco complicado trabalhar com imutabilidade em Java, mas essa pratica traz
diversos benefícios como optimização de memoria.

26. Threads -
● Cada processo possui diversas threads (linhas de instruções).
● Em um programa em Java podemos querer executar 2 ou mais threads ao mesmo
tempo, ou seja, 2 ou mais procedimentos internos do programa ao mesmo tempo,
são basicamente funções rodando em paralelo.
● Pertence a Classe java.lang.Thread

27. Criando Threads
● Existem 2 modos de criar uma Thread:
● Estender a Classe Thread
● Implementar a Classe Runnable
● Não podemos esquecer que Java não suporta múltiplas heranças então estender a
classe Thread pode ser inviável em algumas situações porem caso preciso pode se
usar uma linha de heranças.

28. Métodos
● Start: Inicia a thread “inicia o metodo run”.
●
Run: executa a tarefa da thread.
●
Sleep: Coloca a thread para dormir por alguns milisegundos.

29. Código Thread “Extends”

30. Código Thread Interface Runnable

31. Synchronized
● Quando um método é marcado synchronized, o sistema de execução Java garantirá
que apenas uma thread de cada vez acesse tal método. Se outras threads tentarem
fazer o mesmo, elas serão colocadas em espera até que a thread atual finalize seu
trabalho e libere o método.
● Wait: Bloqueia a execução de thread temporariamente, ou seja, coloca a thread em
modo de espera, A thread fica em modo de espera ate que seja notificada.
● Notify: notifica uma thread que estava esperando ou seja, retoma a execução da
thread.
● NotifyAll: notifica todas as threads e a que tem prioridade mais alta ganha acesso
ao objeto.

32. Código Synchronized

33. Semáforo
● São Threads sincronizadas aonde uma notifica a outra e coloca em modo de espera
ate seu ter minio para que então a outra inicie pelo modo notify e wait.
● Utilizamos semáforos para controlar a quantidade de acesso a determinado recurso.
● Esta definição de semáforo foi proposta por Dijkstra para evitar o tão temido
DeadLock.
● DeadLock: Deadlock acontece quando segmentos estão bloqueados aguardando a
liberação de bloqueios uns dos outros, Esse tipo de dependência acontece
exclusivamente por falha na lógica implementada pelo programador.

34. Código Semáforo

35. Perguntas da Semana 1
● Oque tu entende por Abstração em OOP?
● Trazer algo do mundo real para o código se concentrando no essencial do contexto
retirando informações que não são essenciais para a operação, consiste em
estabelecer uma identidade ao objeto, definir suas propriedades e seus métodos.
●
Uma Classe pode implementar mais de uma interface?
● Sim, pode implementar muitas interfaces.
● Uma Classe pode estender mais de uma classe mãe?
● Não, o Java não suporta multiplas heranças porem pode ser feita uma linha de
herança.
● Métodos estáticos -> como funciona a alocação de espaço na
memória?
● Tem um tamanho fixo, são alocados sequencialmente e automaticamente na
memoria.