ಜಾವಾ ಸೆಟ್ ಉದಾಹರಣೆ



ಜಾವಾ ಜಾವಾ ಸೆಟ್ ಹೊಂದಿಸಿ

ಜಾವಾ ಸೆಟ್ ಇಂಟರ್ಫೇಸ್ ಯಾವುದೇ ನಕಲಿ ಅಂಶಗಳನ್ನು ಹೊಂದಿರದ ಅಂಶಗಳ ಆದೇಶವಿಲ್ಲದ ಸಂಗ್ರಹವಾಗಿದೆ. ಸೆಟ್ ಇಂಟರ್ಫೇಸ್ ಜಾವಾದಲ್ಲಿನ ಗಣಿತದ ಸೆಟ್ನ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ನಾವು ಜಾವಾ ಸೆಟ್ ವಿಧಾನಗಳು ಮತ್ತು ಅವುಗಳ ಬಳಕೆಯ ವಿವಿಧ ಜಾವಾ ಸೆಟ್ ಉದಾಹರಣೆಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತೇವೆ.

ಸೆಟ್ ಇಂಟರ್ಫೇಸ್ನ ವೈಶಿಷ್ಟ್ಯಗಳು

  • ಇದು ಅನನ್ಯ ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಅಂದರೆ ಅದು ನಕಲಿ ಮೌಲ್ಯಗಳನ್ನು ಅನುಮತಿಸುವುದಿಲ್ಲ
  • ಅಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸುವಲ್ಲಿ ಜಾವಾ ಸೆಟ್‌ಗೆ ಯಾವುದೇ ಕ್ರಮವಿಲ್ಲ
  • ಇದು ಯಾವುದೇ ಸೂಚ್ಯಂಕವನ್ನು ಹೊಂದಿಲ್ಲ ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಸ್ಥಾನವನ್ನು ಆಧರಿಸಿ ಯಾವುದೇ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
  • ಇದು ಇಂಟರ್ಫೇಸ್ ಆಗಿರುವುದರಿಂದ, ಯಾವುದೇ ಸೆಟ್ ಅನುಷ್ಠಾನ ತರಗತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು
  • ಸಂಗ್ರಹ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ

ಜಾವಾ ಸೆಟ್ ಮತ್ತು ಜಾವಾ ಪಟ್ಟಿ ನಡುವಿನ ವ್ಯತ್ಯಾಸ

  • ಜಾವಾ ಸೆಟ್ ಅಂಶಗಳ ಕ್ರಮವಿಲ್ಲದ ಸಂಗ್ರಹವಾಗಿದೆ ಪಟ್ಟಿ ಅಂಶಗಳ ಆದೇಶ ಸಂಗ್ರಹವಾಗಿದೆ.
  • ಸೆಟ್ ಸೂಚ್ಯಂಕ ಆಧಾರಿತ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಲ್ಲ ಆದರೆ ಪಟ್ಟಿಯು ಸೂಚ್ಯಂಕವನ್ನು ಹೊಂದಿದೆ, ಅದರೊಂದಿಗೆ ನಾವು ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.
  • ಸೆಟ್ನಲ್ಲಿ, ನಕಲಿ ಮೌಲ್ಯಗಳನ್ನು ಸೇರಿಸಲು ಪಟ್ಟಿ ಅನುಮತಿಸುವಾಗ ನಾವು ನಕಲಿ ಮೌಲ್ಯಗಳನ್ನು ಸೇರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಅನುಷ್ಠಾನವನ್ನು ಹೊಂದಿಸಿ

