ਜਾਵਾ ਸੈਟ ਉਦਾਹਰਨ



ਜਾਵਾ ਜਾਵਾ ਸੈੱਟ ਸੈੱਟ ਕਰੋ

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

ਸੈੱਟ ਇੰਟਰਫੇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

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

ਜਾਵਾ ਸੈੱਟ ਅਤੇ ਜਾਵਾ ਸੂਚੀ ਵਿੱਚ ਅੰਤਰ

  • ਜਾਵਾ ਸੈਟ ਇਕਾਈ ਰਹਿਤ ਤੱਤਾਂ ਦਾ ਸੰਗ੍ਰਹਿ ਹੈ ਜਦੋਂ ਕਿ ਸੂਚੀ ਇਕ ਤੱਤਾਂ ਦਾ ਕ੍ਰਮਵਾਰ ਸੰਗ੍ਰਹਿ ਹੈ.
  • ਸੈੱਟ ਵਿਚ ਇੰਡੈਕਸ-ਅਧਾਰਤ ਐਕਸੈਸ ਨਹੀਂ ਹੁੰਦੀ ਪਰ ਲਿਸਟ ਵਿਚ ਇਕ ਇੰਡੈਕਸ ਹੁੰਦਾ ਹੈ ਜਿਸ ਨਾਲ ਅਸੀਂ ਤੱਤ ਤੱਕ ਪਹੁੰਚ ਸਕਦੇ ਹਾਂ.
  • ਸੈਟ ਵਿੱਚ, ਅਸੀਂ ਡੁਪਲਿਕੇਟ ਵੈਲਯੂਜ ਨਹੀਂ ਜੋੜ ਸਕਦੇ ਜਦੋਂ ਕਿ ਲਿਸਟ ਡੁਪਲਿਕੇਟ ਵੈਲਯੂਜ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ.

ਲਾਗੂ ਕਰੋ

ਕਿਉਕਿ ਜਾਵਾ ਸੈੱਟ ਇਕ ਇੰਟਰਫੇਸ ਹੈ, ਅਸੀਂ ਸਿੱਧਾ ਇਕਾਈ ਨਹੀਂ ਬਣਾ ਸਕਦੇ. ਇਸ ਲਈ ਸਾਨੂੰ ਕਲਾਸਾਂ ਵਿਚੋਂ ਇਕ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜਿਵੇਂ ਕਿ ਹੈਸ਼ਸੈੱਟ, ਟ੍ਰੀਸੈੱਟ, ਲਿੰਕਡਹੈਸ਼ਸੈੱਟ, ਜਾਂ ਐਨੂਮਸੈੱਟ. ਹਰੇਕ ਸੈਟ ਕਲਾਸ ਵੱਖਰੇ mannerੰਗ ਨਾਲ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦੱਸਿਆ ਗਿਆ ਹੈ:

  • ਹੈਸ਼ਸੈੱਟ - ਸੈੱਟ ਵਿਚੋਂ ਲੰਘਦੇ ਸਮੇਂ ਤੱਤ ਦਾ ਕੋਈ ਕ੍ਰਮ ਜਾਂ ਕ੍ਰਮ ਨਹੀਂ ਹੁੰਦਾ.
  • ਟ੍ਰੀਸੈੱਟ - ਇਹ ਛਾਂਟਣ ਦੇ ਨਾਲ ਤੱਤ ਦੇ ਕ੍ਰਮ ਨੂੰ ਵੀ ਸੁਰੱਖਿਅਤ ਰੱਖਦਾ ਹੈ
  • ਲਿੰਕਡਹੈਸ਼ਸੇਟ - ਇਹ ਤੱਤ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੰਮਿਲਿਤ ਕਰਨ ਦੇ ਸਮਾਨ ਸੁਰੱਖਿਅਤ ਰੱਖਦਾ ਹੈ

ਜਾਵਾ ਸੈੱਟ ਕਰੋ

ਜਾਵਾ ਸੈਟ ਉਦਾਹਰਨ

