Говорейки за класа LinkedHashSet в Java, трябва да споменем, че той имплементира интерфейса Set . LinkedHashSet създава колекция, която съхранява елементи в хеш-table, но поддържа реда на вмъкване на елементите за разлика от неговия аналог HashSet .
Какво е зададено в Java
Нека накратко да припомним, че интерфейсът Set дефинира набор (set). Той разширява колекцията и дефинира поведението на колекциите, които не позволяват дублиращи се елементи. По този начин методът add() връща false , ако се направи опит за добавяне на дублиран елемент към набора. Интерфейсът не дефинира ниHowви собствени допълнителни методи. Интерфейсът Set се грижи за уникалността на съхранените обекти, уникалността се определя от имплементацията на метода equals() . Следователно, ако обекти от създадения клас ще бъдат добавени към Set , е желателно да се замени методът equals() .
Клас LinkedHashSet
Преди да говорим за класа LinkedHashSet , трябва да споменем неговия близък роднина, класа HashSet . HashSet имплементира интерфейса Set . Той създава колекция, която съхранява елементите в хеш table. Елементите на хеш-tableта се съхраняват като двойки ключ-стойност. Ключът указва клетката (or сегмента) за съхраняване на стойността. Съдържанието на ключа се използва за определяне на уникална стойност, наречена хеш code. Можем да мислим за хеш code като за идентификатор на обект, въпреки че не е задължително да е уникален. Този хеш code също така служи като индекс, към който се съхраняват данните, свързани с ключа. Класът LinkedHashSet Java разширява HashSet , без да добавя нови методи.LinkedHashSet ви позволява бързо да проверите за съществуването на запис, точно като HashSet , но съдържа подреден списък вътре. Това означава, че съхранява реда на вмъкване на елементите. С други думи, LinkedHashSet поддържа свързан списък от множество елементи в реда, в който са бor вмъкнати. Това позволява подредена итерация на вмъкване в набор. Но това кара класа LinkedHashSet да извършва операции по-дълго от класа HashSet .
Важни характеристики на LinkedHashSet
Можем да съхраняваме уникални елементи само в LinkedHashSet
LinketHashSet ни позволява да извличаме елементи в същия ред, в който вмъкваме
LinkedHashSet не е синхронизиран
LinkedHashSet позволява съхраняване на нулеви елементи
LinkedHashSet използва техника за хеширане, за да съхранява елементи в определен индекс въз основа на хеш code
LinkedHashSet методи
В допълнение към методите, наследени от своите родителски класове, HashSet дефинира следните методи:
boolean add(Object o) добавя посочения елемент към този набор, ако той вече не присъства.
void clear() премахва всички елементи от този набор.
Object clone() връща плитко копие на този екземпляр на LinkedHashSet : самите елементи не са клонирани.
boolean contains(Object o) връща true, ако този набор съдържа указания елемент.
boolean isEmpty() връща true , ако този набор не съдържа елементи.
Итератор iterator() връща итератор над елементите на този набор.
boolean remove(Object o) премахва посочения елемент от този набор, ако присъства.
int size() връща броя на елементите в този набор (неговия брой елементи).
Лесни примери за LinkedHashSet В примера по-долу показваме инициализация на обекта
LinkedHashSet и използване на метода
add() за попълване на набора.
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetEx1 {
public static void main(String[] args) {
//LinkedHashSet() Init
Set<String> set = new LinkedHashSet<>();
//adding elements to LinkedHashSet
set.add("Re"); //first added element
set.add("Do");
set.add("Fa");
set.add("Sol");
set.add("La");
set.add("Ti");
set.add("Mi");//last added element
System.out.println(set);
}
}
Резултатът е:
[Re, Do, Fa, Sol, La, Ti, Mi]
Както можете да видите, елементите в нашия набор се появиха в същия ред, в който ги поставихме.
Пример 2. Добавяне на дубликат в LinkedHashSet
Нека отново поставим в нашия
LinkedHashSet 7 елемента с имена на музикални партитури и поставим един нов елемент, който е същият като един от елементите, поставени преди.
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetEx2 {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
set.add("Re");
set.add("Do");
set.add("Fa");
set.add("Sol");
set.add("La");
set.add("Ti");
set.add("Mi");
set.add("Sol");
System.out.println(set);
}
}
Резултатът от програмата е тук:
[Re, Do, Fa, Sol, La, Ti, Mi]
Резултатът от пример две е абсолютно същият като в първия пример. Не можем да имаме два подобни елемента в колекцията
LinkedHashSet . Когато се опитаме да поставим втория, той просто се игнорира.
Пример 3. Премахване на елементи от LinkedHashSet
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSet3 {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
set.add("Re");
set.add("Do");
set.add("Fa");
set.add("Sol");
set.add("La");
set.add("Ti");
set.add("Mi");
System.out.println(set);
set.remove("Fa");// removing an element from our set
set.remove("Score");//trying to remove element that isn't in set
System.out.println(set.remove("Score"));
System.out.println("Print our set without elements removed: ");
System.out.println(set);
set.clear();
System.out.println("Print out our set after clear command: ");
System.out.println(set);
}
}
Резултатът от програмата е тук:
[Re, Do, Fa, Sol, La, Ti, Mi] false Отпечатайте нашия набор без премахнати елементи: [Re, Do, Sol, La, Ti, Mi] Отпечатайте нашия набор след команда за изчистване: []
Както можете да видите, методът
remove(), приложен към несъществуващ елемент, не води до програмна грешка. Той просто връща
false , ако елементът не е премахнат, и
true, ако елементът е бил в
LinkedHashSet и след това е премахнат.
LinkedHashSet срещу HashSet
Тези два класа са близки роднини. Въпреки това вътре в
HashSet той използва
HashMap за съхраняване на обекти, докато
LinkedHashSet използва
LinkedHashMap . Ако не е необходимо да поддържате реда на вмъкване, но трябва да съхранявате уникални обекти, по-подходящо е да използвате
HashSet . Ако трябва да поддържате реда на вмъкване на елементи, тогава
LinkedHashSet е вашият избор. Производителността на
LinkedHashSet е малко по-бавна от
HashSet , тъй като
LinkedHashSet използва вътрешен
LinkedList , за да поддържа реда на вмъкване на елементи. Да дадем пример:
import java.util.*;
public class LinkedHashSetExample1 {
public static void main(String[] args) {
// while regular hash set orders its elements according to its hashcode stamps
Set<Integer> regularHashSet = new HashSet<>();
regularHashSet.add(7);
regularHashSet.add(3);
regularHashSet.add(5);
regularHashSet.add(65536);
regularHashSet.add(9);
// few duplicates
regularHashSet.add(5);
regularHashSet.add(7);
// next will print:
// > regularHashSet = [65536, 3, 5, 7, 9]
System.out.println("regularHashSet = " + regularHashSet);
// linked hash set keeps order of adding unchanged
Set<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(7);
linkedHashSet.add(3);
linkedHashSet.add(5);
linkedHashSet.add(65536);
linkedHashSet.add(9);
// few duplicates
linkedHashSet.add(5);
linkedHashSet.add(7);
// next will print:
// > linkedHashSet = [7, 3, 5, 65536, 9]
System.out.println("linkedHashSet = " + linkedHashSet);
}
}
Използване на Java LinkedHashSet в реални applications
Тъй като
LinkedHashSet ви позволява бързо да проверите за съществуването на запис и също така съхранява реда, тази колекция изглежда доста удобна за елиминиране на дубликати от списък. Или, например, решаване на проблеми като последния наскоро видян предмет в чантата ми. Или спомняте си такава игра, Pokemon Go?
LinkedHashSet може да съхранява списък с покемони, които сте срещали, и реда, в който са се срещали по пътя ви. В този случай „повтарящият се“ покемон вече няма да се добавя към списъка. Или, например, списък с босове по ниво, които вече сте срещали във всяка игра с нива. Или историята на откриването на космически тела.
LinkedHashSetви позволява бързо да проверите дали космическо тяло вече е в списъка or не, и ако не е там, тогава го добавете към списъка. Нека вземем пример за елиминиране на дубликати.
import java.util.*;
class LinkedHashSetExample2 {
public static void main(String[] args) {
List<String> listWithDuplicates = List.of("some","elements","with", "few", "duplicates", "were", "here", "duplicates", "duplicates");
Set<String> linkedHashSet = new LinkedHashSet<>(listWithDuplicates);
List<String> listWithoutDuplicates = new ArrayList<>(linkedHashSet);
// next will print:
// > listWithDuplicates = [some, elements, with, few, duplicates, here, duplicates, duplicates]
System.out.println("listWithDuplicates = " + listWithDuplicates);
// next will print:
// > listWithoutDuplicates = [some, elements, with, few, duplicates, here]
System.out.println("listWithoutDuplicates = " + listWithoutDuplicates);
// -------------------------------------------------------------------------
// while using regular Hash Set will generally produces some unexpected order
Set<String> regularHashSet = new HashSet<>(listWithDuplicates);
// next will print:
// > linkedHashSet = [some, elements, with, few, duplicates, were, here]
System.out.println("linkedHashSet = " + linkedHashSet);
// next will print:
// > regularHashSet = [here, some, with, duplicates, were, elements, few]
System.out.println("regularHashSet = " + regularHashSet);
}
}
GO TO FULL VERSION