Nói về lớp LinkedHashSet trong Java, chúng ta cần đề cập rằng nó triển khai giao diện Set . LinkedHashSet tạo một bộ sưu tập lưu trữ các phần tử trong bảng băm nhưng duy trì thứ tự chèn của các phần tử không giống như đối tác HashSet của nó .
Đặt trong Java là gì
Chúng ta hãy nhớ lại một cách ngắn gọn rằng giao diện Set định nghĩa một tập hợp (set). Nó mở rộng Bộ sưu tập và xác định hành vi của các bộ sưu tập không cho phép các phần tử trùng lặp. Do đó, phương thức add() trả về false nếu cố gắng thêm một phần tử trùng lặp vào tập hợp. Giao diện không xác định bất kỳ phương thức bổ sung nào của riêng nó. Giao diện Set quan tâm đến tính duy nhất của các đối tượng được lưu trữ, tính duy nhất được xác định bằng cách triển khai phương thức equals() . Do đó, nếu các đối tượng của lớp đã tạo sẽ được thêm vào Set , thì nên ghi đè phương thức equals() .
lớp LinkedHashSet
Trước khi nói về lớp LinkedHashSet , chúng ta cần đề cập đến họ hàng gần của nó, lớp HashSet . HashSet triển khai giao diện Set . Nó tạo ra một bộ sưu tập lưu trữ các phần tử trong bảng băm. Các phần tử của bảng băm được lưu trữ dưới dạng các cặp khóa-giá trị. Khóa chỉ định ô (hoặc phân đoạn) để lưu trữ giá trị. Nội dung của khóa được sử dụng để xác định một giá trị duy nhất được gọi là mã băm. Chúng ta có thể coi mã băm như một mã định danh đối tượng, mặc dù nó không nhất thiết phải là duy nhất. Mã băm này cũng đóng vai trò là một chỉ mục mà dữ liệu được liên kết với khóa được lưu trữ. Lớp Java LinkedHashSet mở rộng HashSet mà không cần thêm bất kỳ phương thức mới nào.LinkedHashSet cho phép bạn nhanh chóng kiểm tra sự tồn tại của một mục, giống như HashSet , nhưng chứa một danh sách có thứ tự bên trong. Điều này có nghĩa là nó lưu trữ thứ tự chèn của các phần tử. Nói cách khác, LinkedHashSet duy trì một danh sách được liên kết của các phần tử tập hợp theo thứ tự chúng được chèn vào. Điều này cho phép lặp lại theo thứ tự của việc chèn vào một tập hợp. Nhưng điều này khiến lớp LinkedHashSet thực hiện các thao tác lâu hơn lớp HashSet .
Các tính năng quan trọng của LinkedHashSet
Chúng tôi chỉ có thể lưu trữ các phần tử duy nhất trong LinkedHashSet
LinketHashSet cho phép chúng tôi trích xuất các phần tử theo cùng thứ tự mà chúng tôi chèn
LinkedHashSet không được đồng bộ hóa
LinkedHashSet cho phép lưu trữ các phần tử null
LinkedHashSet sử dụng kỹ thuật băm để lưu trữ các phần tử tại một chỉ mục được chỉ định dựa trên mã băm
Phương thức LinkedHashSet
Ngoài các phương thức kế thừa từ các lớp cha của nó, HashSet định nghĩa các phương thức sau:
boolean add(Object o) thêm phần tử đã chỉ định vào tập hợp này nếu nó chưa có.
void clear() xóa tất cả các phần tử khỏi tập hợp này.
Bản sao đối tượng() trả về một bản sao nông của phiên bản LinkedHashSet này : bản thân các phần tử không được sao chép.
boolean contains(Object o) trả về true nếu tập hợp này chứa phần tử đã chỉ định.
boolean isEmpty() trả về true nếu tập hợp này không chứa phần tử nào.
Iterator iterator() trả về một iterator trên các phần tử của tập hợp này.
boolean remove(Object o) xóa phần tử đã chỉ định khỏi tập hợp này, nếu có.
int size() trả về số phần tử trong tập hợp này (số phần tử của nó).
Các ví dụ về LinkedHashSet dễ dàng Trong ví dụ bên dưới, chúng tôi trình bày việc khởi tạo đối tượng
LinkedHashSet và sử dụng phương thức
add() để điền vào tập hợp.
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);
}
}
Đầu ra là:
[Rê, Đô, Fa, Sol, La, Ti, Mi]
Như bạn có thể thấy, các phần tử trong tập hợp của chúng tôi xuất hiện theo cùng thứ tự mà chúng tôi đã đặt chúng.
Ví dụ 2. Thêm một bản sao vào LinkedHashSet
Hãy đặt lại các phần tử
LinkedHashSet 7 của chúng tôi với tên của các bản nhạc và đặt một phần tử mới giống với một trong các phần tử đã đặt trước đó.
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);
}
}
Đầu ra của chương trình là đây:
[Rê, Đô, Fa, Sol, La, Ti, Mi]
Đầu ra của Ví dụ hai hoàn toàn giống như trong ví dụ đầu tiên. Chúng ta không thể có hai phần tử giống nhau trong bộ sưu tập
LinkedHashSet . Khi chúng tôi cố gắng đặt cái thứ hai, nó sẽ bị bỏ qua.
Ví dụ 3. Xóa phần tử khỏi 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);
}
}
Đầu ra của chương trình là đây:
[Re, Do, Fa, Sol, La, Ti, Mi]
false
In tập hợp không bỏ phần tử:
[Re, Do, Sol, La, Ti, Mi]
In ra tập hợp của chúng ta sau lệnh xóa:
[]
Như bạn có thể thấy, phương thức
remove() được áp dụng cho phần tử không tồn tại không dẫn đến lỗi chương trình. Nó chỉ trả về
false nếu phần tử không bị xóa và
true nếu phần tử nằm trong
LinkedHashSet và sau đó bị xóa.
LinkedHashSet so với HashSet
Hai hạng người này là họ hàng gần của nhau. Tuy nhiên, bên trong
HashSet , nó sử dụng
HashMap để lưu trữ các đối tượng trong khi
LinkedHashSet sử dụng
LinkedHashMap . Nếu bạn không cần duy trì thứ tự chèn nhưng cần lưu trữ các đối tượng duy nhất, thì việc sử dụng
HashSet sẽ phù hợp hơn . Nếu bạn cần duy trì thứ tự chèn của các phần tử thì
LinkedHashSet là lựa chọn của bạn. Hiệu suất của
LinkedHashSet chậm hơn một chút so với
HashSet vì
LinkedHashSet sử dụng
LinkedList bên trong để duy trì thứ tự chèn của các phần tử. Hãy có một ví dụ:
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);
}
}
Sử dụng Java LinkedHashSet trong các ứng dụng trong thế giới thực
Vì
LinkedHashSet cho phép bạn nhanh chóng kiểm tra sự tồn tại của một mục nhập và cũng lưu trữ thứ tự, nên bộ sưu tập này có vẻ khá thuận tiện để loại bỏ các mục trùng lặp khỏi danh sách. Hoặc, ví dụ, giải quyết các vấn đề như vật phẩm được nhìn thấy gần đây nhất trong túi của tôi. Hoặc, nhớ một trò chơi như vậy, Pokemon Go?
LinkedHashSet có thể lưu trữ danh sách Pokémon bạn đã gặp và thứ tự chúng bắt gặp trên đường đi của bạn. Trong trường hợp này, Pokémon "lặp đi lặp lại" sẽ không còn được thêm vào danh sách. Hoặc, ví dụ, danh sách các ông chủ theo cấp độ mà bạn đã gặp trong bất kỳ trò chơi nào có cấp độ. Hay lịch sử khám phá các thiên thể vũ trụ.
LinkedHashSetcho phép bạn nhanh chóng kiểm tra xem một phần thân không gian đã có trong danh sách hay chưa và nếu không có, hãy thêm nó vào danh sách. Hãy lấy một ví dụ về việc loại bỏ trùng lặp.
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);
}
}
Đầu ra của chương trình là đây:
listWithDuplicates = [một số, phần tử, với, ít, trùng lặp, đã, ở đây, trùng lặp, trùng lặp]
listWithoutDuplicates = [một số, phần tử, với, ít, trùng lặp, đã ở đây]
LinkedHashSet = [một số, phần tử, với, ít, trùng lặp , were, here]
regularHashSet = [đây, một số, với, trùng lặp, là, phần tử, vài]
Volodymyr is one of those who learned Java development thanks to the CodeGym course, and after studying, got a job in our company. ...
[Đọc toàn bộ tiểu sử]
GO TO FULL VERSION