ਨਿਰਧਾਰਤ ਇੰਟਰਫੇਸ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਸਾਨੂੰ java.util. * ਪੈਕੇਜ ਨੂੰ ਆਯਾਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ.

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {

  public static void main(String[] args) {
    Set set1 = new HashSet();
    Set set2 = new TreeSet();
    Set set3 = new LinkedHashSet();

  }

}

ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ ਅਸੀਂ ਸਧਾਰਣ ਸਮੂਹ ਵੀ ਬਣਾ ਸਕਦੇ ਹਾਂ. ਇੱਥੇ ਅਸੀਂ ਹੈਸ਼ਸੈੱਟ ਨੂੰ ਸਟਰਿੰਗ ਟਾਈਪ ਅਤੇ ਟ੍ਰੀਸੈੱਟ ਨੂੰ ਇੰਟੀਜ਼ਰ ਟਾਈਪ ਦੇ ਤੌਰ ਤੇ ਦਿੱਤਾ ਹੈ. ਇਸ ਲਈ ਇਹ ਵਸਤੂਆਂ ਇਨ੍ਹਾਂ ਵਿਸ਼ੇਸ਼ ਕਿਸਮਾਂ ਦੇ ਮੁੱਲ ਹੀ ਸਵੀਕਾਰਦੀਆਂ ਹਨ.

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {

  public static void main(String[] args) {
    Set<String> setstring = new HashSet<String>();
    Set<Integer> setint = new TreeSet<Integer>();
  }
}

ਜਾਵਾ ਸੈੱਟ ਦੇ .ੰਗ

ਸੈੱਟ ਵਿੱਚ ਹੇਠਾਂ ਦੱਸੇ ਗਏ ਤਰੀਕਿਆਂ ਦੇ ਨਾਲ ਕੁਲੈਕਸ਼ਨ ਇੰਟਰਫੇਸ ਦੇ ਸਾਰੇ includesੰਗ ਸ਼ਾਮਲ ਹਨ.