ರಿಂದ ಜಾವಾ ಸೆಟ್ ಇಂಟರ್ಫೇಸ್ ಆಗಿದೆ, ನಾವು ನೇರವಾಗಿ ವಸ್ತುವನ್ನು ರಚಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಆದ್ದರಿಂದ ನಾವು ಹ್ಯಾಶ್‌ಸೆಟ್, ಟ್ರೀಸೆಟ್, ಲಿಂಕ್ಡ್‌ಹ್ಯಾಶ್‌ಸೆಟ್ ಅಥವಾ ಎನಮ್‌ಸೆಟ್‌ನಂತಹ ತರಗತಿಗಳಲ್ಲಿ ಒಂದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾಗಿದೆ. ಪ್ರತಿ ಸೆಟ್ ವರ್ಗವು ಕೆಳಗೆ ಚರ್ಚಿಸಿದಂತೆ ವಿಭಿನ್ನ ರೀತಿಯಲ್ಲಿ ವರ್ತಿಸುತ್ತದೆ:

  • ಹ್ಯಾಶ್‌ಸೆಟ್ - ಸೆಟ್ ಮೂಲಕ ಹಾದುಹೋಗುವಾಗ ಯಾವುದೇ ಕ್ರಮ ಅಥವಾ ಅಂಶಗಳ ಅನುಕ್ರಮವಿಲ್ಲ.
  • ಟ್ರೀಸೆಟ್ - ಇದು ವಿಂಗಡಣೆಯೊಂದಿಗೆ ಅಂಶಗಳ ಕ್ರಮವನ್ನು ಕಾಪಾಡುತ್ತದೆ
  • ಲಿಂಕ್ಡ್‌ಹ್ಯಾಶ್‌ಸೆಟ್ - ಇದು ಒಳಸೇರಿಸುವಿಕೆಯಂತೆಯೇ ಅಂಶಗಳ ಕ್ರಮವನ್ನು ಸಂರಕ್ಷಿಸುತ್ತದೆ

ಜಾವಾವನ್ನು ಹೊಂದಿಸಿ

ಜಾವಾ ಸೆಟ್ ಉದಾಹರಣೆ

ಸೆಟ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ನಾವು 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>();
  }
}

ಜಾವಾ ಸೆಟ್ ವಿಧಾನಗಳು

ಸೆಟ್ ಕೆಳಗೆ ನಮೂದಿಸಿದ ವಿಧಾನಗಳೊಂದಿಗೆ ಸಂಗ್ರಹ ಇಂಟರ್ಫೇಸ್ನ ಎಲ್ಲಾ ವಿಧಾನಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.

