Java მითითებული მაგალითი  



Java ჯავის ნაკრები უცნობია

Java Set ინტერფეისი არის ელემენტების არაორგანიზებული კოლექცია, რომელიც არ შეიცავს არცერთ დუბლირებულ ელემენტს. Set ინტერფეისი გთავაზობთ მათემატიკური ნაკრების მახასიათებლებს java- ში. ამ სახელმძღვანელოში ჩვენ განვახილავთ ჯავის ნაკრების სხვადასხვა მაგალითებს Java set მეთოდებისა და მათი გამოყენების შესახებ.

Set ინტერფეისის მახასიათებლები  

  • ის შეიცავს უნიკალურ ელემენტებს, რაც ნიშნავს, რომ არ იძლევა დუბლიკატების მნიშვნელობებს
  • Java Set– ს არ აქვს რაიმე შეკვეთა ელემენტების შენახვაში
  • მას არ აქვს არანაირი ინდექსი და, შესაბამისად, ვერ ვწვდებით არცერთ ელემენტს პოზიციიდან გამომდინარე.
  • ვინაიდან ეს არის ინტერფეისი, მისი დანერგვა შეგვიძლია Set- ის განხორციელების ნებისმიერი კლასის გამოყენებით
  • აგრძელებს კოლექციის ინტერფეისს

განსხვავება Java Set- სა და Java List- ს შორის  

  • Java Set არის ელემენტების არაორგანიზებული კოლექცია, ხოლო სია არის ელემენტების შეკვეთილი კრებული.
  • სეტს არ აქვს ინდექსზე დაფუძნებული წვდომა, მაგრამ ჩამონათვალს აქვს ინდექსი, რომლითაც ელემენტებზე წვდომა შეგვიძლია.
  • Set- ში, ჩვენ არ შეგვიძლია დავამატოთ დუბლირებული მნიშვნელობები, ხოლო სია საშუალებას გვაძლევს დაამატოთ დუბლირებული მნიშვნელობები.

განხორციელების დაყენება  

მას შემდეგ, რაც ჯავის ნაკრები არის ინტერფეისი, ჩვენ პირდაპირ ობიექტს ვერ შევქმნით. ამრიგად, ჩვენ უნდა განვახორციელოთ ერთ-ერთი კლასი, როგორიცაა HashSet, TreeSet, LinkedHashSet ან EnumSet. თითოეული ნაკრების კლასი განსხვავებულად იქცევა, როგორც ქვემოთ არის განხილული:

  • HashSet - არ არსებობს ელემენტების თანმიმდევრობა ან თანმიმდევრობა სიმრავლეში გადატანისას.
  • TreeSet - ის ინარჩუნებს ელემენტების თანმიმდევრობას დახარისხებასთან ერთად
  • LinkedHashSet - ის ინარჩუნებს ელემენტების თანმიმდევრობას იგივეა, რაც ჩასმა
იხილეთ ასევე
სკანერის კლასი Java და იმპორტი სკანერის 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();

  }

}

ასევე შეგვიძლია შევქმნათ ზოგადი ნაკრებები, როგორც ნაჩვენებია ქვემოთ. აქ ჩვენ დავაკონკრეტეთ HashSet როგორც სიმების ტიპი და TreeSet როგორც მთელი ტიპის. ამრიგად, ეს ობიექტები მხოლოდ ამ კონკრეტული ტიპების მნიშვნელობებს იღებენ.

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 Set მეთოდები  

ნაკრები მოიცავს კოლექციის ინტერფეისის ყველა მეთოდს ქვემოთ ჩამოთვლილ მეთოდებთან ერთად.

