Pausa para café #152. Padrões de codificação Java. HashMap em Java – recursos de uso e métodos de interação

Padrões de codificação Java

Fonte: Médio Neste artigo, você aprenderá como aderir adequadamente aos padrões de codificação em Java. Java é uma das linguagens e plataformas de programação mais utilizadas. Portanto, é altamente provável que seu código seja lido por diversas pessoas. Segue-se que o código deve ser legível e compreensível para todos - desde iniciantes até desenvolvedores seniores. Nosso objetivo é escrever código de tal forma que o leitor do código o compreenda completamente. Isso requer conhecimento e adesão aos padrões de codificação.

Por que precisamos de guias de codificação?

As diretrizes de codificação são importantes porque uma parte significativa do custo do software é gasta na manutenção do código. Além disso, o software nem sempre é desenvolvido por um único desenvolvedor. Portanto, seguir as convenções de escrita de software melhora a legibilidade de um programa. 1. Convenções de nomenclatura : geralmente seguimos a convenção CamelCase (camel case) na programação Java.

• Os nomes dos métodos devem começar com uma letra minúscula.
• Os nomes dos métodos geralmente são verbos.
• Se um método contiver múltiplas palavras, cada palavra interna deverá começar com uma letra maiúscula. Exemplo: toString() .
• O nome do método deve ser uma combinação de um verbo e um substantivo. Exemplo: getCarName() , getCarNumber() .
• Chaves: são usadas para definir os corpos de classes, métodos e loops. Existem dois formatos padrão para usar chaves.
• Linhas em branco não devem aparecer após o parêntese de abertura ou antes do parêntese de fechamento.
  

  class MountBlue{
     ... MountBlue(){
      // Конструктор
         ...
     }
  
     int Mountainain(int a, float b){
  
         ... for (int i = 0; i < Field; i++){
             ....
         }
     }
  }

• Uma chave é colocada no final da linha que inicia uma classe, método, loop e assim por diante. O parêntese de fechamento está em uma linha separada.
  Cada chaveta é adicionada a uma nova linha e o par é alinhado verticalmente.

2. Recuo : A unidade de recuo deve ter 4 espaços e 8 tabulações.

• Aplicar recuo a itens semelhantes em uma lista vertical (como comentários de fim de linha e identificadores em declarações).
• Coloque operadores binários (incluindo atribuição) com espaços.
• Um ponto e vírgula ou vírgula é seguido por um espaço.
• Adicione um espaço entre a palavra-chave (“if”, “while”, “return”, “catch”, “switch”, “for”) e o seguinte parêntese.
• Insira linhas em branco para diferenciar partes importantes do código.

3. Espaços . O espaço em branco também desempenha um papel importante na legibilidade:

• Os operadores devem estar rodeados por um espaço.
  

  Операторы следует писать так:
  a = (b + c) * d;
  А не так:
  a=(b+c)*d

• Palavras reservadas Java devem ser seguidas por um espaço. Por exemplo:
  

  Цикл нужно объявлять так:
  while (true) {...}
  А не так:
  while(true){...}

• As vírgulas devem ser seguidas de um espaço. Por exemplo:
  

  Функцию нужно объявлять так:
  fun(a, b, c, d);
  А не так:
  fun(a, b, c, d);

• Os dois pontos devem ser cercados por um espaço. Por exemplo:
  

  case нужно объявлять так:
  case 100 : break;
  А не так:
  case 100:break;

• O ponto-e-vírgula nas instruções for deve ser seguido por um caractere de espaço. Por exemplo:
  

  Цикл for нужно объявлять так:
  for (i = 0; i < n; i++)
  А не так:
  for(i=0;i<n;i++)

5. Comentários : os programas Java podem ter dois tipos de comentários.

• Os comentários de implementação são delimitados pelo símbolo // . Para comentários de implementação, Java também permite que você use /*…*/ .
• Comentários em bloco são usados ​​para descrever arquivos, métodos, estruturas de dados e algoritmos.
• Comentários de linha única podem ser colocados em uma linha e recuados no nível do código subsequente. Se um comentário não puder ser escrito em uma linha, ele deverá seguir o formato de comentário em bloco.
• Comentários finais (muito curtos) podem aparecer na mesma linha de código que descrevem, mas devem ser separados do código por uma distância significativa.
• Os comentários da documentação descrevem classes, interfaces, construtores, métodos e campos Java. Eles são separados por /**…*/ . Observe o asterisco duplo ** no início com um comentário por classe, interface ou membro. Este comentário deve aparecer imediatamente antes da declaração, sem espaço entre o comentário e o código ao qual se refere. Os comentários da documentação podem ser extraídos para arquivos HTML usando a ferramenta javadoc.

/** Это комментарий к Java documentации */
private int comments_;

HashMap em Java – recursos de uso e métodos de interação

Fonte: FreeCodeCamp Hoje você aprenderá sobre os recursos de trabalho com HashMap, métodos de interação com os dados armazenados neles e uma série de outras recomendações úteis.

Quais são os recursos do HashMap em Java?

Antes de trabalhar com HashMap, é importante entender alguns recursos:

• Os itens são armazenados em pares chave/valor.
• Os elementos não mantêm a ordem quando adicionados. Os dados permanecem desorganizados.
• Se houver chaves duplicadas, a última terá precedência sobre as demais.
• Os tipos de dados são especificados usando classes wrapper em vez de tipos de dados primitivos.

Como criar um HashMap em Java

Para criar e usar um HashMap, você deve primeiro importar o pacote java.util.HashMap :

import java.util.HashMap;

A sintaxe ao criar um novo HashMap é:

HashMap<KeyDataType, ValueDataType> HashMapName = new HashMap<>();

