ਹੈਸ਼ਮੈਪ Javaੰਗ ਜਾਵਾ



ਹੈਸ਼ਮੈਪ ਜਾਵਾ ਜਾਵਾ ਨਕਸ਼ਾ

ਜਾਵਾ ਵਿੱਚ ਹੈਸ਼ਮੈਪ ਕਲਾਸ ਦੇ ਰੂਪ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜਾ ਜਿੱਥੇ ਕੁੰਜੀ ਡੇਟਾ ਵਿਲੱਖਣ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਅਸੀਂ ਸੰਬੰਧਿਤ ਕੁੰਜੀ ਡੇਟਾ ਦੇ ਅਧਾਰ ਤੇ ਮੁੱਲਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹਾਂ. ਹੈਸ਼ਮੈਪ ਜਾਵਾ ਦੇ ਕੁਲੈਕਸ਼ਨ ਫਰੇਮਵਰਕ ਵਿੱਚ ਮੌਜੂਦ ਹੈ ਅਤੇ java.util ਪੈਕੇਜ ਦਾ ਹਿੱਸਾ ਹੈ. ਇਹ ਹੈਸ਼ਿੰਗ ਤਕਨੀਕ ਦੇ ਸਿਧਾਂਤ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ.

ਜਾਵਾ ਹੈਸ਼ਮੈਪ ਲੜੀ

ਜਾਵਾ ਵਿੱਚ ਹੈਸ਼ਮੈਪ ਕਲਾਸ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈ ਸਾਰ ਕਲਾਸ ਐਬਸਟਰੈਕਟਮੈਪ ਅਤੇ ਲਾਗੂ ਕਰਦਾ ਹੈ ਨਕਸ਼ਾ ਇੰਟਰਫੇਸ ਹੇਠ ਦਿੱਤੇ ਅਨੁਸਾਰ.

ਜਾਵਾ ਵਿੱਚ ਹੈਸ਼ਮੈਪ

ਹੈਸ਼ਮੈਪ ਬਣਤਰ ਅਤੇ ਕਾਰਜਸ਼ੀਲ ਸਿਧਾਂਤ

ਜਾਵਾ ਵਿਚ ਹੈਸ਼ਮੈਪ ਦੇ ਸਿਧਾਂਤ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ ਹੈਸ਼ਿੰਗ ਤਕਨੀਕ. ਹੈਸ਼ਿੰਗ ਵਿੱਚ, ਅਸੀਂ ਹੈਸ਼ਮੈਪ ਵਿੱਚ ਕੁੰਜੀ ਅਤੇ ਮੁੱਲ ਨੂੰ ਜੋੜਨ ਲਈ ਹੈਸ਼ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ. ਹੈਸ਼ਮੈਪ ਇੱਕ ਦੇ ਰੂਪ ਵਿੱਚ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜਿਆਂ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ ਐਰੇ ਨੋਡਾਂ ਦੀ ਜਿੱਥੇ ਹਰੇਕ ਐਂਟਰੀ ਨੂੰ ਬਾਲਟੀ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ. ਇੱਕ ਬਾਲਟੀ ਐਰੇ ਵਿਚਲੇ ਤੱਤ ਤੋਂ ਇਲਾਵਾ ਕੁਝ ਵੀ ਨਹੀਂ ਹੁੰਦਾ. ਹਰੇਕ ਨੋਡ ਦੇ 3 ਮੁੱਲ ਹੁੰਦੇ ਹਨ: ਕੁੰਜੀ, ਮੁੱਲ, ਅਤੇ ਲਿੰਕ ਅਗਲੇ ਨੋਡ ਜਦੋਂ 1 ਤੋਂ ਵੱਧ ਨੋਡ ਇਕੋ ਇੰਡੈਕਸ ਨੂੰ ਸਾਂਝਾ ਕਰਦੇ ਹਨ, ਤਾਂ ਇਹ ਲਿੰਕਡ ਸੂਚੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ. ਹਰ ਨੋਡ ਨੂੰ ਬਾਲਟੀ ਵਿੱਚ ਇੱਕ ਇੰਡੈਕਸ ਵਿੱਚ ਮੈਪ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿਸ ਦੀ ਵਰਤੋਂ ਹੈਸ਼ਕੋਡ () ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ.

ਜਾਵਾ ਵਿੱਚ ਹੈਸ਼ਮੈਪ

ਹੈਸ਼ਮੈਪ ਪ੍ਰਦਰਸ਼ਨ