ವಿಧಾನವಿವರಣೆನಿಯತಾಂಕ
ಬೂಲಿಯನ್ ಆಡ್ (ಸ್ಟ್ರಿಂಗ್ ಇ)ಒಂದು ಅಂಶವು ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಅದನ್ನು ಸೇರಿಸುತ್ತದೆ. ಅಂಶವು ಈಗಾಗಲೇ ಸೆಟ್ನಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ ಮತ್ತು ಕರೆಯನ್ನು ನಿರ್ಲಕ್ಷಿಸಿದರೆ ಅದು ಸುಳ್ಳನ್ನು ನೀಡುತ್ತದೆe - ಸೆಟ್ಗೆ ಸೇರಿಸಬೇಕಾದ ಅಂಶ
ಬೂಲಿಯನ್ ಆಡ್ಆಲ್ (ಕಲೆಕ್ಷನ್ ಸಿ)ಸಂಗ್ರಹಣೆಯಲ್ಲಿನ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಅದು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ ಸೆಟ್ಗೆ ಸೇರಿಸುತ್ತದೆಸಿ - ಸೇರಿಸಬೇಕಾದ ಅಂಶಗಳ ಸಂಗ್ರಹ
ಅನೂರ್ಜಿತ ಸ್ಪಷ್ಟ ()ಸೆಟ್ನಿಂದ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ಸೆಟ್ ಖಾಲಿಯಾಗಿರುತ್ತದೆ
ಬೂಲಿಯನ್ ಒಳಗೊಂಡಿದೆ (ಆಬ್ಜೆಕ್ಟ್ ಒ)ಸೆಟ್ ಅಂಶವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಇದ್ದರೆ ನಿಜವಾಗುವುದುo - ಸೆಟ್ನಲ್ಲಿ ಹುಡುಕಬೇಕಾದ ಅಂಶ
ಬೂಲಿಯನ್ ಎಲ್ಲವನ್ನು ಹೊಂದಿದೆ (ಸಂಗ್ರಹ ಸಿ)ಸಂಗ್ರಹವು ಗುಂಪಿನ ಉಪವಿಭಾಗವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಇದ್ದರೆ ನಿಜವಾಗುವುದುಸಿ - ಅಂಶಗಳ ಸಂಗ್ರಹ
ಬೂಲಿಯನ್ ಸಮನಾಗಿರುತ್ತದೆ (ವಸ್ತು ಒ)ಅಂಗೀಕರಿಸಿದ ವಸ್ತುವಿನೊಂದಿಗೆ ಸೆಟ್ನ ಸಮಾನತೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಎರಡೂ ಸೆಟ್ ಆಗಿದ್ದರೆ ಮತ್ತು ಒಂದೇ ಅಂಶಗಳು ಮತ್ತು ಗಾತ್ರವನ್ನು ಹೊಂದಿದ್ದರೆ ಅದು ನಿಜವಾಗುತ್ತದೆo - ಹೋಲಿಸಬೇಕಾದ ವಸ್ತು
ಬೂಲಿಯನ್ isEmpty ()ಸೆಟ್ ಖಾಲಿಯಾಗಿದೆಯೆ ಅಥವಾ ಇಲ್ಲವೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಖಾಲಿಯಾಗಿದ್ದರೆ ನಿಜವಾಗುತ್ತದೆ
ಪುನರಾವರ್ತಕ ಪುನರಾವರ್ತಕ ()ಸೆಟ್ನಲ್ಲಿನ ಅಂಶಗಳ ಮೂಲಕ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಲು ಪುನರಾವರ್ತಕವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಬೂಲಿಯನ್ ತೆಗೆಯುವಿಕೆ (ವಸ್ತು ಒ)ಸೆಟ್ನಿಂದ ನಿರ್ದಿಷ್ಟ ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕಿದರೆ ನಿಜವಾಗುತ್ತದೆo - ತೆಗೆದುಹಾಕಬೇಕಾದ ಅಂಶ
ಬೂಲಿಯನ್ ತೆಗೆಯುವಿಕೆ ಎಲ್ಲ (ಸಂಗ್ರಹ ಸಿ)ಸಂಗ್ರಹದಲ್ಲಿರುವ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಇದ್ದರೆ ಸೆಟ್‌ನಿಂದ ತೆಗೆದುಹಾಕುತ್ತದೆಸಿ - ತೆಗೆದುಹಾಕಬೇಕಾದ ಅಂಶಗಳ ಸಂಗ್ರಹ
ಬೂಲಿಯನ್ ಉಳಿಸಿಕೊಳ್ಳುವ ಎಲ್ಲ (ಸಂಗ್ರಹ ಸಿ)ಸೆಟ್ನಲ್ಲಿನ ಸಂಗ್ರಹದಲ್ಲಿನ ಅಂಶಗಳನ್ನು ಮಾತ್ರ ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ ಅಂದರೆ ಸಂಗ್ರಹದ ಭಾಗವಾಗಿರದ ಎಲ್ಲಾ ಇತರ ಅಂಶಗಳನ್ನು ಇದು ತೆಗೆದುಹಾಕುತ್ತದೆಸಿ - ಉಳಿಸಿಕೊಳ್ಳಬೇಕಾದ ಅಂಶಗಳ ಸಂಗ್ರಹ
ಇಂಟ್ ಗಾತ್ರ ()ಸೆಟ್ನಲ್ಲಿನ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
SplitIterator splititerator ()ಸೆಟ್ನಲ್ಲಿನ ಅಂಶಗಳ ಮೇಲೆ ಸ್ಪ್ಲಿಟ್ ಇಟರೇಟರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ
ಆಬ್ಜೆಕ್ಟ್ [] toArray ()ಸೆಟ್ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ರಚನೆಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ ಟು ಸ್ಟ್ರಿಂಗ್ ()ವಸ್ತುವಿನ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ

ವಿನಾಯಿತಿಗಳನ್ನು ಹೊಂದಿಸಿ