ਢੰਗਵੇਰਵਾਪੈਰਾਮੀਟਰ
ਬੂਲੀਅਨ ਐਡ (ਸਟਰਿੰਗ ਈ)ਸੈੱਟ ਵਿੱਚ ਇੱਕ ਐਲੀਮੈਂਟ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ ਜੇ ਇਹ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਨਹੀਂ ਹੈ. ਇਹ ਗਲਤ ਵਾਪਸ ਆਉਂਦੀ ਹੈ ਜੇ ਤੱਤ ਪਹਿਲਾਂ ਹੀ ਸੈੱਟ ਵਿੱਚ ਮੌਜੂਦ ਹੈ ਅਤੇ ਕਾਲ ਨੂੰ ਨਜ਼ਰ ਅੰਦਾਜ਼ ਕਰਦਾ ਹੈe - ਸੈੱਟ ਵਿੱਚ ਜੋੜਿਆ ਜਾਣ ਵਾਲਾ ਤੱਤ
ਬੁਲੀਅਨ ਐਡ ਆੱਲ (ਕੁਲੈਕਸ਼ਨ)ਸੰਗ੍ਰਹਿ ਵਿਚਲੇ ਸਾਰੇ ਤੱਤ ਨੂੰ ਸੈੱਟ ਵਿਚ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ ਜੇ ਇਹ ਪੇਸ਼ ਨਹੀਂ ਕਰਦਾc - ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਤੱਤਾਂ ਦਾ ਭੰਡਾਰ
ਰੱਦ ਸਾਫ ()ਸੈੱਟ ਤੋਂ ਸਾਰੇ ਤੱਤ ਹਟਾ ਦਿੰਦਾ ਹੈ ਅਤੇ ਸੈਟ ਖਾਲੀ ਹੋਵੇਗਾ
ਬੂਲੀਅਨ ਹੁੰਦੇ ਹਨ (ਆਬਜੈਕਟ ਓ)ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਸੈੱਟ ਵਿੱਚ ਤੱਤ ਹੈ ਅਤੇ ਜੇ ਮੌਜੂਦ ਹੈ ਤਾਂ ਸਹੀ ਵਾਪਸੀ ਕਰਦਾ ਹੈo - ਐਲੀਮੈਂਟ ਨੂੰ ਸੈੱਟ ਵਿੱਚ ਲੱਭਿਆ ਜਾਣਾ ਹੈ
ਬੂਲੀਅਨ ਹੁੰਦੇ ਹਨ ਸਾਰਾ (ਭੰਡਾਰ ਸੀ)ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਭੰਡਾਰ ਸੈਟ ਦਾ ਸਬਸੈੱਟ ਹੈ ਅਤੇ ਜੇ ਮੌਜੂਦ ਹੈ ਤਾਂ ਸਹੀ ਵਾਪਸ ਆਵੇਗਾc - ਤੱਤਾਂ ਦਾ ਭੰਡਾਰ
ਬੂਲੀਅਨ ਬਰਾਬਰ (ਆਬਜੈਕਟ ਓ)ਪਾਸ ਕੀਤੀ ਇਕਾਈ ਨਾਲ ਸੈਟ ਦੀ ਬਰਾਬਰੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ. ਇਹ ਸਹੀ ਵਾਪਸੀ ਕਰਦਾ ਹੈ ਜੇ ਦੋਵੇਂ ਸੈਟ ਹਨ ਅਤੇ ਇਕੋ ਤੱਤ ਅਤੇ ਅਕਾਰ ਵਾਲੇ ਹਨo - ਇਕਾਈ ਜਿਸਦੀ ਤੁਲਨਾ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ
ਬੂਲੀਅਨ ਇਮਪਟੀ ()ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਸੈੱਟ ਖਾਲੀ ਹੈ ਜਾਂ ਨਹੀਂ ਅਤੇ ਜੇ ਖਾਲੀ ਹੈ ਤਾਂ ਸਹੀ ਵਾਪਸ ਆਵੇਗਾ
ਆਇਟਰਰੇਟਰ ਦੁਹਰਾਉਣ ਵਾਲਾ ()ਸੈੱਟ ਵਿਚਲੇ ਤੱਤ ਨੂੰ ਨੈਵੀਗੇਟ ਕਰਨ ਲਈ ਇਕ ਦੁਹਰਾਉਣ ਵਾਲਾ ਵਾਪਸ ਕਰਦਾ ਹੈ
ਬੂਲੀਅਨ ਹਟਾਓ (ਆਬਜੈਕਟ ਓ)ਵਿਸ਼ੇਸ਼ ਤੱਤ ਨੂੰ ਸੈੱਟ ਤੋਂ ਹਟਾਉਂਦਾ ਹੈ ਅਤੇ ਸਹੀ ਵਾਪਸੀ ਕਰਦਾ ਹੈ ਜੇ ਤੱਤ ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈo - ਹਟਾਏ ਜਾਣ ਵਾਲੇ ਤੱਤ
ਬੂਲੀਅਨ ਹਟਾਓ ਸਾਰਾ (ਭੰਡਾਰ ਸੀ)ਸੰਗ੍ਰਹਿ ਵਿਚਲੇ ਸਾਰੇ ਤੱਤ ਨੂੰ ਸੈੱਟ ਤੋਂ ਹਟਾ ਦਿੰਦਾ ਹੈ ਜੇ ਮੌਜੂਦ ਹੈc - ਹਟਾਏ ਜਾਣ ਵਾਲੇ ਤੱਤਾਂ ਦਾ ਭੰਡਾਰ
ਬੂਲੀਅਨ ਰੀਟੇਨਲ (ਕੁਲੈਕਸ਼ਨ ਸੀ)ਸਮੂਹ ਵਿੱਚ ਸੰਗ੍ਰਹਿ ਵਿੱਚ ਸਿਰਫ ਤੱਤ ਰੱਖਦਾ ਹੈ ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਇਹ ਉਹ ਸਾਰੇ ਤੱਤ ਹਟਾ ਦਿੰਦਾ ਹੈ ਜੋ ਭੰਡਾਰ ਦਾ ਹਿੱਸਾ ਨਹੀਂ ਹਨਸੀ - ਬਰਕਰਾਰ ਰੱਖਣ ਵਾਲੇ ਤੱਤਾਂ ਦਾ ਭੰਡਾਰ
ਪੂਰਨ ਆਕਾਰ ()ਸੈੱਟ ਵਿਚ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ
ਸਪਲਿਟਇਟੇਟਰ ਸਪਲਿਟਾਈਟਰੇਟਰ ()ਸੈੱਟ ਵਿੱਚ ਤੱਤ ਉੱਤੇ ਇੱਕ ਸਪਲਿਟ ਈਟਰਰੇਟਰ ਬਣਾਉਂਦਾ ਹੈ
ਆਬਜੈਕਟ [] ਤੋਂ ਅਰੈ ()ਸੈੱਟ ਵਿਚਲੇ ਸਾਰੇ ਤੱਤਾਂ ਨੂੰ ਐਰੇ ਵਿਚ ਬਦਲਦਾ ਹੈ
ਸਟ੍ਰਿੰਗ ਟੂ ਸਟ੍ਰਿੰਗ ()ਆਬਜੈਕਟ ਦੀ ਇੱਕ ਸਤਰ ਦੀ ਨੁਮਾਇੰਦਗੀ ਵਾਪਸ ਕਰਦਾ ਹੈ

