ජාවා හි LinkedHashSet



ජාවා ජාවා සෙට්

ජාවා LinkedHashSet

ජාවා LinkedHashSet ක්‍රියාත්මක කරයි කට්ටලයක් අතුරු මුහුණත සහ හැෂ්සෙට් පන්තිය දිගු කරයි. එය හැෂ් ටේබල් එකේ දෙබිඩි සම්බන්ධිත ලැයිස්තුවක් ක්‍රියාත්මක කිරීම භාවිතා කරයි. මෙයින් අදහස් කරන්නේ එය මූලද්‍රව්‍ය හරහා නැවත ගමන් කරන අතරතුර ඇතුළත් කිරීමේ අනුපිළිවෙල පවත්වා ගෙන යන බවයි. අපි මූලද්‍රව්‍ය ඇතුළත් කළ ආකාරයටම ලබා ගත හැකිය.

ජාවා LinkedHashSet හි විශේෂාංග

ජාවා LinkedHashSet හි වැදගත් අංග පහත දැක්වේ:

  • අපට සබැඳි හැෂ්සෙට් එකක අද්විතීය අංග පමණක් ගබඩා කළ හැකිය.
  • අප ඇතුළු කරන එකම අනුපිළිවෙලින් මූලද්‍රව්‍ය ලබා ගැනීමේ හැකියාව
  • සමමුහුර්ත නොකළ.
  • ශුන්‍ය මූලද්‍රව්‍ය ගබඩා කිරීමට ඉඩ දෙන්න.
  • හැෂ් කේතය මත පදනම්ව නිශ්චිත දර්ශකයේ මූලද්‍රව්‍ය ගබඩා කිරීම සඳහා හැෂිං තාක්ෂණය භාවිතා කරයි.

ධූරාවලිය

ජාවා හි LinkedHashSet

ඉදිකිරීම්කරුවන්

පහත දැක්වෙන්නේ ඉදිකිරීම්කරුවන් එය අපට ජාවා LinkedHashSet පන්තිය සඳහා භාවිතා කළ හැකිය.

ඉදිකිරීම්කරුවිස්තර
LinkedHashSet ()සුපුරුදු LinkedHashSet නිර්මාණය කරයි
LinkedHashSet (int ධාරිතාව)නිශ්චිත ධාරිතාවක් සහිත LinkedHashSet නිර්මාණය කරයි
LinkedHashSet (int ධාරිතාව, float loadFactor)නිශ්චිත ධාරිතාව සහ පැටවීමේ සාධකය සමඟ සම්බන්ධිත හැෂ්සෙට් එකක් සාදයි.
LinkedHashSet (එකතුව ඇ)නිශ්චිත එකතුව සමඟ සම්බන්ධිත හැෂ්සෙට් එකක් සාදයි

ක්රම

පහත දැක්වෙන්නේ ක්රම ජාවා LinkedHashSet පන්තිය මඟින් සහය දක්වයි.

