Pausa para el café #152. Estándares de codificación Java. HashMap en Java: funciones de uso y métodos de interacción

Estándares de codificación Java

Fuente: Medio En este artículo, aprenderá cómo cumplir adecuadamente con los estándares de codificación en Java. Java es uno de los lenguajes y plataformas de programación más utilizados. Por lo tanto, es muy probable que varias personas lean su código. De ello se deduce que el código debe ser legible y comprensible para todos, desde principiantes hasta desarrolladores experimentados. Nuestro objetivo es escribir código de tal manera que el lector del código lo comprenda completamente. Esto requiere conocimiento y cumplimiento de los estándares de codificación.

¿Por qué necesitamos guías de codificación?

Las pautas de codificación son importantes porque una parte importante del costo del software se gasta en mantener el código. Además, el software no siempre lo desarrolla un único desarrollador. Por lo tanto, seguir las convenciones de escritura de software mejora la legibilidad de un programa. 1. Convenciones de nomenclatura : generalmente seguimos la convención CamelCase (caso de camello) en la programación Java.

• Los nombres de los métodos deben comenzar con una letra minúscula.
• Los nombres de los métodos suelen ser verbos.
• Si un método contiene varias palabras, cada palabra interna debe comenzar con una letra mayúscula. Ejemplo: toString() .
• El nombre del método debe ser una combinación de un verbo y un sustantivo. Ejemplo: getCarName() , getCarNumber() .
• Llaves: Se utilizan para definir los cuerpos de clases, métodos y bucles. Hay dos formatos estándar para usar llaves.
• No deben aparecer líneas en blanco después del paréntesis de apertura ni antes del paréntesis de cierre.
  

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

• Se coloca una llave al final de la línea que comienza una clase, método, bucle, etc. El paréntesis de cierre está en una línea separada.
  Cada llave se agrega a una nueva línea y el par se alinea verticalmente.

2. Sangría : la unidad de sangría debe tener 4 espacios y 8 pestañas.

• Aplicar sangría a elementos similares en una lista vertical (como comentarios de final de línea e identificadores en declaraciones).
• Rodee los operadores binarios (incluida la asignación) con espacios.
• Un punto y coma o una coma van seguidos de un espacio.
• Agregue un espacio entre la palabra clave (“si”, “mientras”, “regresar”, “captura”, “cambiar”, “para”) y el siguiente paréntesis.
• Inserte líneas en blanco para diferenciar partes importantes del código.

3. Espacios . Los espacios en blanco también juegan un papel importante en la legibilidad:

• Los operadores deben estar rodeados por un espacio.
  

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

• Las palabras reservadas de Java deben ir seguidas de un espacio. Por ejemplo:
  

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

• Las comas deben ir seguidas de un espacio. Por ejemplo:
  

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

• Los dos puntos deben estar rodeados por un espacio. Por ejemplo:
  

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

• El punto y coma en las declaraciones for debe ir seguido de un carácter de espacio. Por ejemplo:
  

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

5. Comentarios : los programas Java pueden tener dos tipos de comentarios.

• Los comentarios de implementación están delimitados por el símbolo // . Para comentarios de implementación, Java también le permite usar /*…*/ .
• Los comentarios de bloque se utilizan para describir archivos, métodos, estructuras de datos y algoritmos.
• Los comentarios de una sola línea se pueden colocar en una línea y sangrar hasta el nivel del código posterior. Si un comentario no se puede escribir en una línea, debe seguir el formato de comentario en bloque.
• Los comentarios finales (muy cortos) pueden aparecer en la misma línea de código que describen, pero deben estar separados del código por una distancia significativa.
• Los comentarios de la documentación describen clases, interfaces, constructores, métodos y campos de Java. Están separados por /***…*/ . Tenga en cuenta el doble asterisco ** al principio con un comentario por clase, interfaz o miembro. Este comentario debe aparecer inmediatamente antes de la declaración, sin espacio entre el comentario y el código al que se refiere. Los comentarios de la documentación se pueden extraer en archivos HTML utilizando la herramienta javadoc.

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

HashMap en Java: funciones de uso y métodos de interacción

Fuente: FreeCodeCamp Hoy aprenderá sobre las características de trabajar con HashMap, los métodos para interactuar con los datos almacenados en ellos y una serie de otras recomendaciones útiles.

