Pause café #152. Normes de codage Java. HashMap en Java - fonctionnalités d'utilisation et méthodes d'interaction

Normes de codage Java

Source : Medium Dans cet article, vous apprendrez comment respecter correctement les normes de codage en Java. Java est l'un des langages et plates-formes de programmation les plus utilisés. Il est donc fort probable que votre code soit lu par plusieurs personnes. Il s'ensuit que le code doit être lisible et compréhensible par tous, des débutants aux développeurs expérimentés. Notre objectif est d'écrire du code de telle manière que le lecteur du code le comprenne parfaitement. Cela nécessite des connaissances et le respect des normes de codage.

Pourquoi avons-nous besoin de guides de codage ?

Les directives de codage sont importantes car une part importante du coût des logiciels est consacrée à la maintenance du code. De plus, les logiciels ne sont pas toujours développés par un seul développeur. Par conséquent, suivre les conventions d’écriture de logiciels améliore la lisibilité d’un programme. 1. Conventions de dénomination : Nous suivons généralement la convention CamelCase (camel case) en programmation Java.

• Les noms de méthodes doivent commencer par une lettre minuscule.
• Les noms de méthodes sont généralement des verbes.
• Si une méthode contient plusieurs mots, chaque mot interne doit commencer par une lettre majuscule. Exemple : toString() .
• Le nom de la méthode doit être une combinaison d'un verbe et d'un nom. Exemple : getCarName() , getCarNumber() .
• Accolades : elles sont utilisées pour définir les corps des classes, des méthodes et des boucles. Il existe deux formats standard pour utiliser les accolades.
• Les lignes vides ne doivent pas apparaître après la parenthèse ouvrante ou avant la parenthèse fermante.
  

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

• Une accolade est placée à la fin de la ligne qui commence une classe, une méthode, une boucle, etc. La parenthèse fermante se trouve sur une ligne distincte.
  Chaque accolade est ajoutée à une nouvelle ligne et la paire est alignée verticalement.

2. Indentation : L'unité d'indentation doit être composée de 4 espaces et 8 onglets.

• Appliquez une indentation aux éléments similaires dans une liste verticale (tels que les commentaires de fin de ligne et les identifiants dans les déclarations).
• Entourez les opérateurs binaires (y compris l’affectation) d’espaces.
• Un point-virgule ou une virgule est suivi d'un espace.
• Ajoutez un espace entre le mot-clé (« if », « while », « return », « catch », « switch », « for ») et la parenthèse suivante.
• Insérez des lignes vides pour différencier les parties importantes du code.

3. Espaces . Les espaces jouent également un rôle important dans la lisibilité :

• Les opérateurs doivent être entourés d'un espace.
  

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

• Les mots réservés Java doivent être suivis d' un espace. Par exemple:
  

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

• Les virgules doivent être suivies d'un espace. Par exemple:
  

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

• Les deux points doivent être entourés d'un espace. Par exemple:
  

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

• Les points-virgules dans les instructions for doivent être suivis d'un caractère espace. Par exemple:
  

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

5. Commentaires : Les programmes Java peuvent avoir deux types de commentaires.

• Les commentaires d'implémentation sont délimités par le symbole // . Pour les commentaires d'implémentation, Java vous permet également d'utiliser /*…*/ .
• Les commentaires en bloc sont utilisés pour décrire les fichiers, les méthodes, les structures de données et les algorithmes.
• Les commentaires sur une seule ligne peuvent être placés sur une seule ligne et mis en retrait au niveau du code suivant. Si un commentaire ne peut pas être écrit sur une seule ligne, il doit suivre le format de commentaire en bloc.
• Les commentaires de fin (très courts) peuvent apparaître sur la même ligne de code qu'ils décrivent, mais doivent être séparés du code par une distance significative.
• Les commentaires de la documentation décrivent les classes, interfaces, constructeurs, méthodes et champs Java. Ils sont séparés par /***…*/ . Notez le double astérisque ** au début avec un commentaire par classe, interface ou membre. Ce commentaire doit apparaître immédiatement avant la déclaration, sans espace entre le commentaire et le code auquel il fait référence. Les commentaires de la documentation peuvent être extraits dans des fichiers HTML à l'aide de l'outil javadoc.

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

HashMap en Java - fonctionnalités d'utilisation et méthodes d'interaction

Source : FreeCodeCamp Aujourd'hui, vous découvrirez les fonctionnalités de travail avec HashMap, les méthodes d'interaction avec les données qui y sont stockées et un certain nombre d'autres recommandations utiles.

Quelles sont les fonctionnalités de HashMap en Java ?