ਜਾਵਾ ਵਿੱਚ ਹੈਸ਼ਮੈਪ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਹੇਠ ਦਿੱਤੇ ਪੈਰਾਮੀਟਰਾਂ ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ:

  • ਸ਼ੁਰੂਆਤੀ ਸਮਰੱਥਾ - ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ ਹੈਸ਼ਮੈਪ ਕਿੰਨੀ ਬਾਲਟੀਆਂ ਨੂੰ ਸਟੋਰ ਕਰ ਸਕਦਾ ਹੈ ਜਦੋਂ ਇਹ ਅਰੰਭ ਹੁੰਦਾ ਹੈ. ਮੂਲ ਰੂਪ ਵਿੱਚ, ਇਹ ਹੈ 16 ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜੇ
  • ਲੋਡ ਫੈਕਟਰ - ਇਹ ਸਮਰੱਥਾ ਦੀ ਪ੍ਰਤੀਸ਼ਤਤਾ ਹੈ ਜਿਸ ਨੂੰ ਵਧਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਮੂਲ ਰੂਪ ਵਿੱਚ, ਇਹ ਹੈ 0.75
  • ਥ੍ਰੈਸ਼ੋਲਡ - ਇਹ ਲੋਡ ਫੈਕਟਰ ਅਤੇ ਸਮਰੱਥਾ ਦਾ ਉਤਪਾਦ ਹੈ ਜਿਸਦਾ ਮੂਲ ਮੁੱਲ ਹੈ 12 (16 * 0.75)
  • ਰੀਹੈਸਿੰਗ - ਇਹ ਇੱਕ ਥ੍ਰੈਸ਼ੋਲਡ ਵੈਲਯੂ 'ਤੇ ਪਹੁੰਚਣ ਤੋਂ ਬਾਅਦ ਸਮਰੱਥਾ ਨੂੰ ਦੁਗਣਾ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਹੈ.

ਜਾਵਾ ਹੈਸ਼ਮੈਪ ਘੋਸ਼ਣਾ

ਜਾਵਾ ਵਿੱਚ ਹੈਸ਼ਮੈਪ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਆਯਾਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ java.util.HashMap ਪੈਕੇਜ. ਸੰਟੈਕਸ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ ਹੈ:

HashMap<KeyType,ValueType> map = new HashMap<>();

ਕੀ ਟਾਈਪ - ਇਹ ਕੁੰਜੀ ਡੇਟਾ ਦੀ ਕਿਸਮ ਹੈ.Eg: ਸਤਰ ਜਾਂ ਪੂਰਨ ਅੰਕ

ਵੈਲਯੂ ਟਾਈਪ - ਇਹ ਵੈਲਯੂ ਡੇਟਾ ਦੀ ਕਿਸਮ ਹੈ. ਉਦਾਹਰਣ: ਸਤਰ ਜਾਂ ਪੂਰਨ ਅੰਕ

ਹੈਸ਼ਮੈਪ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

ਜਾਵਾ ਵਿੱਚ ਹੈਸ਼ਮੈਪ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹੇਠਾਂ ਹਨ:

  • ਹਰੇਕ ਕੁੰਜੀ ਨਾਲ ਸੰਬੰਧਿਤ ਮੁੱਲ ਸਟੋਰ ਕਰਦਾ ਹੈ
  • ਸਿਰਫ ਵਿਲੱਖਣ ਕੁੰਜੀਆਂ ਹਨ
  • ਡੁਪਲਿਕੇਟ ਕੁੰਜੀਆਂ ਦੀ ਆਗਿਆ ਨਹੀਂ ਦਿੰਦਾ ਪਰ ਡੁਪਲਿਕੇਟ ਮੁੱਲ ਹੋ ਸਕਦੇ ਹਨ
  • ਇਹ ਕਿਸੇ ਵੀ ਆਰਡਰ ਨੂੰ ਬਰਕਰਾਰ ਨਹੀਂ ਰੱਖਦਾ ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਜਿਸ ਆਰਡਰ ਵਿਚ ਡੇਟਾ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਉਹ ਇਕੋ ਜਿਹਾ ਨਹੀਂ ਹੁੰਦਾ ਜਿਸ ਵਿਚ ਇਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ.
  • ਇਹ ਗੈਰ-ਸਮਕਾਲੀ ਹੈ

ਜਾਵਾ ਹੈਸ਼ਮੈਪ ਕਲਾਸ ਨਿਰਮਾਤਾ

ਹੈਸ਼ਮੈਪ 4 ਵੱਖ ਵੱਖ ਨਿਰਮਾਤਾਵਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਹੇਠਲੀ ਸਾਰਣੀ ਵਿੱਚ ਵੇਖ ਸਕਦੇ ਹੋ:

ਕੰਸਟਰਕਟਰਵੇਰਵਾ
ਹੈਸ਼ਮੈਪ ()ਇੱਕ ਡਿਫੌਲਟ ਹੈਸ਼ਮੈਪ ਅਰੰਭ ਕਰਦਾ ਹੈ
ਹੈਸ਼ਮੈਪ (ਮੈਪਮ)ਹਾਸ਼ਮੈਪ ਦੀ ਸ਼ੁਰੂਆਤ ਮੈਪ ਐਮ ਦੇ ਤੱਤ ਨਾਲ ਕੀਤੀ
ਹੈਸ਼ਮੈਪ (ਪੂਰਨ ਸਮਰੱਥਾ)ਨਿਰਧਾਰਤ ਸਮਰੱਥਾ ਪੂਰਨ ਅੰਕ ਮੁੱਲ ਨਾਲ ਹੈਸ਼ਮੈਪ ਅਰੰਭ ਕਰਦਾ ਹੈ
ਹੈਸ਼ਮੈਪ (ਇੰਟ ਸਮਰੱਥਾ, ਫਲੋਟ ਲੋਡਫੈਕਟਰ)ਨਿਰਧਾਰਤ ਸਮਰੱਥਾ ਅਤੇ ਲੋਡਫੈਕਟਰ ਨਾਲ ਹੈਸ਼ਮੈਪ ਅਰੰਭ ਕਰਦਾ ਹੈ