Agora vamos entender alguns dos termos da sintaxe acima.

• KeyDataType denota o tipo de dados de todas as chaves que serão armazenadas no arquivo HashMap.
• ValueDataType denota o tipo de dados de todos os valores que serão armazenados no arquivo HashMap.
• HashMapName denota o nome do HashMap.

Aqui está um exemplo para uma compreensão mais simples dos termos:

HashMap<Integer, String> StudentInfo = new HashMap<>();

Neste código, criamos um HashMap chamado StudentInfo . Todas as chaves armazenadas no HashMap serão Inteiras e os valores serão Strings. Observe que ao especificar tipos de dados para chaves e valores em um HashMap, estamos trabalhando com classes wrapper, não com tipos primitivos. Antes de mergulharmos nos exemplos, aqui está uma lista de classes wrapper e seus tipos de dados primitivos correspondentes em Java:

Classes wrapper e tipos primitivos em Java

Ao trabalhar com HashMap, usamos apenas classes wrapper.

Métodos HashMap em Java

Agora falaremos sobre algumas técnicas úteis que você pode usar ao trabalhar com HashMap. Por exemplo, você aprenderá como adicionar, acessar, remover e atualizar elementos em um arquivo HashMap.

Como adicionar elementos HashMap em Java

Para adicionar elementos a um HashMap, usamos o método put() . São necessários dois parâmetros - a chave e o valor do elemento a ser adicionado. Aqui está um exemplo:

import java.util.HashMap;
class HashMapExample {
    public static void main(String[] args) {

        HashMap<Integer, String> StudentInfo = new HashMap<>();

        StudentInfo.put(1, "Ihechikara");
        StudentInfo.put(2, "Jane");
        StudentInfo.put(3, "John");

        System.out.println(StudentInfo);
        // {1=Ihechikara, 2=Jane, 3=John}
    }
}

Neste trecho de código, o HashMap é denominado StudentInfo . Especificamos as chaves como números inteiros e os valores como strings: HashMap<Integer, String> . Para adicionar elementos ao HashMap, usamos o método put() :

StudentInfo.put(1, "Ihechikara");
StudentInfo.put(2, "Jane");
StudentInfo.put(3, "John");

Adicionamos três elementos, cada um com um número inteiro como chave e uma string como valor.

Como acessar elementos em um HashMap

Você pode usar o método get() para acessar os elementos armazenados no arquivo HashMap. Leva um parâmetro - a chave do elemento que está sendo acessado. Aqui está um exemplo:

import java.util.HashMap;
class HashMapExample {
    public static void main(String[] args) {
        HashMap<Integer, String> StudentInfo = new HashMap<>();

        StudentInfo.put(1, "Ihechikara");
        StudentInfo.put(2, "Jane");
        StudentInfo.put(3, "John");

        System.out.println(StudentInfo.get(2));
        // Jane
    }
}

No exemplo acima, StudentInfo.get(2) retorna o valor com chave 2 . Ao enviar para o console, "Jane" é impresso.

Como alterar o valor dos elementos em um HashMap em Java

Para alterar o valor dos elementos em um HashMap, usamos o método replace() . São necessários dois parâmetros - a chave do elemento que está sendo alterado e o novo valor atribuído a ele.

import java.util.HashMap;
class HashMapExample {
    public static void main(String[] args) {
        HashMap<Integer, String> StudentInfo = new HashMap<>();

        StudentInfo.put(1, "Ihechikara");
        StudentInfo.put(2, "Jane");
        StudentInfo.put(3, "John");

        // UИзменить ключ 1
        StudentInfo.replace(1, "Doe");

        System.out.println(StudentInfo);
        // {1=Doe, 2=Jane, 3=John}
    }
}

Quando os elementos do HashMap acima foram atribuídos, o elemento com chave 1 tinha o valor “Ihechikara”. Alteramos seu valor para “Doe” usando o método replace(): StudentInfo.replace(1, "Doe"); .

Como remover elementos no HashMap Java

Para remover um elemento de um arquivo HashMap, você pode usar o método remove() . É necessário um parâmetro - a chave do elemento a ser excluído.

import java.util.HashMap;
class HashMapExample {
    public static void main(String[] args) {
        HashMap<Integer, String> StudentInfo = new HashMap<>();

        StudentInfo.put(1, "Ihechikara");
        StudentInfo.put(2, "Jane");
        StudentInfo.put(3, "John");

        // Удалить ключ 1
        StudentInfo.remove(1);

        System.out.println(StudentInfo);
        // {2=Jane, 3=John}
    }
}

Aqui removemos o elemento com chave 1 usando o método remove() . Se você deseja remover todos os elementos HashMap de uma vez, use o método clear() :

import java.util.HashMap;
class HashMapExample {
    public static void main(String[] args) {
        HashMap<Integer, String> StudentInfo = new HashMap<>();

        StudentInfo.put(1, "Ihechikara");
        StudentInfo.put(2, "Jane");
        StudentInfo.put(3, "John");

        // Удалить все элементы
        StudentInfo.clear();

        System.out.println(StudentInfo);
        // {}
    }
}

Aqui estão alguns métodos mais úteis que você pode usar ao trabalhar com HashMap:

• containsKey retorna verdadeiro se a chave especificada existir no arquivo HashMap .
• containsValue retorna verdadeiro se o valor especificado existir no HashMap .
• size() retorna o número de elementos em um HashMap .
• isEmpty() retorna verdadeiro se não houver elementos no HashMap .

Conclusão

Neste artigo, falamos sobre HashMap em Java. Primeiro, examinamos os recursos do arquivo HashMap e aprendemos como interagir com os elementos e dados armazenados. Também vimos exemplos de código e alguns métodos para trabalhar com HashMap . Boa codificação!