ක්රමයවිස්තරපරාමිතීන්
බූලියන් එකතු කිරීම (වස්තුව ඊ)නිශ්චිත අංගය කට්ටලයට එකතු කරයිe - එකතු කළ යුතු මූලද්රව්යය
මූලද්‍රව්‍යය දැනටමත් නොමැති නම් සත්‍ය වේ
මූලද්රව්යය දැනටමත් තිබේ නම් සාවද්ය වේ
බූලියන් ඇඩ්ඒල් (එකතුව ඇ)නිශ්චිත එකතුවෙහි ඇති සියලුම අංග එකතු කරයිc - එකතු කිරීමට අවශ්‍ය අංග අඩංගු එකතුව
void clear ()කට්ටලයේ ඇති සියලුම අංග ඉවත් කර කට්ටලය හිස් කරයි
වස්තු ක්ලෝන ()TreeSet නිදසුනෙහි නොගැඹුරු පිටපතක් ලබා දෙයි
බූලියන් අඩංගු වේ (වස්තුව o)කට්ටලයේ නිශ්චිත මූලද්‍රව්‍යය තිබේ නම් සත්‍ය වේo - සෙවිය යුතු අංගය
බූලියන් සියල්ල අඩංගු වේ (එකතුව ඇ)එකතුවෙහි නිශ්චිතව දක්වා ඇති සියලුම අංග කට්ටලයේ අඩංගු නම් සත්‍ය වේc - සෙවීම සඳහා එකතු කිරීමේ අංග
බූලියන් සමාන (වස්තුව o)කට්ටලයේ නිශ්චිත වස්තුව සංසන්දනය කරයිතිබේ නම් සත්‍ය වේ
නොමැති නම් අසත්‍යය ලබා දෙයි
බූලියන් isEmpty ()කට්ටලය හිස් නම් සහ කිසිදු අංගයක් නොමැති නම් සත්‍ය වේ
අනුකාරක අනුකාරකය ()ආරෝහණ අනුපිළිවෙලෙහි ඇති මූලද්‍රව්‍යවලට වඩා අනුකාරකයක් ලබා දෙයි
බූලියන් ඉවත් කිරීම (වස්තුව o)නිශ්චිත අංගය කට්ටලයෙන් ඉවත් කරයිo - ඉවත් කළ යුතු මූලද්රව්යය
බූලියන් ඉවත් කිරීම සියල්ල (එකතුව ඇ)නිශ්චිත එකතුවෙහි ඇති සියලුම අංග ඉවත් කරයිc - ඉවත් කළ යුතු මූලද්‍රව්‍ය එකතුව
බූලියන් රඳවා තබා ගැනීම සියල්ල (එකතුව ඇ)කට්ටලයේ නිශ්චිත එකතුවෙහි ඇති සියලුම අංග රඳවා තබා ඇති අතර කට්ටලයේ අනෙක් අංග ඉවත් කරයිc - රඳවා ගත යුතු මූලද්‍රව්‍ය එකතුව
int ප්‍රමාණය ()කට්ටලයේ ඇති මූලද්‍රව්‍ය ගණන වන කට්ටලයේ ප්‍රමාණය ලබා දෙයි
Spliterator spliterator ()කට්ටලයේ ඇති මූලද්රව්ය හරහා ස්ප්ලිටරේටරය ලබා දෙයි
වස්තුව [] සිට අරේ ()කට්ටලයේ ඇති මූලද්‍රව්‍යවල අරාව නිරූපණය කරයි
String toString ()කට්ටලයේ ඇති මූලද්‍රව්‍යයන්ගේ තන්තු නිරූපණයක් ලබා දෙයි

උදාහරණය: LinkedHashSet වෙත අංග එකතු කරන්න

අපට භාවිතයෙන් කට්ටලයට අංග එකතු කළ හැකිය add() ක්‍රමය භාවිතා කර එකතුවක් එකතු කරන්න addAll() ක්රමයකි.

import java.util.LinkedHashSet;

public class AddElementsLinkedHashSet {

  public static void main(String[] args) {
    LinkedHashSet<Integer> lh = new LinkedHashSet<Integer>();
    lh.add(20);
    lh.add(30);
    lh.add(10);
    lh.add(50);
    lh.add(40);
    
    System.out.println("Elements in the Set after add method: " + lh);
    
    LinkedHashSet<Integer> l = new LinkedHashSet<Integer>();
    l.add(60);
    l.add(80);
    
    lh.addAll(l);
    System.out.println("Elements in the Set after addAll method: " + lh);

  }

}
Elements in the Set after add method: [20, 30, 10, 50, 40]
Elements in the Set after addAll method: [20, 30, 10, 50, 40, 60, 80]

උදාහරණය: LinkedHashSet වෙතින් අංග මකන්න

කට්ටලයේ මූලද්‍රව්‍ය මකා දැමිය යුතු ආකාරය පෙන්වන උදාහරණය පහත දැක්වේ. නිශ්චිත අගයක් ඉවත් කිරීම සඳහා අපට භාවිතා කළ හැකිය remove() ක්රමය සහ සියලු අගයන් ඉවත් කරන්න, භාවිතා කරන්න removeAll() ක්‍රමය. අපට රඳවා ගත හැක්කේ එකතු සහ ජාවා LinkedHashSet වෙතින් අනෙක් ඒවා ඉවත් කරන්න retainAll() ක්රමයකි.