ಜಾವಾ ಸೆಟ್ ಥ್ರೋ ಕೆಳಗಿನ ವಿನಾಯಿತಿಗಳು

  • ಬೆಂಬಲಿಸದ ಕಾರ್ಯಾಚರಣೆ ಎಕ್ಸೆಪ್ಶನ್
  • ಶೂನ್ಯಪಾಯಿಂಟರ್ ಎಕ್ಸೆಪ್ಶನ್
  • ಕ್ಲಾಸ್‌ಕ್ಯಾಸ್ಟ್ ಎಕ್ಸೆಪ್ಶನ್
  • ಕಾನೂನುಬಾಹಿರ ಆರ್ಗ್ಯುಮೆಂಟ್ ಎಕ್ಸೆಪ್ಶನ್

ಒಂದು ಗುಂಪಿನಿಂದ ಅಂಶಗಳನ್ನು ಸೇರಿಸಿ ಮತ್ತು ತೆಗೆದುಹಾಕಿ

ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಮೊದಲು ಹ್ಯಾಶ್‌ಸೆಟ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು 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 ಟ್ಪುಟ್ನಲ್ಲಿ, "XNUMX" ನಕಲಿ ಅಂಶವನ್ನು ಸೇರಿಸಲಾಗಿಲ್ಲ ಎಂದು ನೀವು ನೋಡಬಹುದು, ಇದು ಸೆಟ್ ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ. ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ ಕಂಡುಬರುವಂತೆ ನಾವು ಟ್ರೀಸೆಟ್ ಬಳಸಿ ಹ್ಯಾಶ್‌ಸೆಟ್‌ನ ಅಂಶಗಳನ್ನು ವಿಂಗಡಿಸಬಹುದು.

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]

ಜಾವಾ ಸೆಟ್ ಅನ್ನು ಅರೇಗೆ ಪರಿವರ್ತಿಸಿ

ನಾವು ಸೆಟ್ ಅನ್ನು ಒಂದು ಆಗಿ ಪರಿವರ್ತಿಸಬಹುದು ಸರಣಿ ಕೆಳಗೆ ವಿವರಿಸಿದಂತೆ toArray ವಿಧಾನವನ್ನು ಬಳಸುವ ಅಂಶಗಳ.

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

ಸೆಟ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಜಾವಾ ಪ್ರೋಗ್ರಾಂ ಉದಾಹರಣೆ (ಯೂನಿಯನ್, ers ೇದಕ ಮತ್ತು ವ್ಯತ್ಯಾಸ)

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು 2 ಪೂರ್ಣಾಂಕ ಸೆಟ್ಗಳನ್ನು ರಚಿಸಿದ್ದೇವೆ. 2 ಸೆಟ್‌ಗಳ ಒಕ್ಕೂಟವನ್ನು ನಿರ್ವಹಿಸಲು, ನಾವು ಆಡ್‌ಆಲ್ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ, ಅದು ಎರಡೂ ಸೆಟ್‌ಗಳಿಂದ ಎಲ್ಲಾ ವಿಶಿಷ್ಟ ಅಂಶಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ. Ers ೇದಕಕ್ಕಾಗಿ, ಸೆಟ್‌ಗಳ ನಡುವಿನ ಸಾಮಾನ್ಯ ಅಂಶಗಳನ್ನು ಮಾತ್ರ ಉಳಿಸಿಕೊಳ್ಳಲು ನಾವು ಉಳಿಸಿಕೊಳ್ಳುವ ಎಲ್ಲಾ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ. 2 ಸೆಟ್‌ಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಕಂಡುಹಿಡಿಯಲು, ನಾವು ತೆಗೆದುಹಾಕುವ ಎಲ್ಲ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ, ಅದು ಸೆಟ್ 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]

ತೀರ್ಮಾನ

ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ನೀವು ಜಾವಾದಲ್ಲಿ ಸೆಟ್ ಬಗ್ಗೆ ಮತ್ತು ವಿಭಿನ್ನ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ಗಳಿಗಾಗಿ ಸೆಟ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಮತ್ತು ಬಳಸುವುದು ಎಂಬುದರ ಬಗ್ಗೆ ಕಲಿತಿದ್ದೀರಿ.

ರೆಫರೆನ್ಸ್