DEV Community: Carolina Cunha

NoSQL x SQL

Carolina Cunha — Wed, 26 Apr 2023 12:44:30 +0000

Bancos de dados SQL (relacionais)

Dados são armazenados em tabelas.
Como é necessário que os dados sejam armazenados em tabelas, eles precisam ser estruturados (ter formatos e tipos fixo).
Cada registro da tabela possui um identificador único para acesso ao dado;
Principais vantagens:
- Garante o padrão ACID nas transações (Atomicidade, Consistência, Isolamento e Durabilidade);
- Não permite dados duplicados;
- Normalização (os dados estarão em uma forma onde as anomalias serão reduzidas ou inexistentes);
- "Fácil" para recuperar os dados.
Principais desvantagens:
- Não é escalável;
- O esquema de dados é rígido e mudanças nesses esquema são custosas.

Bancos de dados NoSQL

Os dados podem ser utilizados de diversas formas, com esquemas não rígidos.
Tipos de dados que podem ser armazenados em bancos NoSQL:
- Documentos: formato JSON;
- Chave-valor;
- Grafos;
- Wide-column: tabelas onde as linhas e colunas não são iguais. Como se fosse um banco chave-valor multidimensional.
- Tabela fornecida pelo site do MongoDB com cada as propriedades de cada tipo de banco de dados:

Quando usar um banco de dados NoSQL

Como eles tem vários tipos, o uso em cada situação precisa ser estudada qual é a necessidade;
Para aplicações onde o esquema do dado pode variar bancos NoSQL são boas opções;
Outro bom uso é para aplicações que podem precisar ser escaladas de forma rápida;
Aplicações de big data também podem se beneficiar desse tipo de banco;
Também aplicações que precisem apresentar alta performance no gerenciamento dos dados.

Notas da Mentoria

Carolina Cunha — Wed, 26 Apr 2023 09:47:46 +0000

Olá leitor!

Vou explicar mais ou menos ideia dessa série: Lá em 2021, pedi a ajuda de uma profissional sênior pra me ajudar no que eu precisava entender melhor para que eu me tornasse sênior também. Enumeramos vários conceitos, e fiquei de estudar e escrever posts sobre esses conceitos. Não consegui render muito mas estou tentando retomar isso agora. Como ando com pouco tempo, decidi ir escrevendo aqui as minhas notas de estudo e pedir pra que fossem revisadas, e depois eu tento transformá-las em um texto mais conciso.

Se você chegou aqui e quer contribuir com algo, fique a vontade! :)

Default Methods e Métodos Estáticos em Interfaces

Carolina Cunha — Wed, 04 Nov 2020 18:46:26 +0000

Continuando na saga de rever as funcionalidades e conceitos que foram introduzidos na versão 8 do Java, hoje vou falar um pouquinho de default methods e métodos estáticos em interfaces.

Antes da versão 8 do Java, caso fosse necessário adicionar métodos em uma interface, obrigatoriamente esses métodos teriam que ser implementados em todas as implementações daquela interface. Se estivermos falando de uma interface muito usada, como a interface Comparator, a adição de métodos acarretaria a quebra de todos os sistemas construídos nas versões anteriores do Java que utilizam essa interface. Para permitir a evolução de interfaces sem causa a quebra de código, foram inseridos na versão 8 do Java os default methods.

Os default methods são métodos contendo código que são declarados em interfaces e, diferente dos demais métodos da interface, eles não precisam ser implementados em todas as implementações da interface. Outra vantagem é que uma vez adicionados, todas as implementações da interface passam a ter acesso a eles.

Como disse antes, para exemplificar vou utilizar a interface Comparator. A interface Comparator nos acompanha desde os primórdios do Java (mais especificamente desde a versão 1.2), porém a partir da versão 1.8 ela ganhou diversos métodos, como o reversed():

default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }

List<Livro> livros = new ArrayList<>();
        livros.add(new Livro("Morte e vida Severina", 240));
        livros.add(new Livro("Vidas Secas", 190));
        livros.add(new Livro("O Alienista", 150));
        livros.add(new Livro("Alice no País das Maravilhas", 300));

        Comparator<Livro> comparator = new Comparator<Livro>() {
            @Override
            public int compare(Livro o1, Livro o2) {
                return o1.getNome().compareTo(o2.getNome());
            }
        };
        System.out.println("Ordem Natural:");
        livros.sort(comparator);
        livros.forEach(l -> System.out.println(l.getNome()));

        System.out.println("---------------------");

        System.out.println("Ordem Contrária:");
        livros.sort(comparator.reversed());
        livros.forEach(l -> System.out.println(l.getNome()));
    }

Saída:

A adição desse método não comprometeu o funcionamento dos sistemas que já utilizavam essa interface. Esse é o principal objetivo dos default methods: preservar a estabilidade dos sistemas de versões anteriores quando for necessário alterar interfaces.

No exemplo acima, eu utilizei o método sort() da interface List, que também foi um default method adicionado na versão 8 do Java! Ele foi adicionado para facilitar a ordenação das listas. A sintaxe dele é a seguinte:

default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

Já pensou como poderíamos inserir novas funcionalidades em uma interface tão usada como a List sem causar um caos nos sistemas já existentes? Daí a importância desse novo recurso.

Outro recurso interessante adicionado no Java 8 foi a possibilidade de se implementar métodos estáticos nas interfaces, que podem trazer funcionalidades úteis às interfaces sem comprometer o funcionamento de códigos legados.

Voltando à interface Comparator, vamos observar os métodos reverseOrder() e naturalOrder():

public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
        return Collections.reverseOrder();
    }

public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
        return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
    }

public static void main(String[] args){
        List<Integer> numeros = Arrays.asList(300,19,32,10,69);
        System.out.println("Ordem Natural:");
        numeros.sort(Comparator.naturalOrder());
        numeros.forEach(n-> System.out.print(n + " "));
        System.out.println();
        System.out.println("Ordem Contrária:");
        numeros.sort(Comparator.reverseOrder());
        numeros.forEach(n-> System.out.print(n + " "));
    }

Saída:

Esse são recursos muito úteis, mas é importante salientar que não devem ser usados para herança. Já existem vários outros recursos de herança no Java, como a Composição, por exemplo. Use com moderção!

Esse artigo faz parte de uma série que estou escrevendo enquanto revejo as funcionalidades do Java 8. Se gostou ou tem melhorias para sugerir, vou adorar saber!

Interfaces Funcionais

Carolina Cunha — Mon, 31 Aug 2020 13:39:00 +0000

As interfaces funcionais não surgiram no Java 8: nas versões mais antigas, já era possível encontrar esse tipo de interface. Mas foi no Java 8 que elas adquiriram maior importância, uma vez que elas são peças fundamentais para a implementação das expressões lambdas. Mas o que é uma interface funcional?

Uma interface funcional é uma interface que possui apenas um método abstrato. Ela pode ter mais de um método, mas se apenas um deles for abstrato, ela será considerada uma interface funcional. Vamos utilizar a interface Comparator para exemplificar:

@FunctionalInterface
public interface Comparator<T> {
  int compare(T o1, T o2);
}

Essa interface contém mais métodos do que apenas o transcrito acima, e ela é interessante por alguns motivos que vou explicando ao longo do artigo. Para criar as comparações criei uma classe Livro:

public class Livro{

    private String nome;
    private int qtdPaginas;

    public Livro(String nome, int qtdPaginas){
        this.nome = nome;
        this.qtdPaginas = qtdPaginas;
    }

    public String getNome() {
        return nome;
    }
    public void setNome(String nome) {
        this.nome = nome;
    }
    public int getQtdPaginas() {
        return qtdPaginas;
    }
    public void setQtdPaginas(int qtdPaginas) {
        this.qtdPaginas = qtdPaginas;
    }
}

A criação de um Comparator utilizando a classe Livro seria:

 Comparator<Livro> comparator = new Comparator<Livro>() {
            @Override
            public int compare(Livro o1, Livro o2) {
                return o1.getNome().compareTo(o2.getNome());
            }
        };

Utilizando lambda, podemos ainda escrever o Comparator de forma mais simples:

Comparator<Livro> porNome =
                (Livro o1, Livro o2)->o1.getNome().compareTo(o2.getNome());

Utilizando a classe anônima, vemos que o código fica um pouco confuso, porém o método que está sendo sobrescrito fica claro. Já quando utilizamos lambda, não fica explícito qual é o método da interface a ser sobrescrito, e é por isso que ela deve ser uma interface funcional: haverá apenas um método abstrato, que será sobrescrito.

Uma utilização desse
Comparator:

public static void main(String[] args){
        Comparator<Livro> porNome =
                (Livro o1, Livro o2)->o1.getNome().compareTo(o2.getNome());

        List<Livro> livros = new ArrayList<>();
        livros.add(new Livro("Morte e vida Severina", 240));
        livros.add(new Livro("Vidas Secas", 190));
        livros.add(new Livro("O Alienista", 150));
        livros.add(new Livro("Alice no País das Maravilhas", 300));

        livros.sort(porNome);
    }

Ou ainda de forma mais direta:

public static void main(String[] args){
        List<Livro> livros = new ArrayList<>();
        livros.add(new Livro("Morte e vida Severina", 240));
        livros.add(new Livro("Vidas Secas", 190));
        livros.add(new Livro("O Alienista", 150));
        livros.add(new Livro("Alice no País das Maravilhas", 300));

        livros.sort((Livro o1, Livro o2)->o1.getNome().compareTo(o2.getNome()));
    }

Todos os métodos de interfaces no Java são por padrão públicos e abstratos. Porém, em uma interface funcional também podem ser encontrados métodos default. A interface Comparator possui diversos métodos default, como:

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);

    boolean equals(Object obj);

    default java.util.Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }

    default <U> java.util.Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor,
            java.util.Comparator<? super U> keyComparator)
    {
        return thenComparing(comparing(keyExtractor, keyComparator));
    }
}

Como anteriormente dito, não transcrevi todos os métodos presentes na interface, apenas alguns para mostrar que a ela pode possuir mais métodos, desde que sejam default methods.

O método boolean equals(Object obj); não descaracteriza a interface Comparator como funcional porque ele é uma sobrescrita do método equals da classe Object.

Para evitar que uma interface funcional fosse descaracterizada acidentalmente causando prejuízo na utilização de expressões lambda, no Java 8 foi introduzida a anotação FunctionalInterface. É uma anotação opcional para manter as demais interfaces funcionais que já existiam antes da versão 8 do Java funcionando normalmente. Se não for colocada mas ainda assim a interface tiver apenas um método abstrato, ela será considerada funcional.

Outros exemplos de interfaces funcionais no Java:

Comparable:

public interface Comparable<T> {
    public int compareTo(T o);
}

Runnable:

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

As interfaces Comparator e Runnable conceitualmente já eram consideradas interfaces funcionais antes de receberem a notação @FunctionalInterface no Java 8. A interface Comparable permanece sem a anotação.

Esse artigo faz parte de uma série que estou escrevendo enquanto revejo as funcionalidades do Java 8. Se gostou ou tem melhorias para sugerir, vou adorar saber!

Listas Encadeadas

Carolina Cunha — Tue, 04 Aug 2020 10:59:44 +0000

Listas encadeadas ou listas ligadas são estruturas lineares para armazenamento de objetos do mesmo tipo. Esses objetos estão ligados uns nos outros através de ponteiros, que guardam a posição do próximo objeto da lista.

Essas listas podem ser de dois tipos:

Listas encadeadas simples: onde cada elemento tem armazenado o endereço de memória onde está localizado o próximo elemento da lista:

Listas duplamente encadeadas: onde cada elemento tem armazenado o endereço de memória onde está localizando o anterior e o próximo elemento da lista:

Listas Encadeadas no Java

No Java, a implementaçãos das listas encadeadas é feita através da coleção LinkedList, que é uma lista circular duplamente encadeada. Nesse tipo de lista, cada elemento é chamado de nó, e cada nó guarda em si, além do elemento, a posição do elemento anterior e a posição do elemento posterior.

Na memória, uma LinkedList não fica armazenada sequencialmente. Ela fica distribuída, por isso a importância de ser a posição dos elementos anteriores e posteriores em cada nó. O fato de estar distribuída na memória permite que a lista possa crescer durante a execução do programa de forma limitada apenas pela memória física disponível.

Pelo exemplo acima, vemos que a utilização de uma LinkedList é muito semelhante a utilização de um ArrayList. Então, qual seria a vantagem de utilizar uma LinkedList?

Performance! Se você precisa que sua lista tenha uma melhor performance na adição e/ou remoção de elementos, então você deve utilizar uma LinkedList! Mas por que? Porque a performance é melhor nos métodos add e remove?

Se estivermos falando de inserção/remoção no final ou no início da lista, é uma operação simples: após a criação do nó, será feita a atualização das posições nos elementos:

Se estivermos falando de inserção/remoção no meio da lista, antes da inserção ainda haverá a operação de busca do local onde deve ser inserido o elemento, então perde-se um pouco na performance nesse caso, porém devemos lembrar que o Java nesse caso escolhe o menor caminho a percorrer.

Porém, quando falamos de operações de busca de elementos específicos, a LinkedList se comporta como um ArrayList, ou seja: no pior caso, será necessário percorrer a lista toda.

Concluindo, os melhores indicativos de que se é um bom momento para usar uma LinkedList são:

Quando não serão necessários acessos a elementos de forma aleatória;
Quando serão efetuadas muitas operações de inserção/deleção de elementos;
Quando for necessário que o crescimento da lista seja dinâmico.

Bibliografia:

Essa desenvolvedora bacana aqui

Diferença entre ArrayList, Vector e LinkedList em Java

LinkedLists: O que acontece por trás da interface

Documentação oficial