¿Cuáles son las características de HashMap en Java?

Antes de trabajar con HashMap, es importante comprender algunas características:

• Los elementos se almacenan en pares clave/valor.
• Los elementos no mantienen el orden cuando se agregan. Los datos siguen desorganizados.
• Si hay claves duplicadas, la última tiene prioridad sobre las demás.
• Los tipos de datos se especifican mediante clases contenedoras en lugar de tipos de datos primitivos.

Cómo crear un HashMap en Java

Para crear y utilizar un HashMap, primero debe importar el paquete java.util.HashMap :

import java.util.HashMap;

La sintaxis al crear un nuevo HashMap es:

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

Ahora comprendamos algunos de los términos de la sintaxis anterior.

• KeyDataType indica el tipo de datos de todas las claves que se almacenarán en el archivo HashMap.
• ValueDataType indica el tipo de datos de todos los valores que se almacenarán en el archivo HashMap.
• HashMapName indica el nombre del HashMap.

A continuación se muestra un ejemplo para una comprensión más sencilla de los términos:

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

En este código, hemos creado un HashMap llamado StudentInfo . Todas las claves almacenadas en el HashMap serán Enteras y los valores serán Strings. Tenga en cuenta que al especificar tipos de datos para claves y valores en un HashMap, estamos trabajando con clases contenedoras, no con tipos primitivos. Antes de sumergirnos en los ejemplos, aquí hay una lista de clases contenedoras y sus correspondientes tipos de datos primitivos en Java:

Clases contenedoras y tipos primitivos en Java

Cuando trabajamos con HashMap, solo usamos clases contenedoras.

Métodos HashMap en Java

Ahora hablaremos sobre algunas técnicas útiles que puedes usar cuando trabajas con HashMap. Por ejemplo, aprenderá cómo agregar, acceder, eliminar y actualizar elementos en un archivo HashMap.

Cómo agregar elementos HashMap en Java

Para agregar elementos a un HashMap, usamos el método put() . Se necesitan dos parámetros: la clave y el valor del elemento que se agregará. He aquí un ejemplo:

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}
    }
}

En este fragmento de código, el HashMap se denomina StudentInfo . Especificamos las claves como números enteros y los valores como cadenas: HashMap<Integer, String> . Para agregar elementos al HashMap, usamos el método put() :

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

Hemos agregado tres elementos, cada uno con un número entero como clave y una cadena como valor.

Cómo acceder a elementos en un HashMap

Puede utilizar el método get() para acceder a los elementos almacenados en el archivo HashMap. Se necesita un parámetro: la clave del elemento al que se accede. He aquí un ejemplo:

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
    }
}

En el ejemplo anterior, StudentInfo.get(2) devuelve el valor con la clave 2 . Cuando se envía a la consola, se imprime "Jane".

Cómo cambiar el valor de los elementos en un HashMap en Java

Para cambiar el valor de los elementos en un HashMap, usamos el método reemplazar() . Se necesitan dos parámetros: la clave del elemento que se está cambiando y el nuevo valor que se le asigna.

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}
    }
}

Cuando se asignaron elementos al HashMap anterior, el elemento con la clave 1 tenía el valor "Ihechikara". Cambiamos su valor a “Doe” usando el método replace(): StudentInfo.replace(1, "Doe"); .

Cómo eliminar elementos en HashMap Java

Para eliminar un elemento de un archivo HashMap, puede utilizar el método remove() . Se necesita un parámetro: la clave del elemento que se va a eliminar.

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}
    }
}

Aquí hemos eliminado el elemento con la clave 1 usando el método remove() . Si desea eliminar todos los elementos HashMap a la vez, utilice el 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);
        // {}
    }
}

A continuación se muestran algunos métodos más útiles que puede utilizar cuando trabaja con HashMap:

• containsKey devuelve verdadero si la clave especificada existe en el archivo HashMap .
• containsValue devuelve verdadero si el valor especificado existe en HashMap .
• size() devuelve el número de elementos en un HashMap .
• isEmpty() devuelve verdadero si no hay elementos en HashMap .

Conclusión

En este artículo, hablamos sobre HashMap en Java. Primero, analizamos las características del archivo HashMap y aprendimos cómo interactuar con los elementos y los datos almacenados. También analizamos ejemplos de código y algunos métodos para trabajar con HashMap . ¡Feliz codificación!