ਹੈਸ਼ਮੈਪ .ੰਗ

ਜਾਵਾ ਹੈਸ਼ਮੈਪ ਹੇਠਾਂ ਦਿੱਤੀ ਸਾਰਣੀ ਵਿਚ ਦੱਸੇ ਤਰੀਕਿਆਂ ਦੇ ਨਾਲ ਨਾਲ ਮੈਪ ਇੰਟਰਫੇਸ ਨਾਲ ਸੰਬੰਧਿਤ ਸਾਰੇ supportsੰਗਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ

ਢੰਗਵੇਰਵਾਪੈਰਾਮੀਟਰ
ਰੱਦ ਸਾਫ ()ਇਸ ਨਕਸ਼ੇ ਵਿਚਲੇ ਸਾਰੇ ਮੈਪਿੰਗਸ ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਨਕਸ਼ਾ ਖਾਲੀ ਹੋਵੇਗਾ
ਆਬਜੈਕਟ ਕਲੋਨ ()ਇਸ ਹੈਸ਼ਮੈਪ ਦੀ ਇਕ ਛੋਟੀ ਜਿਹੀ ਕਾੱਪੀ ਵਾਪਸ ਕਰਦਾ ਹੈ. ਕੁੰਜੀ ਅਤੇ ਆਪਣੇ ਆਪ ਕਲੋਨ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ
ਬੁਲੀਅਨ ਵਿੱਚ ਕੀ (ਆਬਜੈਕਟ ਕੁੰਜੀ) ਹੈਸਹੀ ਦਰਸਾਉਂਦਾ ਹੈ ਜੇ ਨਿਰਧਾਰਤ ਕੁੰਜੀ ਲਈ ਕੋਈ ਮੈਪਿੰਗ ਮੁੱਲ ਹੈਕੁੰਜੀ - ਉਹ ਕੁੰਜੀ ਜਿਸ ਲਈ ਸਾਨੂੰ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ
ਬੁਲੀਅਨ ਵਿੱਚ ਵਾਲਯੂ (ਆਬਜੈਕਟ ਦਾ ਮੁੱਲ) ਹੁੰਦਾ ਹੈਜੇ ਸਹੀ ਮੁੱਲ ਲਈ ਕੁੰਜੀ ਦਾ ਮੈਪਿੰਗ ਹੋਵੇ ਤਾਂ ਸਹੀ ਵਾਪਿਸ ਆਵੇਗਾਮੁੱਲ - ਮੁੱਲ, ਜਿਸ ਲਈ ਖਾਸ ਕੁੰਜੀ ਨੂੰ ਮੈਪ ਕੀਤਾ ਗਿਆ ਹੈ
ਸੈੱਟ ਕਰੋ ਐਂਟਰੀਸੈੱਟ ()ਨਕਸ਼ੇ ਦੀ ਮੈਪਿੰਗ ਦਾ ਸੈਟ ਸੈਟ ਵੇਖਾਉਂਦਾ ਹੈ
ਬੂਲੀਅਨ ਬਰਾਬਰ (ਆਬਜੈਕਟ ਓ)ਸਹੀ ਵਾਪਿਸ ਆਵੇਗਾ ਜੇ ਆਬਜੈਕਟ ਦੇ ਨਕਸ਼ੇ ਦੀ ਇਕੋ ਮੇਲਿੰਗ ਹੋਵੇo - ਤੁਲਨਾ ਕੀਤੀ ਜਾਣ ਵਾਲੀ ਇਕਾਈ
ਪੂਰਨ ਅੰਕ ਪ੍ਰਾਪਤ (ਆਬਜੈਕਟ ਕੁੰਜੀ)ਨਕਸ਼ੇ ਵਿਚ ਨਿਰਧਾਰਤ ਕੁੰਜੀ ਦਾ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ. ਜੇ ਕੋਈ ਮੈਪਿੰਗ ਨਹੀਂ ਹੈ ਤਾਂ ਇਹ ਰੱਦ ਹੋ ਜਾਂਦੀ ਹੈਕੁੰਜੀ - ਕੁੰਜੀ ਜਿਸ ਲਈ ਵੈਲਯੂ ਮੈਪਿੰਗ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ
ਪੂਰਨ ਅੰਕ getOrDefault (ਆਬਜੈਕਟ ਕੁੰਜੀ, ਪੂਰਨ ਅੰਕ ਮੂਲ)ਜੇ ਮੈਪ ਕੀਤੀ ਗਈ ਹੈ ਤਾਂ ਨਿਰਧਾਰਿਤ ਕੁੰਜੀ ਦਾ ਮੁੱਲ ਵਾਪਸ ਕਰ ਦੇਵੇਗਾ, ਨਹੀਂ ਤਾਂ ਮੈਪਿੰਗ ਨਾ ਹੋਣ 'ਤੇ ਮੂਲ ਮੁੱਲ ਵਾਪਸ ਕਰ ਦੇਵੇਗਾਕੁੰਜੀ - ਉਹ ਕੁੰਜੀ ਜਿਸ ਲਈ ਅਸੀਂ ਕਦਰ ਕਰਦੇ ਹਾਂ ਵਾਪਸ ਕਰਨਾ ਹੈ
defaultvalue - ਜਦੋਂ ਕੋਈ ਮੈਪਿੰਗ ਨਹੀਂ ਹੁੰਦੀ ਤਾਂ ਵਾਪਸੀ ਲਈ ਮੂਲ ਮੁੱਲ
ਇੰਟ ਹੈਸ਼ਕੋਡ ()ਨਕਸ਼ੇ ਦਾ ਹੈਸ਼ਕੋਡ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ
ਬੂਲੀਅਨ ਈਪਟੀ ()ਵਾਪਸੀ ਸਹੀ ਹੈਸ਼ਮੈਪ ਵਿੱਚ ਕੋਈ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜ ਨਹੀਂ ਹੁੰਦਾ
ਕੀਸੈੱਟ ਸੈੱਟ ਕਰੋ ()ਨਕਸ਼ੇ ਵਿੱਚ ਮੌਜੂਦ ਕੁੰਜੀਆਂ ਦਾ ਸੈਟ ਸੈਟ ਵੇਖਾਉਂਦਾ ਹੈ
ਪੂਰਨ ਅੰਕ (ਸਟ੍ਰਿੰਗ ਕੁੰਜੀ, ਇੰਟ ਵੈਲਯੂ)ਕੁੰਜੀ ਨੂੰ ਮੁੱਲ ਦੇ ਨਾਲ ਜੋੜਦਾ ਹੈ. ਜੇ ਕੁੰਜੀ ਪਹਿਲਾਂ ਹੀ ਮੌਜੂਦ ਹੈ, ਤਾਂ ਇਹ ਪੁਰਾਣੇ ਮੁੱਲ ਨੂੰ ਨਵੇਂ ਮੁੱਲ ਨਾਲ ਬਦਲ ਦੇਵੇਗੀਕੁੰਜੀ - ਮੈਪਿੰਗ ਲਈ ਕੁੰਜੀ
ਨਿਰਧਾਰਿਤ ਕੁੰਜੀ ਲਈ ਮੁੱਲ - ਮੁੱਲ
ਰੱਦ ਪੁਟਆਲ (ਮੈਪ ਮੀ)ਸਾਰੇ ਕੁੰਜੀ - ਮੁੱਲ ਦੇ ਮੈਪਿੰਗ ਨੂੰ ਮੌਜੂਦਾ ਨਕਸ਼ੇ ਨਾਲ ਜੋੜਦਾ ਹੈਮੀ - ਮੈਪਿੰਗ ਦੀਆਂ ਕਾਪੀਆਂ ਮੌਜੂਦਾ ਨਕਸ਼ੇ 'ਤੇ ਜੋੜੀਆਂ ਜਾਣਗੀਆਂ
ਪੂਰਨ ਅੰਕ putIfAbmitted (ਸਤਰ ਦੀ ਕੁੰਜੀ, ਪੂਰਨ ਅੰਕ ਮੁੱਲ)ਮੁੱਲ ਨੂੰ ਜੋੜਦਾ ਹੈ ਜੇ ਪਹਿਲਾਂ ਹੀ ਕੁੰਜੀ ਨਾਲ ਮੈਪ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ ਤਾਂ ਮੌਜੂਦਾ ਮੁੱਲ ਵਾਪਸ ਕਰ ਦੇਵੇਗਾਕੁੰਜੀ - ਮੈਪਿੰਗ ਲਈ ਕੁੰਜੀ
ਮੁੱਲ - ਮੁੱਲ ਨੂੰ ਜੋੜਨਾ
ਪੂਰਨ ਅੰਕ ਹਟਾਓ (ਆਬਜੈਕਟ ਕੁੰਜੀ)ਨਕਸ਼ੇ ਵਿਚ ਦਿੱਤੀ ਕੁੰਜੀ ਲਈ ਮੈਪਿੰਗ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈਕੁੰਜੀ - ਨਕਸ਼ੇ ਦੀ ਕੁੰਜੀ ਜਿਸ ਲਈ ਮੈਪਿੰਗ ਨੂੰ ਹਟਾਉਣਾ ਹੈ
ਬੂਲੀਅਨ ਹਟਾਓ (ਆਬਜੈਕਟ ਕੁੰਜੀ, ਆਬਜੈਕਟ ਦਾ ਮੁੱਲ)ਨਿਰਧਾਰਿਤ ਕੁੰਜੀ ਦੀ ਐਂਟਰੀ ਕੇਵਲ ਤਾਂ ਹੀ ਹਟਾਉਂਦੀ ਹੈ ਜੇ ਇਹ ਨਿਰਧਾਰਤ ਮੁੱਲ ਨਾਲ ਮੇਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈਕੁੰਜੀ - ਨਕਸ਼ੇ ਵਿੱਚ ਕੁੰਜੀ
ਕੁੰਜੀ 'ਤੇ ਮੁੱਲ - ਮੁੱਲ ਨੂੰ ਮੈਪ ਕੀਤਾ
ਪੂਰਨ ਅੰਕ ਬਦਲੋ (ਸਟਰਿੰਗ ਕੁੰਜੀ, ਪੂਰਨ ਅੰਕ)ਨਿਰਧਾਰਿਤ ਕੁੰਜੀ ਦੇ ਮੁੱਲ ਨੂੰ ਕੇਵਲ ਉਦੋਂ ਹੀ ਮੁੱਲ ਨਾਲ ਬਦਲਦਾ ਹੈ ਜੇ ਇਹ ਵਰਤਮਾਨ ਵਿੱਚ ਕੁਝ ਮੁੱਲ ਨਾਲ ਮੈਪ ਕੀਤੀ ਜਾਂਦੀ ਹੈਕੁੰਜੀ - ਨਕਸ਼ੇ ਵਿੱਚ ਕੁੰਜੀ
ਮੁੱਲ - ਮੁੱਲ ਨੂੰ ਤਬਦੀਲ
ਬੂਲੀਅਨ ਬਦਲੋ (ਸਟਰਿੰਗ ਕੁੰਜੀ, ਪੂਰਨ ਅੰਕ ਪੁਰਾਣਾ, ਪੂਰਨ ਅੰਕ ਨਵਾਂ)ਨਿਰਧਾਰਿਤ ਕੁੰਜੀ ਦੀ ਐਂਟਰੀ ਨੂੰ ਨਵੇਂ ਮੁੱਲ ਨਾਲ ਉਦੋਂ ਹੀ ਬਦਲ ਦਿੰਦਾ ਹੈ ਜੇ ਇਹ ਪਹਿਲਾਂ ਹੀ ਨਿਰਧਾਰਤ ਪੁਰਾਣੇ ਮੁੱਲ ਨਾਲ ਮੈਪ ਕੀਤੀ ਹੋਵੇਕੁੰਜੀ - ਨਕਸ਼ੇ ਵਿੱਚ ਕੁੰਜੀ
ਪੁਰਾਣੀ - ਪੁਰਾਣੀ ਕੁੰਜੀ ਨੂੰ ਮੈਪ ਕੀਤਾ ਗਿਆ
newvalue - newvalue ਨੂੰ ਕੁੰਜੀ ਨਾਲ ਮੈਪ ਕੀਤਾ ਜਾਣਾ ਹੈ
ਪੂਰਨ ਆਕਾਰ ()ਨਕਸ਼ੇ ਦਾ ਆਕਾਰ ਵਾਪਸ ਕਰਦਾ ਹੈ
ਸਟ੍ਰਿੰਗ ਟੂ ਸਟ੍ਰਿੰਗ ()ਨਕਸ਼ੇ ਦੀ ਇੱਕ ਸਤਰ ਦੀ ਨੁਮਾਇੰਦਗੀ ਵਾਪਸ ਕਰਦਾ ਹੈ
ਕੁਲੈਕਸ਼ਨ ਵੈਲਯੂਜ ()ਨਕਸ਼ੇ ਵਿੱਚ ਮੌਜੂਦ ਮੁੱਲਾਂ ਦਾ ਸੰਗ੍ਰਹਿ ਦ੍ਰਿਸ਼ ਵਾਪਸ ਕਰਦਾ ਹੈ