მეთოდიაღწერაპარამეტრი
ლოგიკური დამატება (სიმებიანი e)სიმრავლეს ამატებს ელემენტს, თუ ის უკვე არ არსებობს. იგი ყალბი ბრუნდება, თუ ელემენტი უკვე არსებობს სიმრავლეში და უგულებელყოფს ზარსe - სიმრავლეში დამატებული ელემენტი
ლოგიკური დამატება ყველა (Collectionc)კოლექციაში დამატება ყველა ელემენტი, თუ ის არ არის წარმოდგენილიგ - დამატებული ელემენტების კრებული
ბათილია გასაგები ()ხსნის ყველა ელემენტს ნაკრებიდან და ნაკრები ცარიელი იქნება
ლოგიკური შეიცავს (ობიექტი o)ამოწმებს, შეიცავს თუ არა ელემენტს ელემენტს და აბრუნებს თუ არა trueo - სიმრავლეში მოსაძებნი ელემენტი
ლოგიკური შეიცავს ყველა (კოლექცია c)ამოწმებს, არის თუ არა კოლექცია სიმრავლეების ქვესიმრავლე და ბრუნდება ნამდვილი, თუ ეს არისგ - ელემენტების კრებული
ლოგიკური ტოლია (ობიექტი o)ამოწმებს სიმრავლის თანასწორობას გავლილ ობიექტთან. იგი უბრუნდება სიმართლეს, თუ ორივე სიმრავლეა და შეიცავს ერთნაირ ელემენტებს და ზომასo - ობიექტი, რომლის შედარებაა საჭირო
ლოგიკური არის ცარიელი ()ამოწმებს ცარიელია თუ არა სიმრავლე და აბრუნებს თუ არა ცარიელი
Iterator iterator ()აბრუნებს იტერატორს ნაკრების ელემენტებში გადასასვლელად
ლოგიკური ამოღება (ობიექტი o)ხსნის სპეციფიკურ ელემენტს სიმრავლიდან და უბრუნდება true თუ ელემენტი ამოღებულიაo - ამოღებული ელემენტი
ლოგიკური ამოღება ყველა (კოლექცია c)ასლის შემთხვევაში, კოლექციიდან შლის ყველა ელემენტსგ - ამოღებული ელემენტების კრებული
boolean retainAll (კოლექცია c)ინახავს კოლექციაში მხოლოდ ელემენტებს, რაც ნიშნავს, რომ ის ხსნის ყველა სხვა ელემენტს, რომლებიც არ არიან კოლექციის ნაწილიგ - შესანარჩუნებელი ელემენტების კრებული
int ზომა ()აბრუნებს სიმრავლის ელემენტების რაოდენობას
SplitIterator splititerator ()ქმნის სპლიტ – იტერატორს ნაკრების ელემენტებზე
ობიექტი [] toArray ()სიმრავლის ყველა ელემენტს გარდაქმნის მასივში
სიმებიანი toString ()აბრუნებს ობიექტის სიმების წარმოდგენას
იხილეთ ასევე
DataInputStream ჯავაში

გამონაკლისების დაყენება  

ჯავის ნაკრები ისვრის ქვემოთ მოცემული გამონაკლისები

  • მხარდაუჭერელი ოპერაციის გამონაკლისი
  • NullPointerException
  • ClassCastException
  • არალეგალური არგუმენტი გამონაკლისი

დაამატეთ და ამოიღეთ ელემენტები სიმრავლიდან  

ქვემოთ მოყვანილ მაგალითში, პირველ რიგში, ჩვენ ვქმნით HashSet- ს და ვამატებთ 2 ელემენტს. შემდეგ ჩვენ ვქმნით სხვა HashSet- ს და ვამატებთ კიდევ 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]

ელემენტების დახარისხება TreeSet– ის გამოყენებით  

აქ, ჩვენ გამოვაცხადეთ მთლიანი მასივი და შემდეგ დავამატეთ ელემენტები HashSet– ს მარყუჟის გამოყენებით. გამომავალში ხედავთ, რომ დუბლიკატი ელემენტი "12" არ არის შეტანილი, რომელიც არის მითითებული თვისება. HashSet– ის ელემენტების დალაგება შეგვიძლია TreeSet– ის გამოყენებით, როგორც ჩანს ქვემოთ მოცემულ მაგალითში.

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

Set ოპერაციების Java პროგრამის მაგალითი (კავშირი, კვეთა და განსხვავება)  

ამ მაგალითში ჩვენ შევქმენით 2 მთელი რიცხვი. 2 ნაკრების გაერთიანების შესასრულებლად, ჩვენ ვიყენებთ addAll მეთოდს, რომელიც დაამატებს ყველა უნიკალურ ელემენტს ორივე სიმრავლიდან. კვეთისთვის ვიყენებთ retainAll მეთოდს, რომ შევინარჩუნოთ მხოლოდ საერთო ელემენტები სიმრავლეებს შორის. 2 სიმრავლეს შორის განსხვავების დასადგენად, ჩვენ ვიყენებთ removeAll მეთოდს, რომელიც ამოიღებს set2– ის ყველა ელემენტს, set1– ის საერთო ელემენტებს

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]

დასკვნა  

ამ სახელმძღვანელოში თქვენ გაეცანით Set in Java და როგორ შექმნათ და გამოიყენოთ set სხვადასხვა მანიპულირებისთვის.

იხილეთ ასევე
ჩამოთვლა ჯავაში

Reference