Pausa caffè #152. Standard di codifica Java. HashMap in Java: funzionalità di utilizzo e metodi di interazione

Standard di codifica Java

Fonte: Medium In questo articolo imparerai come aderire correttamente agli standard di codifica in Java. Java è uno dei linguaggi e delle piattaforme di programmazione più utilizzati. Pertanto, è molto probabile che il tuo codice venga letto da più persone. Ne consegue che il codice dovrebbe essere leggibile e comprensibile da tutti, dai principianti agli sviluppatori senior. Il nostro obiettivo è scrivere il codice in modo tale che il lettore lo comprenda appieno. Ciò richiede conoscenza e aderenza agli standard di codifica.

Perché abbiamo bisogno di guide alla codifica?

Le linee guida per la codifica sono importanti perché una parte significativa del costo del software viene spesa per la manutenzione del codice. Inoltre, il software non è sempre sviluppato da un singolo sviluppatore. Pertanto, seguire le convenzioni di scrittura del software migliora la leggibilità di un programma. 1. Convenzioni di denominazione : generalmente seguiamo la convenzione CamelCase (camel case) nella programmazione Java.

• I nomi dei metodi devono iniziare con una lettera minuscola.
• I nomi dei metodi sono solitamente verbi.
• Se un metodo contiene più parole, ciascuna parola interna deve iniziare con una lettera maiuscola. Esempio: toString() .
• Il nome del metodo deve essere una combinazione di un verbo e un sostantivo. Esempio: getCarName() , getCarNumber() .
• Parentesi graffe: vengono utilizzate per definire il corpo di classi, metodi e cicli. Esistono due formati standard per l'utilizzo delle parentesi graffe.
• Le righe vuote non devono apparire dopo la parentesi di apertura o prima della parentesi di chiusura.
  

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

• Una parentesi graffa viene posizionata alla fine della riga che inizia una classe, un metodo, un ciclo e così via. La parentesi di chiusura è su una riga separata.
  Ciascuna parentesi graffa viene aggiunta a una nuova riga e la coppia viene allineata verticalmente.

2. Rientro : l'unità di rientro dovrebbe essere composta da 4 spazi e 8 tabulazioni.