Avant de travailler avec HashMap, il est important de comprendre certaines fonctionnalités :

• Les éléments sont stockés dans des paires clé/valeur.
• Les éléments ne maintiennent pas l'ordre lorsqu'ils sont ajoutés. Les données restent non organisées.
• S'il y a des clés en double, la dernière prévaut sur la ou les autres.
• Les types de données sont spécifiés à l'aide de classes wrapper au lieu de types de données primitifs.

Comment créer un HashMap en Java

Pour créer et utiliser un HashMap, vous devez d'abord importer le package java.util.HashMap :

import java.util.HashMap;

La syntaxe lors de la création d'un nouveau HashMap est :

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

Comprenons maintenant certains des termes de la syntaxe ci-dessus.

• KeyDataType désigne le type de données de toutes les clés qui seront stockées dans le fichier HashMap.
• ValueDataType désigne le type de données de toutes les valeurs qui seront stockées dans le fichier HashMap.
• HashMapName désigne le nom du HashMap.

Voici un exemple pour une compréhension plus simple des termes :

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

Dans ce code, nous avons créé un HashMap appelé StudentInfo . Toutes les clés stockées dans le HashMap seront des entiers et les valeurs seront des chaînes. Notez que lors de la spécification des types de données pour les clés et les valeurs dans un HashMap, nous travaillons avec des classes wrapper, et non avec des types primitifs. Avant de plonger dans les exemples, voici une liste des classes wrapper et de leurs types de données primitifs correspondants en Java :

Classes wrapper et types primitifs en Java

Lorsque nous travaillons avec HashMap, nous utilisons uniquement des classes wrapper.

Méthodes HashMap en Java

Nous allons maintenant parler de quelques techniques utiles que vous pouvez utiliser lorsque vous travaillez avec HashMap. Par exemple, vous apprendrez comment ajouter, accéder, supprimer et mettre à jour des éléments dans un fichier HashMap.

Comment ajouter des éléments HashMap en Java

Pour ajouter des éléments à un HashMap, nous utilisons la méthode put() . Il faut deux paramètres : la clé et la valeur de l'élément à ajouter. Voici un exemple :

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

Dans cet extrait de code, le HashMap est nommé StudentInfo . Nous avons spécifié les clés sous forme d'entiers et les valeurs sous forme de chaînes : HashMap<Integer, String> . Pour ajouter des éléments au HashMap, nous avons utilisé la méthode put() :

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

Nous avons ajouté trois éléments, chacun avec un entier comme clé et une chaîne comme valeur.

Comment accéder aux éléments dans un HashMap

Vous pouvez utiliser la méthode get() pour accéder aux éléments stockés dans le fichier HashMap. Il prend un paramètre - la clé de l'élément auquel on accède. Voici un exemple :

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

Dans l'exemple ci-dessus, StudentInfo.get(2) renvoie la valeur avec la clé 2 . Lors de la sortie sur la console, "Jane" est imprimé.

Comment changer la valeur des éléments dans un HashMap en Java

Pour modifier la valeur des éléments dans un HashMap, nous utilisons la méthode replace() . Il prend deux paramètres : la clé de l'élément en cours de modification et la nouvelle valeur qui lui est attribuée.

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

Lorsque des éléments ont été attribués au HashMap ci-dessus , l'élément avec la clé 1 avait la valeur « Ihechikara ». Nous avons changé sa valeur en « Doe » en utilisant la méthode replace() : StudentInfo.replace(1, "Doe"); .

Comment supprimer des éléments dans HashMap Java

Pour supprimer un élément d'un fichier HashMap, vous pouvez utiliser la méthode remove() . Il faut un paramètre - la clé de l'élément à supprimer.

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

Ici, nous avons supprimé l'élément avec la clé 1 à l'aide de la méthode remove() . Si vous souhaitez supprimer tous les éléments HashMap d’un coup, utilisez la méthode 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);
        // {}
    }
}

Voici quelques méthodes plus utiles que vous pouvez utiliser lorsque vous travaillez avec HashMap :

• containKey renvoie true si la clé spécifiée existe dans le fichier HashMap .
• containValue renvoie true si la valeur spécifiée existe dans le HashMap .
• size() renvoie le nombre d'éléments dans un HashMap .
• isEmpty() renvoie true s'il n'y a aucun élément dans le HashMap .

Conclusion

Dans cet article, nous avons parlé de HashMap en Java. Tout d’abord, nous avons examiné les fonctionnalités du fichier HashMap et appris comment interagir avec les éléments et les données stockées. Nous avons également examiné des exemples de code et quelques méthodes pour travailler avec HashMap . Bon codage !