ਹੈਸ਼ਮੈਪ ਅਪਵਾਦ

ਇਹ ਜਾਵਾ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਅਪਵਾਦਾਂ ਨੂੰ ਸੁੱਟਦਾ ਹੈ:

  • ਇਕਸਾਰ
  • ਗੈਰ ਕਾਨੂੰਨੀ ਮਨੀਟਰ ਸਟੇਟ ਐਕਸੈਪਸ਼ਨ
  • NullPointerException
  • ਰੁਕਾਵਟ
  • ਗੈਰਕਨੂੰਨੀ ਆਰਗੂਮੈਂਟ ਐਕਸੈਪਸ਼ਨ

ਹੈਸ਼ਮੈਪ ਵਿੱਚ ਐਲੀਮੈਂਟਸ ਸ਼ਾਮਲ ਕਰਨਾ

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਣ ਵਿੱਚ ਵੇਖ ਸਕਦੇ ਹੋ, ਪਹਿਲਾਂ ਅਸੀਂ ਸਟ੍ਰਿੰਗ ਟਾਈਪ ਦੀ ਕੁੰਜੀ ਅਤੇ ਇੰਟੀਜ਼ਰ ਟਾਈਪ ਦੀ ਵੈਲਯੂ ਨਾਲ ਇੱਕ ਵਿਦਿਆਰਥੀ ਹੈਸ਼ਮੈਪ ਬਣਾਉਂਦੇ ਹਾਂ. ਅਸੀਂ ਫਿਰ ਦੀ ਵਰਤੋਂ ਨਾਲ ਵਿਅਕਤੀਗਤ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜੇ ਜੋੜਦੇ ਹਾਂ ਪਾ .ੰਗ. ਤੁਸੀਂ ਆਉਟਪੁੱਟ ਵਿੱਚ ਵੇਖ ਸਕਦੇ ਹੋ ਕਿ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਤੱਤ ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਉਹ ਕ੍ਰਮ ਨਹੀਂ ਜਿੰਨਾ ਵਿੱਚ ਇਸਨੂੰ ਪਾਇਆ ਗਿਆ ਸੀ.