ਅਪਵਾਦ ਸੈੱਟ ਕਰੋ

ਜਾਵਾ ਸੈੱਟ ਸੁੱਟ ਹੇਠ ਅਪਵਾਦ

  • ਅਸਮਰਥਿਤਓਪ੍ਰੇਸ਼ਨ ਐਕਸੈਪਸ਼ਨ
  • NullPointerException
  • ਕਲਾਸਕਾਸਟਐਕਸੈਪਸ਼ਨ
  • ਗੈਰਕਨੂੰਨੀ ਆਰਗੂਮੈਂਟ ਐਕਸੈਪਸ਼ਨ

ਸੈੱਟ ਤੋਂ ਤੱਤ ਸ਼ਾਮਲ ਅਤੇ ਹਟਾਓ

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

ਹਟਾਉਣ ਦੀ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ 1 ਸਮੂਹ ਵਿੱਚੋਂ ਇੱਕ ਤੱਤ ਹਟਾਉਂਦੇ ਹਾਂ ਅਤੇ ਫਿਰ ਦੂਜੇ ਸਮੂਹ ਵਿੱਚੋਂ ਸਾਰੇ ਤੱਤ ਹਟਾ ਦਿੰਦੇ ਹਾਂ.

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {

  public static void main(String[] args) {

    Set<String> setstring = new HashSet<String>();
    setstring.add("Java");
    setstring.add("Javascript");
    System.out.println(setstring);
    
    Set<String> string2 = new HashSet<String>();
    string2.add("C");
    string2.add("C++");
    
    setstring.addAll(string2);
    System.out.println("Elements in set after addAll operation");
    System.out.println(setstring);
    
    setstring.remove("Javascript");
    System.out.println("Elements in the set after remove opertaion");
    System.out.println(setstring);
    
    setstring.removeAll(string2);
    System.out.println("Elements in the set after removeAll opertaion");
    System.out.println(setstring);
    
  }
  

}
Output:
[Java, Javascript]
Elements in set after addAll operation
[Java, C++, C, Javascript]
Elements in the set after remove opertaion
[Java, C++, C]
Elements in the set after removeAll opertaion
[Java]

ਟ੍ਰੀਸੈੱਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੱਤਾਂ ਦੀ ਛਾਂਟੀ ਕਰਨਾ

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

import java.util.*;

public class SetSort {

  public static void main(String[] args) {
    Set<Integer> numbers = new HashSet<Integer>();
    int[] a = {34,78,12,67,45,23,12,89};
    for(int i=0;i<a.length;i++) {
      numbers.add(a[i]);
    }
    System.out.println("Elements in HashSet");
    System.out.println(numbers);
    
    Set<Integer> treeset = new TreeSet<Integer>(numbers);
    System.out.println("Elements in treeset after sort");
    System.out.println(treeset);
  }

}
Output:
Elements in HashSet
[34, 67, 23, 89, 12, 45, 78]
Elements in treeset after sort
[12, 23, 34, 45, 67, 78, 89]