• Applica il rientro a elementi simili in un elenco verticale (come commenti di fine riga e identificatori nelle dichiarazioni).
• Circonda gli operatori binari (inclusa l'assegnazione) con spazi.
• Un punto e virgola o una virgola sono seguiti da uno spazio.
• Aggiungi uno spazio tra la parola chiave (“if”, “mentre”, “return”, “catch”, “switch”, “for”) e la parentesi seguente.
• Inserisci righe vuote per differenziare parti importanti del codice.

3. Spazi . Anche gli spazi bianchi svolgono un ruolo importante nella leggibilità:

• Gli operatori devono essere circondati da uno spazio.
  

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

• Le parole riservate Java devono essere seguite da uno spazio. Per esempio:
  

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

• Le virgole devono essere seguite da uno spazio. Per esempio:
  

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

• I due punti devono essere circondati da uno spazio. Per esempio:
  

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

• Il punto e virgola nelle istruzioni for deve essere seguito da uno spazio. Per esempio:
  

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

5. Commenti : i programmi Java possono avere due tipi di commenti.

• I commenti di implementazione sono delimitati dal simbolo // . Per i commenti sull'implementazione, Java consente anche di utilizzare /**…*/ .
• I commenti di blocco vengono utilizzati per descrivere file, metodi, strutture dati e algoritmi.
• I commenti a riga singola possono essere posizionati su una riga e rientrati al livello del codice successivo. Se un commento non può essere scritto su una riga, deve seguire il formato del commento a blocchi.
• I commenti finali (molto brevi) possono apparire sulla stessa riga di codice che descrivono, ma devono essere separati dal codice da una distanza significativa.
• I commenti della documentazione descrivono classi, interfacce, costruttori, metodi e campi Java. Sono separati da /**…*/ . Nota il doppio asterisco ** all'inizio con un commento per classe, interfaccia o membro. Questo commento deve apparire immediatamente prima della dichiarazione, senza spazi tra il commento e il codice a cui si riferisce. I commenti della documentazione possono essere estratti in file HTML utilizzando lo strumento javadoc.

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

HashMap in Java: funzionalità di utilizzo e metodi di interazione

Fonte: FreeCodeCamp Oggi imparerai le funzionalità di lavoro con HashMap, i metodi di interazione con i dati in essi memorizzati e una serie di altri consigli utili.

Quali sono le funzionalità di HashMap in Java?

Prima di lavorare con HashMap, è importante comprendere alcune funzionalità:

• Gli elementi vengono archiviati in coppie chiave/valore.
• Gli elementi non mantengono l'ordine quando vengono aggiunti. I dati rimangono non organizzati.
• Se sono presenti chiavi duplicate, l'ultima ha la precedenza sulle altre.
• I tipi di dati vengono specificati utilizzando classi wrapper anziché tipi di dati primitivi.

Come creare una HashMap in Java

Per creare e utilizzare una HashMap, devi prima importare il pacchetto java.util.HashMap :

import java.util.HashMap;

La sintassi durante la creazione di una nuova HashMap è:

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

Ora comprendiamo alcuni dei termini nella sintassi precedente.

• KeyDataType denota il tipo di dati di tutte le chiavi che verranno archiviate nel file HashMap.
• ValueDataType denota il tipo di dati di tutti i valori che verranno archiviati nel file HashMap.
• HashMapName denota il nome dell'HashMap.

Ecco un esempio per una più semplice comprensione dei termini:

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

In questo codice abbiamo creato una HashMap chiamata StudentInfo . Tutte le chiavi memorizzate nell'HashMap saranno numeri interi e i valori saranno stringhe. Tieni presente che quando specifichiamo i tipi di dati per chiavi e valori in una HashMap, stiamo lavorando con classi wrapper, non con tipi primitivi. Prima di immergerci negli esempi, ecco un elenco di classi wrapper e i corrispondenti tipi di dati primitivi in ​​Java:

Classi wrapper e tipi primitivi in ​​Java

Quando lavoriamo con HashMap, utilizziamo solo classi wrapper.

Metodi HashMap in Java

Ora parleremo di alcune tecniche utili che puoi utilizzare quando lavori con HashMap. Ad esempio, imparerai come aggiungere, accedere, rimuovere e aggiornare gli elementi in un file HashMap.

Come aggiungere elementi HashMap in Java

Per aggiungere elementi a una HashMap, utilizziamo il metodo put() . Sono necessari due parametri: la chiave e il valore dell'elemento da aggiungere. Ecco un esempio:

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

In questo frammento di codice, HashMap è denominato StudentInfo . Abbiamo specificato le chiavi come numeri interi e i valori come stringhe: HashMap<Integer, String> . Per aggiungere elementi a HashMap, abbiamo utilizzato il metodo put() :

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

Abbiamo aggiunto tre elementi, ciascuno con un numero intero come chiave e una stringa come valore.

Come accedere agli elementi in una HashMap

Puoi utilizzare il metodo get() per accedere agli elementi memorizzati nel file HashMap. Richiede un parametro: la chiave dell'elemento a cui si accede. Ecco un esempio:

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

Nell'esempio precedente, StudentInfo.get(2) restituisce il valore con la chiave 2 . Quando viene inviato alla console, viene stampato "Jane".

Come modificare il valore degli elementi in una HashMap in Java

Per modificare il valore degli elementi in una HashMap, utilizziamo il metodo replace() . Richiede due parametri: la chiave dell'elemento da modificare e il nuovo valore che gli viene assegnato.

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 alla HashMap di cui sopra venivano assegnati elementi, l'elemento con la chiave 1 aveva il valore "Ihechikara". Abbiamo cambiato il suo valore in "Doe" utilizzando il metodo replace(): StudentInfo.replace(1, "Doe"); .

Come rimuovere elementi in HashMap Java

Per rimuovere un elemento da un file HashMap, puoi utilizzare il metodoremove () . Richiede un parametro: la chiave dell'elemento da eliminare.

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

Qui abbiamo rimosso l'elemento con chiave 1 utilizzando il metodoremove() . Se desideri rimuovere tutti gli elementi HashMap contemporaneamente, utilizza il metodo 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);
        // {}
    }
}

Ecco alcuni metodi più utili che puoi utilizzare quando lavori con HashMap:

• contieneKey restituisce true se la chiave specificata esiste nel file HashMap .
• contieneValue restituisce true se il valore specificato esiste in HashMap .
• size() restituisce il numero di elementi in una HashMap .
• isEmpty() restituisce true se non ci sono elementi in HashMap .

Conclusione

In questo articolo abbiamo parlato di HashMap in Java. Innanzitutto, abbiamo esaminato le funzionalità del file HashMap e imparato come interagire con gli elementi e i dati memorizzati. Abbiamo anche esaminato esempi di codice e alcuni metodi per lavorare con HashMap . Buona programmazione!