Java באַשטעטיקט בייַשפּיל



ז'אבא Java באַשטעטיקט שטעלן

Java Set צובינד איז אַן אַנאָרדערד זאַמלונג פון עלעמענטן וואָס טאָן ניט אַנטהאַלטן קיין דופּליקאַט עלעמענטן. די שטעלן צובינד אָפפערס פֿעיִקייטן פון די מאַטאַמאַטיקאַל שטעלן אין Java. אין דעם טוטאָריאַל, מיר וועלן דעקן פאַרשידן ביישפילן פון Java שטעלן פון Java שטעלן מעטהאָדס און זייער נוצן.

פֿעיִקייטן פון באַשטעטיק צובינד

  • עס כּולל יינציק עלעמענטן וואָס מיינען אַז עס קען נישט לאָזן דופּליקאַט וואַלועס
  • Java Set טוט נישט האָבן קיין סדר צו סטאָרד די עלעמענטן
  • עס האט נישט קיין אינדעקס און דעריבער מיר קענען נישט אַקסעס קיין עלעמענטן באזירט אויף דער שטעלע.
  • זינט עס איז אַ צובינד, מיר קענען ינסטרומענט עס מיט קיין פון די שטעלן ימפּלאַמענטיישאַן קלאסן
  • עקסטענדס קאַלעקשאַן צובינד

חילוק צווישן Java Set און Java List

  • Java באַשטעטיקט איז אַ אַנאָרדערד זאַמלונג פון עלעמענטן רעשימע איז אַ אָרדערד זאַמלונג פון עלעמענטן.
  • שטעלן האט נישט אינדעקס-באזירט אַקסעס אָבער ליסטע האט אַן אינדעקס מיט וואָס מיר קענען אַקסעס עלעמענטן.
  • אין באַשטעטיקן, מיר קענען נישט לייגן דופּליקאַט וואַלועס בשעת רשימה אַלאַוז אַדינג דופּליקאַט וואַלועס.

שטעלן ימפּלעמענטאַטיאָן

זינט Java Set איז אַ צובינד, מיר קענען נישט מאַכן אַ כייפעץ גלייַך. דעריבער מיר דאַרפֿן צו ינסטרומענט איינער פון די קלאסן ווי HashSet, TreeSet, LinkedHashSet אָדער EnumSet. יעדער גאַנג קלאַס ביכייווז אין אַ אַנדערש שטייגער ווי דיסקאַסט ונטער:

  • האַשסעט - עס איז קיין סדר אָדער סיקוואַנס פון עלעמענטן בשעת דורכפאָר דורך דעם גאַנג.
  • טרעעסעט - עס פּרעזערווייז די סדר פון עלעמענטן צוזאמען מיט סאָרטינג
  • לינקדהאַשסעט - עס פּרעזערווייז די סדר פון עלעמענטן די זעלבע ווי ינסערשאַן

שטעלן Java

Java באַשטעטיקט בייַשפּיל

אין סדר צו ינסטרומענט די שטעלן צובינד, מיר דאַרפֿן צו אַרייַנפיר די 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>();
  }
}

Java באַשטעטיקט מעטהאָדס

שטעלן כולל אַלע די מעטהאָדס פון קאַלעקשאַן צובינד צוזאמען מיט די אונטן-דערמאנט מעטהאָדס.