import java.util.LinkedHashSet;

public class RemoveElementsLinkedHashSet {

  public static void main(String[] args) {
    LinkedHashSet<Integer> lh = new LinkedHashSet<Integer>();
    lh.add(20);
    lh.add(30);
    lh.add(10);
    lh.add(50);
    lh.add(40);
    
    System.out.println("Elements in the Set after add method: " + lh);
    lh.remove(50);
    System.out.println("Elements in the Set after remove method: " + lh);
    
    lh.removeAll(lh);
    System.out.println("Elements in the Set after removeAll method: " + lh);
    
    lh.add(10);
    lh.add(20);
    
    LinkedHashSet<Integer> l = new LinkedHashSet<Integer>();
    l.add(60);
    l.add(80);
    
    lh.addAll(l);
    System.out.println("Elements in the Set after addAll method: " + lh);
    
    lh.retainAll(l);
    System.out.println("Elements in the Set after retainAll method: " + lh);
    

  }

}
Elements in the Set after add method: [20, 30, 10, 50, 40]
Elements in the Set after remove method: [20, 30, 10, 40]
Elements in the Set after removeAll method: []
Elements in the Set after addAll method: [10, 20, 60, 80]
Elements in the Set after retainAll method: [60, 80]

උදාහරණය: LinkedHashSet හි මූලද්‍රව්‍ය හරහා අනුකරණය කරන්න

අපට හැකි ක්‍රම 2 ක් ඇත පුනරාවර්තනය ජාවා හි LinkedHashSet හි අගයන් හරහා. අපට එක්කෝ භාවිතා කළ හැකිය iterator() ක්රමය හෝ භාවිතා කරන්න එක් එක් සඳහා ලූප්. පහත උදාහරණයෙන් ක්‍රම දෙකම විදහා දක්වයි.

import java.util.Iterator;
import java.util.LinkedHashSet;

public class IterateLinkedHashSet {

  public static void main(String[] args) {
    LinkedHashSet<String> l = new LinkedHashSet<String>();
    l.add("Aditya");
    l.add("Banu");
    l.add("Sreenath");
    l.add("Vivek");
    l.add("Rupesh");

    System.out.println("Size of the LinkedHashSet: " + l.size());
    
    //Iterate using the iterator
    System.out.println("Iterate using the iterator");
    Iterator<String> i = l.iterator();
    while(i.hasNext())
      System.out.println(i.next());
    
    System.out.println("Iterate using the for-each");
    //Iterate using the for-each loop
    for(String s: l)
      System.out.println(s);

  }

}
Size of the LinkedHashSet: 5
Iterate using the iterator
Aditya
Banu
Sreenath
Vivek
Rupesh
Iterate using the for-each
Aditya
Banu
Sreenath
Vivek
Rupesh

උදාහරණය: කට්ටලයේ අන්තර්ගතය හිස් කර හිස් දැයි පරීක්ෂා කරන්න

භාවිතා කිරීමෙන් අපට කට්ටලයේ අන්තර්ගතය ඉවත් කළ හැකිය clear() ක්‍රමය භාවිතා කර LinkedHashSet හිස්ව තිබේදැයි පරීක්ෂා කරන්න isEmpty() ක්රමයකි.

import java.util.LinkedHashSet;

public class ClearLinkedHashSet {

  public static void main(String[] args) {
    LinkedHashSet<String> l = new LinkedHashSet<String>();
    l.add("Aditya");
    l.add("Banu");
    l.add("Sreenath");
    l.add("Vivek");
    l.add("Rupesh");
    
    System.out.println("Elements in the Set: " + l);
    l.clear();
    
    System.out.println("Elements in the Set after using clear method: " + l);
    System.out.println("Is LinkedHashSet empty: " + l.isEmpty());

  }

}
Elements in the Set: [Aditya, Banu, Sreenath, Vivek, Rupesh]
Elements in the Set after using clear method: []
Is LinkedHashSet empty: true

උදාහරණය: නිශ්චිත මූලද්‍රව්‍යයක් හෝ මූලද්‍රව්‍ය එකතුවක් සඳහා පරීක්ෂා කරන්න

