Coffee break #152. Mga Pamantayan sa Java Coding. HashMap sa Java - mga tampok sa paggamit at paraan ng pakikipag-ugnayan

Mga Pamantayan sa Java Coding

Source: Medium Sa artikulong ito, matututunan mo kung paano maayos na sumunod sa mga pamantayan ng coding sa Java. Ang Java ay isa sa pinakamalawak na ginagamit na mga wika at platform ng programming. Samakatuwid, malaki ang posibilidad na ang iyong code ay mababasa ng maraming tao. Ito ay sumusunod na ang code ay dapat na nababasa at naiintindihan ng lahat - mula sa mga nagsisimula hanggang sa mga senior na developer. Ang aming layunin ay magsulat ng code sa paraang lubos na nauunawaan ito ng mambabasa ng code. Nangangailangan ito ng kaalaman at pagsunod sa mga pamantayan ng coding.

Bakit kailangan natin ng mga gabay sa coding?

Mahalaga ang mga alituntunin sa pag-coding dahil malaking bahagi ng halaga ng software ang ginagastos sa pagpapanatili ng code. Bukod pa rito, ang software ay hindi palaging binuo ng isang developer. Samakatuwid, ang pagsunod sa mga kumbensyon sa pagsulat ng software ay nagpapabuti sa pagiging madaling mabasa ng isang programa. 1. Pagpapangalan ng mga convention : Karaniwan naming sinusunod ang CamelCase (camel case) convention sa Java programming.

• Ang mga pangalan ng pamamaraan ay dapat magsimula sa isang maliit na titik.
• Ang mga pangalan ng pamamaraan ay karaniwang mga pandiwa.
• Kung ang isang paraan ay naglalaman ng maraming salita, ang bawat panloob na salita ay dapat magsimula sa malaking titik. Halimbawa: toString() .
• Ang pangalan ng pamamaraan ay dapat na kumbinasyon ng isang pandiwa at isang pangngalan. Halimbawa: getCarName() , getCarNumber() .
• Curly braces: Ginagamit ang mga ito upang tukuyin ang mga katawan ng mga klase, pamamaraan at mga loop. Mayroong dalawang karaniwang format para sa paggamit ng mga kulot na brace.
• Ang mga blangkong linya ay hindi dapat lumabas pagkatapos ng pambungad na panaklong o bago ang pagsasara ng panaklong.
  

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

• Ang isang kulot na brace ay inilalagay sa dulo ng linya na nagsisimula sa isang klase, pamamaraan, loop, at iba pa. Ang pagsasara ng panaklong ay nasa isang hiwalay na linya.
  Ang bawat kulot na brace ay idinaragdag sa isang bagong linya, at ang pares ay patayong nakahanay.

2. Indentation : Ang unit ng indentation ay dapat na 4 na puwang at 8 tab.

• Ilapat ang indentation sa mga katulad na item sa isang patayong listahan (tulad ng mga komento sa dulo ng linya at mga identifier sa mga deklarasyon).
• Palibutan ang mga binary operator (kabilang ang pagtatalaga) na may mga puwang.
• Ang semicolon o kuwit ay sinusundan ng puwang.
• Magdagdag ng puwang sa pagitan ng keyword (“kung”, “habang”, “return”, “catch”, “switch”, “for”) at ang sumusunod na parenthesis.
• Ipasok ang mga blangkong linya upang makilala ang mga mahahalagang bahagi ng code.

3. Mga espasyo . May mahalagang papel din ang whitespace sa pagiging madaling mabasa:

• Ang mga operator ay dapat na napapalibutan ng isang espasyo.
  

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

• Ang mga salitang nakalaan sa Java ay dapat na sinundan ng isang puwang. Halimbawa:
  

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

• Ang mga kuwit ay dapat na sinusundan ng isang puwang. Halimbawa:
  

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

• Ang mga colon ay dapat na napapalibutan ng isang espasyo. Halimbawa:
  

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

• Ang mga semicolon sa para sa mga pahayag ay dapat na sinundan ng isang character na espasyo. Halimbawa:
  

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

5. Mga Komento : Ang mga programang Java ay maaaring magkaroon ng dalawang uri ng mga komento.

• Ang mga komento sa pagpapatupad ay nililimitahan ng // simbolo . Para sa mga komento sa pagpapatupad, pinapayagan ka rin ng Java na gamitin ang /*…*/ .
• Ang mga komento sa pag-block ay ginagamit upang ilarawan ang mga file, pamamaraan, istruktura ng data, at algorithm.
• Maaaring ilagay ang mga komento sa isang linya sa isang linya at i-indent sa antas ng kasunod na code. Kung ang isang komento ay hindi maisulat sa isang linya, dapat itong sundin ang block comment format.
• Ang mga sumusunod na komento (napakaikli) ay maaaring lumabas sa parehong linya ng code na inilalarawan nila, ngunit dapat na ihiwalay mula sa code sa pamamagitan ng isang makabuluhang distansya.
• Ang mga komento sa dokumentasyon ay naglalarawan ng mga klase ng Java, interface, constructor, pamamaraan, at field. Pinaghiwalay sila ng /**...*/ . Tandaan ang double asterisk ** sa simula na may isang komento sa bawat klase, interface, o miyembro. Dapat lumabas kaagad ang komentong ito bago ang deklarasyon, na walang puwang sa pagitan ng komento at ng code na tinutukoy nito. Maaaring i-extract ang mga komento sa dokumentasyon sa mga HTML file gamit ang javadoc tool.

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

HashMap sa Java - mga tampok sa paggamit at paraan ng pakikipag-ugnayan