ਅੱਗੇ, ਅਸੀਂ 'ਸਟੂ' ਨਾਮ ਦਾ ਦੂਜਾ ਹੈਸ਼ਮੈਪ ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਫਿਰ 2 ਕੁੰਜੀ-ਮੁੱਲ ਦੀਆਂ ਜੋੜੀਆਂ ਜੋੜਦੇ ਹਾਂ. ਇਹ ਅਸੀਂ ਫਿਰ ਵਰਤ ਕੇ 'ਵਿਦਿਆਰਥੀ' ਨਕਸ਼ੇ 'ਤੇ ਜੋੜਦੇ ਹਾਂ ਸਭ ਪਾਉ ਵਿਧੀ

import java.util.HashMap;
public class HashMapAdd {

  public static void main(String[] args) {
    HashMap<String,Integer> student = new HashMap<>();
    student.put("Arthi", 100);
    student.put("Dev", 105);
    student.put("Banu",102);
    student.put("Rishi", 108);
    System.out.println("Elements in student map:");
    System.out.println(student);
    
    HashMap<String,Integer> stu = new HashMap<>();
    stu.put("Ravi",110);
    stu.put("Tejas", 112);
    System.out.println("Elements in stu map:");
    System.out.println(stu);
    
    student.putAll(stu);
    
    System.out.println("Elements in student map after invoking putAll method:");
    System.out.println(student);
  }

}
Elements in student map:
{Dev=105, Banu=102, Rishi=108, Arthi=100}
Elements in stu map:
{Ravi=110, Tejas=112}
Elements in student map after invoking putAll method:
{Dev=105, Ravi=110, Tejas=112, Banu=102, Rishi=108, Arthi=100}

ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਨਕਸ਼ੇ ਵਿੱਚ ਕੋਈ ਖਾਸ ਕੁੰਜੀ ਜਾਂ ਮੁੱਲ ਹੈ

ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ مشتمل ਹੈ checkੰਗ ਇਹ ਜਾਂਚਣ ਲਈ ਕਿ ਕੀ ਨਕਸ਼ੇ ਵਿੱਚ ਕੋਈ ਖਾਸ ਕੁੰਜੀ ਮੌਜੂਦ ਹੈ ਜਾਂ ਨਹੀਂ. ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਦੇਵ ਮੌਜੂਦ ਹੈ ਅਤੇ ਇਸ ਲਈ ਇਹ ਸਹੀ ਵਾਪਸੀ ਕਰਦਾ ਹੈ ਅਤੇ ਰਵੀ ਮੌਜੂਦ ਨਹੀਂ ਹੈ ਅਤੇ ਇਸ ਲਈ ਗਲਤ ਵਾਪਿਸ ਆਉਂਦਾ ਹੈ.