පහත උදාහරණයෙන් දැක්වෙන්නේ LinkedHashSet හි නිශ්චිත අගයක් තිබේද යන්න පරීක්ෂා කරන්නේ කෙසේද යන්නයි contains() භාවිතා කරන ක්‍රමය සහ එකතුව containsAll() ක්රමයකි.

import java.util.LinkedHashSet;

public class CheckElementLinkedHashSet {

  public static void main(String[] args) {
    LinkedHashSet<String> l = new LinkedHashSet<String>();
    l.add("Aditya");
    l.add("Banu");
    l.add("Sreenath");
    l.add("Vivek");
    l.add("Rupesh");
    
    System.out.println("Elements in the Set: " + l);
    System.out.println(l.contains("Sreenath"));
    System.out.println(l.contains("Divya"));
    
    LinkedHashSet<String> lh = new LinkedHashSet<String>();
    lh.add("Ramya");
    lh.add("Sriya");
    
    l.addAll(lh);
    System.out.println("Elements in the Set after addAll method: " + l);
    System.out.println(l.containsAll(lh));

  }

}
Elements in the Set: [Aditya, Banu, Sreenath, Vivek, Rupesh]
true
false
Elements in the Set after addAll method: [Aditya, Banu, Sreenath, Vivek, Rupesh, Ramya, Sriya]
true

උදාහරණය: LinkedHashSet අරාවකට පරිවර්තනය කරන්න

පහත උදාහරණයේ දී, අපි භාවිතා කරමින් LinkedHashSet අරාවකට පරිවර්තනය කරමු toArray() ක්‍රමය සහ අරාව දර්ශක 1 හි මූලද්‍රව්‍යය මුද්‍රණය කරන්න.

import java.util.Arrays;
import java.util.LinkedHashSet;

public class ConvertToArray {

  public static void main(String[] args) {
    LinkedHashSet<String> l = new LinkedHashSet<String>();
    l.add("Aditya");
    l.add("Banu");
    l.add("Sreenath");
    l.add("Vivek");
    l.add("Rupesh");
    
    System.out.println("Elements in the Set: " + l);
    String[] s = new String[l.size()];
    l.toArray(s);
    
    System.out.println("Convert to array:");
    System.out.println(Arrays.toString(s));
    
    System.out.println("Display the element at array index 1: " + s[1]);
  }

}
Elements in the Set: [Aditya, Banu, Sreenath, Vivek, Rupesh]
Convert to array:
[Aditya, Banu, Sreenath, Vivek, Rupesh]
Display the element at array index 1: Banu

උදාහරණය: LinkedHashSet වෙනත් කට්ටල එකතුවකට පරිවර්තනය කරන්න

එකතුවක් පරාමිතියක් ලෙස පිළිගන්නා ඉදිකිරීම්කරු භාවිතා කර අපට LinkedHashSet, TreeSet, HashSet වැනි වෙනත් කට්ටල එකතුවකට පරිවර්තනය කළ හැකිය. පහත උදාහරණයෙන් දැක්වෙන්නේ LinkedHashSet එකක් TreeSet සහ HashSet බවට පරිවර්තනය කරන්නේ කෙසේද යන්නයි.

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

public class ConvertToTreeSet {

  public static void main(String[] args) {
    Set<String> s = new LinkedHashSet<String>();
    s.add("Chennai");
    s.add("Bangalore");
    s.add("Delhi");
    s.add("Mumbai");
    
    System.out.println("LinkedHashSet: " + s);
    
    Set<String> t = new TreeSet<String>(s);
    System.out.println("TreeSet: " + t);
    
    Set<String> h = new HashSet<String>(s);
    System.out.println("HashSet: " + h);

  }

}
LinkedHashSet: [Chennai, Bangalore, Delhi, Mumbai]
TreeSet: [Bangalore, Chennai, Delhi, Mumbai]
HashSet: [Delhi, Chennai, Mumbai, Bangalore]

කාල සංකීර්ණත්වය

එකතු කිරීම (), ඉවත් කිරීම () සහ () වැනි බහුලව භාවිතා වන ක්‍රමවල කාල සංකීර්ණතාව නියත අගයක් වන ඕ (1) වේ.

විමර්ශන