Pinagmulan: FreeCodeCamp Ngayon ay matututunan mo ang tungkol sa mga tampok ng pagtatrabaho sa HashMap, mga paraan ng pakikipag-ugnayan sa data na nakaimbak sa mga ito, at ilang iba pang kapaki-pakinabang na rekomendasyon.

Ano ang mga tampok ng HashMap sa Java?

Bago magtrabaho sa HashMap, mahalagang maunawaan ang ilang feature:

• Ang mga item ay iniimbak sa key/value pairs.
• Ang mga elemento ay hindi nagpapanatili ng kaayusan kapag idinagdag. Ang data ay nananatiling hindi organisado.
• Kung mayroong mga duplicate na susi, ang huli ay mauuna kaysa sa iba pa.
• Tinutukoy ang mga uri ng data gamit ang mga klase ng wrapper sa halip na mga primitive na uri ng data.

Paano lumikha ng isang HashMap sa Java

Upang lumikha at gumamit ng HashMap, kailangan mo munang i-import ang java.util.HashMap package :

import java.util.HashMap;

Ang syntax kapag lumilikha ng bagong HashMap ay:

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

Ngayon ay unawain natin ang ilan sa mga termino sa itaas na syntax.

• Ang KeyDataType ay tumutukoy sa uri ng data ng lahat ng mga key na maiimbak sa HashMap file.
• Ang ValueDataType ay tumutukoy sa uri ng data ng lahat ng mga halaga na maiimbak sa HashMap file.
• Ang HashMapName ay tumutukoy sa pangalan ng HashMap.

Narito ang isang halimbawa para sa isang mas simpleng pag-unawa sa mga termino:

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

Sa code na ito, gumawa kami ng HashMap na tinatawag na StudentInfo . Ang lahat ng mga key na nakaimbak sa HashMap ay magiging Integers at ang mga value ay Strings. Tandaan na kapag tinutukoy ang mga uri ng data para sa mga key at value sa isang HashMap, nagtatrabaho kami sa mga klase ng wrapper, hindi sa mga primitive na uri. Bago tayo sumisid sa mga halimbawa, narito ang isang listahan ng mga klase ng wrapper at ang kanilang kaukulang mga primitive na uri ng data sa Java:

Mga klase ng wrapper at primitive na uri sa Java

Kapag nagtatrabaho sa HashMap, gumagamit lang kami ng mga klase ng wrapper.

Mga Paraan ng HashMap sa Java

Ngayon ay pag-uusapan natin ang ilang mga kapaki-pakinabang na diskarte na magagamit mo kapag nagtatrabaho sa HashMap. Halimbawa, matututunan mo kung paano magdagdag, mag-access, mag-alis, at mag-update ng mga elemento sa isang HashMap file.

Paano magdagdag ng mga elemento ng HashMap sa Java

Upang magdagdag ng mga elemento sa isang HashMap, ginagamit namin ang put() method . Kailangan ng dalawang parameter - ang susi at ang halaga ng elementong idaragdag. Narito ang isang halimbawa:

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

Sa code snippet na ito, ang HashMap ay pinangalanang StudentInfo . Tinukoy namin ang mga susi bilang mga integer at ang mga halaga bilang mga string: HashMap<Integer, String> . Upang magdagdag ng mga elemento sa HashMap, ginamit namin ang put() na paraan :

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

Nagdagdag kami ng tatlong elemento, bawat isa ay may integer bilang susi at isang string bilang halaga.

Paano i-access ang mga elemento sa isang HashMap

Maaari mong gamitin ang get() na paraan upang ma-access ang mga elementong nakaimbak sa HashMap file. Kailangan ng isang parameter - ang susi ng elementong ina-access. Narito ang isang halimbawa:

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

Sa halimbawa sa itaas, ibinabalik ng StudentInfo.get(2) ang value na may key 2 . Kapag ang output sa console, "Jane" ay naka-print.

Paano baguhin ang halaga ng mga elemento sa isang HashMap sa Java

Upang baguhin ang halaga ng mga elemento sa isang HashMap, ginagamit namin ang replace() na paraan . Kailangan ng dalawang parameter - ang susi ng elementong binago at ang bagong halaga na itinalaga dito.

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

Kapag ang HashMap sa itaas ay itinalaga ng mga elemento, ang elementong may key 1 ay may value na "Ihechikara". Binago namin ang halaga nito sa "Doe" gamit ang replace() method: StudentInfo.replace(1, "Doe"); .

Paano mag-alis ng mga elemento sa HashMap Java

Upang alisin ang isang elemento mula sa isang HashMap file, maaari mong gamitin ang remove() na paraan . Kailangan ng isang parameter - ang susi ng elemento na tatanggalin.

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

Dito namin inalis ang elemento na may key 1 gamit ang remove() method . Kung gusto mong tanggalin ang lahat ng elemento ng HashMap nang sabay-sabay, pagkatapos ay gamitin ang clear() na paraan :

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);
        // {}
    }
}

Narito ang ilang mas kapaki-pakinabang na paraan na magagamit mo kapag nagtatrabaho sa HashMap:

• Ang containsKey ay nagbabalik ng true kung ang tinukoy na key ay umiiral sa HashMap file .
• Ang containsValue ay nagbabalik ng true kung ang tinukoy na halaga ay umiiral sa HashMap .
• size() ay nagbabalik ng bilang ng mga elemento sa isang HashMap .
• isEmpty() ay nagbabalik ng true kung walang mga elemento sa HashMap .

Konklusyon

Sa artikulong ito, pinag-usapan namin ang tungkol sa HashMap sa Java. Una, tiningnan namin ang mga feature ng HashMap file at natutunan kung paano makipag-ugnayan sa mga elemento at nakaimbak na data. Tiningnan din namin ang mga halimbawa ng code at ilang pamamaraan para sa pagtatrabaho sa HashMap . Maligayang coding!