מעטאָדבאַשרייַבונגפּאַראַמעטער
באָאָלעאַן לייגן (שטריקל E)לייגט אַן עלעמענט צו דעם גאַנג אויב עס איז נישט עקסיסטירט. עס קערט פאַלש אויב עלעמענט שוין יגזיסץ אין דעם גאַנג און יגנאָרז די רופןe - דער עלעמענט צו זיין מוסיף צו דעם גאַנג
באָאָלעאַן אַדדאַלל (קאַלעקשאַן)מוסיף אַלע די עלעמענטן אין דער זאַמלונג צו דעם גאַנג אויב עס איז נישט פאָרשטעלןc - זאַמלונג פון עלעמענטן צו זיין מוסיף
פּאָסל קלאָר ()רימוווז אַלע די עלעמענטן פֿון דער שטעלן און שטעלן וועט זיין ליידיק
באָאָלעאַן כּולל (כייפעץ אָ)טשעקס אויב די סכום כּולל די עלעמענט און קערט אמת אויב עס איז פאָרשטעלןאָ - עלעמענט צו זיין געזוכט אין דעם גאַנג
באָאָלעאַן כּולל אַלע (זאַמלונג C)טשעקס אויב די זאַמלונג איז אַ סאַבסעט פון דער סכום און קערט אמת אויב עס איז פאָרשטעלןc - זאַמלונג פון עלעמענטן
באָאָלעאַן יקוואַלז (כייפעץ אָ)טשעקס די יקוואַלאַטי פון דעם גאַנג מיט דעם כייפעץ דורכגעגאנגען. עס קערט אמת אויב ביידע זענען סעץ און כּולל זעלביקער עלעמענטן און גרייסאָ - כייפעץ וואָס דאַרף זיין קאַמפּערד
באָאָלעאַן isEmpty ()טשעקס אויב די סכום איז ליידיק אָדער נישט און קערט אמת אויב ליידיק
יטעראַטאָר יטעראַטאָר ()קערט אַ יטעראַטאָר צו נאַוויגירן דורך די עלעמענטן אין דער סכום
באָאָלעאַן אַראָפּנעמען (כייפעץ אָ)רימוווז דער ספּעציפיש עלעמענט פֿון דער סכום און קערט אמת אויב דער עלעמענט איז אַוועקגענומעןאָ - דער עלעמענט צו ווערן אַוועקגענומען
באָאָלעאַן אַראָפּנעמען אַלע (זאַמלונג C)רימוווז אַלע די עלעמענטן אין דער זאַמלונג אויב עס איז פאָרשטעלןc - זאַמלונג פון עלעמענטן צו ווערן אַוועקגענומען
באָאָלעאַן ריטיין כל (זאַמלונג C)כּולל בלויז די עלעמענטן אין דער זאַמלונג אין דעם סכום וואָס מיטל אַז עס רימוווז אַלע אנדערע עלעמענטן וואָס זענען נישט טייל פון דער זאַמלונגc - זאַמלונג פון עלעמענטן צו זיין ריטיינד
ינט גרייס ()קערט די נומער פון עלעמענטן אין דער סכום
ספּליטיטעראַטאָר ספּליטיטעראַטאָר ()קרעאַטעס אַ שפּאַלטן יטעראַטאָר איבער די עלעמענטן אין דעם גאַנג
כייפעץ [] צו אַררייַ ()קאָנווערץ אַלע די עלעמענטן אין דעם גאַנג צו מענגע
שטריקל צו שטריקל ()רעטורנס אַ שטריקל פאַרטרעטונג פון די כייפעץ

שטעלן אויסנעמען

Java שטעלן ווארפט ער די אונטן אויסנעמען

  • UnsupportedOperationException
  • NullPointerException
  • ClassCastException
  • IllegalArgumentException

לייג און באַזייַטיקן עלעמענטן פֿון אַ סכום

אין די ביישפּיל, מיר ערשטער שאַפֿן אַ האַשסעט און לייגן 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]

גער Java Set to Array

מיר קענען קאָנווערט שטעלן אין אַן מענגע פון עלעמענטן ניצן די 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

בייַשפּיל Java פּראָגראַם פון באַשטעטיקט אָפּעראַטיאָנס (פֿאַרבאַנד, ינטערסעקשאַן און דיפעראַנסיז)

אין דעם בייַשפּיל, מיר האָבן באשאפן 2 ינטאַדזשער שטעלט. צו דורכפירן אַ פאַרבאַנד פון 2 סעץ, מיר נוצן די אַדדאַלל מעטהאָדס, וואָס וועט לייגן אַלע יינציק עלעמענטן פֿון ביידע סעץ. פֿאַר ינטערסעקשאַן, מיר נוצן די רעטאַינאַלל מעטהאָדס צו האַלטן בלויז די פּראָסט עלעמענטן צווישן די סעץ. צו געפֿינען די חילוק צווישן 2 שטעלט, מיר נוצן די removeAll מעטאָד וואָס וועט באַזייַטיקן אַלע יסודות אין סעט 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]

סאָף

אין דעם טוטאָריאַל, איר האָט געלערנט וועגן באַשטעטיקט אין Java און ווי אַזוי צו שאַפֿן און נוצן שטעלן פֿאַר פאַרשידענע מאַניפּיאַליישאַנז.

דערמאָנען