How to understand the set collection in Java

This article brings you relevant knowledge about java, which mainly introduces related issues about set collections. The characteristics of set collections are disordered, non-repeating and without indexes. The following is Let's take a look, hope it helps everyone.

Recommended study: "java video tutorial"

Set series collection features:

• Unordered: The access sequence is inconsistent
• No duplication: Duplication can be removed
• No index: There is no indexed method, so ordinary methods cannot be used For loop traversal, elements cannot be obtained by index

Set collection implementation class features:

HashSet:Unordered, no duplication, no index

LinkedHashSet:Ordered, no duplication, no index

TreeSet:Sort, no duplication , No index

The function of the Set collection is basically the same as the API of Collection.

HashSet collection

HashSet collection:

Set<String> set = new HashSet<>();
        set.add("石原里美");
        set.add("石原里美");
        set.add("工藤静香");
        set.add("朱茵");
        System.out.println(set);
        set.remove("朱茵");
        System.out.println(set);

Output result:

Through the above From the code and running results, we can clearly see that the HashSet collection is disordered and non-repeating;

Combined with the above pictures, we can see that the HashSet collection cannot Data is obtained through the index of the get() method, and when deleting data in the collection, the data can only be deleted in a targeted manner.

LinkedHashSet collection:

LinkedHashSet collection:

Set<String> set = new LinkedHashSet<>();
        set.add("石原里美");
        set.add("石原里美");
        set.add("工藤静香");
        set.add("朱茵");
        System.out.println(set);
        set.remove("朱茵");
        System.out.println(set);

Output result:

Passed Comparing the above code with the output results, you can see the difference between disordered and ordered. The former will disrupt the order of the incoming data, while the latter will still store the data in the order of the input data, so the output Time is in order.

TreeSet collection:

TreeSet collection:

Set<Integer> set = new TreeSet<>();
        set.add(13);
        set.add(23);
        set.add(23);
        set.add(11);
        System.out.println(set);
        set.remove(23);
        System.out.println(set);

Output result:

Passed From the above code and output results, we can understand literally why TreeSet is characterized by sorting, that is, the stored data is sorted according to Java's default sorting method.

However, if you store custom objects such as People at this time, TreeSet cannot be sorted directly, and an error will occur!

//People类：
public class People{
    private String name;
    private int age;
    private String classroom;

    public People(){

    }
    public People(String name, int age, String classroom) {
        this.name = name;
        this.age = age;
        this.classroom = classroom;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getClassroom() {
        return classroom;
    }

    public void setClassroom(String classroom) {
        this.classroom = classroom;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", classroom='" + classroom + '\'' +
                '}';
    }
}
//main方法：
public static void main(String[] args) {
        Set<People> p = new TreeSet<>();
        p.add(new People("张三",19,"智能"));
        p.add(new People("李四",18,"数据库"));
        p.add(new People("王五",20,"渗透"));
        System.out.println(p);
    }

If we want to solve this problem, we need to customize the storage type for the TreeSet collection. There are two ways to solve this problem: One is to customize the class to implement the Comparable interface and Rewrite the compareTo method inside to specify the rules; The other is a collection with its own comparator object for rule definition.

Method 1: Custom class implements the Comparable interface and rewrites the compareTo method to specify the comparison rules (the redundant and irrelevant code will not be repeated here, only the important part of the code will be shown) )

//改变的第一个地方:实现Comparable类
public class People implements Comparable<People> {
//改变的第二个地方：重写Comparable类中的compareTo方法    
    @Override
    public int compareTo(People o) {
        return this.age-o.age;
    }
}

Output result (compared according to age):

In the overridden method, the code after return determines what the object will be based on The comparison rules are as follows:

• If the first element is considered to be greater than the second element, a positive integer can be returned
• If the first element is considered to be less than the second element Just return a negative integer
• If you think the first element is equal to the second element, just return 0. At this time, the Treeset collection will only retain one element, and both are considered duplicates

Method 2:The collection comes with a comparator object for rule definition

Set<People> p = new TreeSet<>(new Comparator<People>() {
            @Override
            public int compare(People o1, People o2) {
                return o1.getAge()-o2.getAge();
            }
        });

Change the creation of the collection on the original basis, and its comparison criteria are similar to the previous definition method, relatively The previous method is more convenient and faster. Here, we can also review some of the previously learned knowledge "Lambda expressions" and simplify the code block.

Set<People> p = new TreeSet<>((o1, o2) -> o1.getAge()-o2.getAge());

If you have not studied Lambda expressions, or your knowledge of Lambda expressions is not clear, you can look at how to understand lambda expressions in Java - simplifying the explanation of this article may help Something helpful to you.

Recommended learning: "java video tutorial"

The above is the detailed content of How to understand the set collection in Java. For more information, please follow other related articles on the PHP Chinese website!