ਇਸੇ ਤਰ੍ਹਾਂ, ਰੱਖਦਾ ਹੈ ਵਿਧੀ ਜਾਂਚਦੀ ਹੈ ਕਿ ਕੀ ਕੋਈ ਵਿਸ਼ੇਸ਼ ਮੁੱਲ ਮੌਜੂਦ ਹੈ. ਇੱਥੇ, 102 ਮੌਜੂਦ ਹਨ ਪਰ 110 ਮੌਜੂਦ ਨਹੀਂ ਹੈ ਅਤੇ ਇਸ ਲਈ ਗਲਤ ਵਾਪਿਸ ਆਉਂਦਾ ਹੈ.

import java.util.HashMap;
public class HashMapAdd {

  public static void main(String[] args) {
    HashMap<String,Integer> student = new HashMap<>();
    student.put("Arthi", 100);
    student.put("Dev", 105);
    student.put("Banu",102);
    student.put("Rishi", 108);
    System.out.println("Elements in student map:");
    System.out.println(student);
    
    System.out.println(student.containsKey("Dev"));
    System.out.println(student.containsKey("Ravi"));
    
    System.out.println(student.containsValue(102));
    System.out.println(student.containsValue(110));
  }

}
Elements in student map:
{Dev=105, Banu=102, Rishi=108, Arthi=100}
true
false
true
false