ਜਾਵਾ ਸੈੱਟ ਨੂੰ ਐਰੇ ਵਿੱਚ ਬਦਲੋ

ਅਸੀਂ ਸੈੱਟ ਨੂੰ ਏ ਵਿਚ ਬਦਲ ਸਕਦੇ ਹਾਂ ਐਰੇ ਹੇਠ ਦਿੱਤੇ ਅਨੁਸਾਰ ਟੌਅਰੇ methodੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਤੱਤਾਂ ਦੀ.

import java.util.*;

public class SetArray {

  public static void main(String[] args) {
    Set<String> names = new HashSet<String>();
    names.add("Roshan");
    names.add("Kiran");
    names.add("Tejas");
    names.add("Karthik");
    
    String[] strnames = names.toArray(new String[names.size()]);
    for(String strvalues: strnames) {
      System.out.println(strvalues);
    }

  }

}
Output:
Roshan
Kiran
Tejas
Karthik

ਸੈੱਟ ਓਪਰੇਸ਼ਨਾਂ ਦਾ ਉਦਾਹਰਣ ਜਾਵਾ ਪ੍ਰੋਗਰਾਮ (ਯੂਨੀਅਨ, ਲਾਂਘਾ, ਅਤੇ ਅੰਤਰ)

ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ 2 ਪੂਰਨ ਅੰਕ ਸੈਟ ਕੀਤੇ ਹਨ. 2 ਸੈੱਟਾਂ ਦਾ ਯੂਨੀਅਨ ਕਰਨ ਲਈ, ਅਸੀਂ ਐਡ-ਆੱਲ methodੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਜੋ ਦੋਵਾਂ ਸੈੱਟਾਂ ਦੇ ਸਾਰੇ ਵਿਲੱਖਣ ਤੱਤ ਜੋੜ ਦੇਵੇਗਾ. ਲਾਂਘਾ ਦੇ ਲਈ, ਅਸੀਂ ਸੈੱਟਾਂ ਦੇ ਵਿਚਕਾਰ ਸਿਰਫ ਸਧਾਰਣ ਤੱਤ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਣ ਲਈ ਰਿਟੇਨ ਆਲ .ੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ. 2 ਸੈੱਟਾਂ ਦੇ ਵਿਚਕਾਰ ਫਰਕ ਨੂੰ ਲੱਭਣ ਲਈ, ਅਸੀਂ ਹਟਾਉਣ ਵਾਲੇ ਸਾਰੇ methodੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਜੋ ਕਿ ਸੈੱਟ 2 ਦੇ ਸਾਰੇ ਤੱਤਾਂ ਨੂੰ ਸੈੱਟ 1 ਵਿੱਚ ਆਮ ਤੱਤਾਂ ਦੇ ਨਾਲ ਹਟਾ ਦੇਵੇਗਾ.

import java.util.*;

public class SetOperations {

  public static void main(String[] args) {
    Set<Integer> set1 = new HashSet<Integer>();
    set1.add(3);
    set1.add(7);
    set1.add(5);
    set1.add(1);
    System.out.println("Set 1 : " + set1);
    
    Set<Integer> set2 = new HashSet<Integer>();
    set2.add(3);
    set2.add(4);
    set2.add(9);
    set2.add(5);
    
    System.out.println("Set 2 : " + set2);
    
    Set<Integer> a = new HashSet<Integer>(set1);
    a.addAll(set2);
    
    System.out.println("Union of Set 1 and Set 2 : " + a);
    
    Set<Integer> b = new HashSet<Integer>(set1);
    b.retainAll(set2);
    System.out.println("Intersection of Set 1 and Set 2 : " + b);
    
    Set<Integer> c = new HashSet<Integer>(set1);
    c.removeAll(set2);
    System.out.println("Difference between Set 1 and Set 2 : " + c);
  }

}
Output:
Set 1 : [1, 3, 5, 7]
Set 2 : [3, 4, 5, 9]
Union of Set 1 and Set 2 : [1, 3, 4, 5, 7, 9]
Intersection of set 1 and set 2 : [3, 5]
Difference between 2 sets : [1, 7]

ਸਿੱਟਾ

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

ਹਵਾਲਾ