ਇੱਕ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜਾ ਹਟਾਓ ਅਤੇ ਬਦਲੋ

ਇਥੇ, ਅਸੀਂ ਇੰਟੇਜਰ ਅਤੇ ਜਾਵਾ ਵਿਚ ਹੈਸ਼ਮੈਪ ਬਣਾਉਂਦੇ ਹਾਂ ਸਤਰ ਭਾਸ਼ਾਵਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਟਾਈਪ ਕਰੋ. ਅਸੀਂ ਦੂਸਰੇ ਮੁੱਲ ਨੂੰ ਨਵੇਂ ਡੇਟਾ ਨਾਲ ਬਦਲਦੇ ਹਾਂ ਅਤੇ ਤੀਜੇ ਮੁੱਲ ਨੂੰ ਬਦਲ ਦਿੰਦੇ ਹਾਂ ਜੇ ਖਾਸ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜਾ ਵਰਤ ਕੇ ਨਕਸ਼ੇ ਵਿਚ ਮੌਜੂਦ ਹੈ ਬਦਲੋ () ਵਿਧੀ

ਤਦ, ਅਸੀਂ ਕੁੰਜੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਤੀਜੇ ਤੱਤ ਨੂੰ ਹਟਾਉਂਦੇ ਹਾਂ ਅਤੇ ਕੁੰਜੀ-ਵੈਲਯੂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ 3 ਤੱਤ ਨੂੰ ਹਟਾਉਂਦੇ ਹਾਂ ਹਟਾਓ () ਵਿਧੀ

import java.util.HashMap;
public class RemoveHashMap {

  public static void main(String[] args) {
    HashMap<Integer,String> lang = new HashMap<>();
    lang.put(1, "Java");
    lang.put(2, "C");
    lang.putIfAbsent(3, "C++");
    System.out.println(lang);
    
    lang.replace(2, "PHP");
    System.out.println(lang);
    
    lang.replace(3, "C++", "JavaScript");
    System.out.println(lang);
    
    lang.remove(3);
    System.out.println(lang);
    
    lang.remove(1, "Java");		
    System.out.println(lang);
    
    
  }

}
{1=Java, 2=C, 3=C++}
{1=Java, 2=PHP, 3=C++}
{1=Java, 2=PHP, 3=JavaScript}
{1=Java, 2=PHP}
{2=PHP}

ਸਾਫ ਅਤੇ ਖਾਲੀ methodsੰਗਾਂ ਦੀ ਉਦਾਹਰਣ

ਜਾਵਾ ਵਿੱਚ ਹੈਸ਼ਮੈਪ ਵਰਤਦਾ ਹੈ ਸਾਫ () ਨਕਸ਼ੇ ਵਿੱਚ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜਿਆਂ ਦੀ ਮੈਪਿੰਗ ਨੂੰ ਸਾਫ ਕਰਨ ਲਈ methodੰਗ ਅਤੇ ਖਾਲੀ ਹੈ ਵਿਧੀ ਜਾਂਚਦੀ ਹੈ ਕਿ ਕੀ ਨਕਸ਼ਾ ਖਾਲੀ ਹੈ. ਪਹਿਲੀ ਆਉਟਪੁੱਟ ਗਲਤ ਹੈ ਕਿਉਂਕਿ ਮੈਪਿੰਗ ਮੌਜੂਦ ਹੈ ਅਤੇ ਦੂਜਾ ਆਉਟਪੁੱਟ ਸਹੀ ਹੈ ਕਿਉਂਕਿ ਸਪੱਸ਼ਟ () ਵਿਧੀ ਨੂੰ ਲਾਗੂ ਕਰਨ ਤੋਂ ਬਾਅਦ ਨਕਸ਼ੇ ਵਿੱਚ ਕੋਈ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜ ਨਹੀਂ ਹੈ.

import java.util.HashMap;
public class RemoveHashMap {

  public static void main(String[] args) {
    HashMap<Integer,String> lang = new HashMap<>();
    lang.put(1, "Java");
    lang.put(2, "C");
    
    System.out.println(lang.isEmpty());
    lang.clear();
    
    System.out.println(lang.isEmpty());
    
  }

}
false
true

ਐਂਟਰੀਸੈੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦਿਆਂ ਹੈਸ਼ਮੈਪ ਤੱਤਾਂ ਦੁਆਰਾ ਭੰਡਾਰਨ

ਜਾਵਾ ਵਿੱਚ ਹੈਸ਼ਮੈਪ ਦੇ ਵਿਅਕਤੀਗਤ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜਿਆਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਅਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਐਂਟਰੀਸੈੱਟ ਦੇ ਨਾਲ ਹੈਸ਼ਮੈਪ ਦਾ ਤਰੀਕਾ ਇੰਦਰਾਜ਼ ਏ ਦਾ ਇਸਤੇਮਾਲ ਕਰਕੇ ਮੈਪ ਇੰਟਰਫੇਸ ਦਾ ਤਰੀਕਾ ਹਰ ਲੂਪ ਲਈ. ਨਕਸ਼ਾ ਇੰਟਰਫੇਸ ਦੇ ਐਂਟਰੀ methodੰਗ ਵਿੱਚ ਬਿਲਟ-ਇਨ ਵਿਧੀਆਂ ਹਨ ਜਿਵੇਂ ਕਿ geyKey () ਕੁੰਜੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਅਤੇ getValue () ਅਨੁਸਾਰੀ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ. ਅਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਅਕਾਰ () ਨਕਸ਼ੇ ਦਾ ਆਕਾਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ methodੰਗ.

import java.util.HashMap;
import java.util.Map;
public class IterateHashMap {

  public static void main(String[] args) {
    HashMap<String,String> cityState = new HashMap<>();
    cityState.put("Bangalore", "Karnataka");
    cityState.put("Chennai", "TamilNadu");
    cityState.put("Madurai", "TamilNadu");
    cityState.put("Mumbai", "Maharashtra");
    
    System.out.println("Size of map is : " + cityState.size());
    
    for(Map.Entry<String,String> m : cityState.entrySet())
    {
      System.out.println(m.getKey() + " : " + m.getValue());
    }

  }

}
Size of map is : 4
Chennai : TamilNadu
Madurai : TamilNadu
Mumbai : Maharashtra
Bangalore : Karnataka

ਕੀਸੈੱਟ () ਅਤੇ ਵੈਲਯੂਜ () ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਐਲੀਮੈਂਟਸ ਦੁਆਰਾ ਪਾਸ਼

ਹੈਸ਼ਮੈਪ ਐਲੀਮੈਂਟਸ ਨੂੰ ਲੂਪ ਕਰਨ ਦਾ ਇਕ ਹੋਰ ਤਰੀਕਾ ਹੈ ਕੀਸੈੱਟ () .ੰਗ. ਇਸਦੀ ਵਰਤੋਂ ਕਰਦਿਆਂ, ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਣ ਦੇ ਅਨੁਸਾਰ ਸਾਰੀਆਂ ਕੁੰਜੀਆਂ ਦਾ ਵੱਖਰਾ ਸਮੂਹ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ. ਸਾਰੇ ਮੁੱਲ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਅਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਮੁੱਲ () methodੰਗ ਅਤੇ ਲੂਪ ਲਈ ਪ੍ਰਿੰਟ.

ਕੀ-ਸੈੱਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਅਸੀਂ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦੁਹਰਾਓ ਦੇ ਕੇ ਕੀ-ਵੈਲਯੂ ਜੋੜਾਂ ਨੂੰ ਵੀ ਪ੍ਰਿੰਟ ਕਰ ਸਕਦੇ ਹਾਂ ਪ੍ਰਾਪਤ ਕਰੋ () ਸੰਬੰਧਿਤ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ .ੰਗ.

import java.util.HashMap;
import java.util.Map;
public class IterateHashMap {

  public static void main(String[] args) {
    HashMap<String,String> cityState = new HashMap<>();
    cityState.put("Bangalore", "Karnataka");
    cityState.put("Chennai", "TamilNadu");
    cityState.put("Madurai", "TamilNadu");
    cityState.put("Mumbai", "Maharashtra");
    
    System.out.println("Printing only keys:");
    for(String s : cityState.keySet())
    {
      System.out.println(s);
    }
    System.out.println();
    System.out.println("Printing only values: ");
    for(String c : cityState.values())
    {
      System.out.println(c);
    }
    System.out.println();
    System.out.println("Printing both key-value pairs:");
    for(String v : cityState.keySet())
    {
      System.out.println("Key: " + v + " | value: " + cityState.get(v));
    }
  }

}
Printing only keys:
Chennai
Madurai
Mumbai
Bangalore

Printing only values: 
TamilNadu
TamilNadu
Maharashtra
Karnataka

Printing both key-value pairs:
Key: Chennai | value: TamilNadu
Key: Madurai | value: TamilNadu
Key: Mumbai | value: Maharashtra
Key: Bangalore | value: Karnataka

ਸਿੱਟਾ

ਇਸ ਟਿutorialਟੋਰਿਅਲ ਵਿੱਚ, ਤੁਸੀਂ ਕਈ ਉਦਾਹਰਣਾਂ ਦੇ ਨਾਲ ਹੈਸ਼ਮੈਪ ਅਤੇ ਇਸਦੇ ਵੱਖ ਵੱਖ ਤਰੀਕਿਆਂ ਬਾਰੇ ਸਿੱਖਿਆ ਹੈ.

ਹਵਾਲਾ