How to apply set collection in Java

Set series collection features:

• Unordered: access The order is inconsistent

• No duplication: Duplication can be removed

• No index: There is no indexed method, so ordinary for loop traversal cannot be used, and Elements cannot be obtained by index

Set collection implementation class features:

HashSet: unordered, non-repeating, no index

LinkedHashSet: ordered, non-repeating, no index

TreeSet: sorted, non-repeating, 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 code and running results, we It can be clearly seen that the HashSet collection is disordered and non-repeating;

Based on the above picture, it can be seen that the HashSet collection cannot pass the get() method The index obtains data, 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:

Use the above code and output result to do By comparison, you can see the difference between disordered and ordered. The former will disrupt the order of the incoming data, while the latter still stores the data in the order of the input data, so the output is in an ordered state.

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 results:

##Through the above code and output results we You 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 override the compareTo method inside Specify the rules; the other is to use the collection's own comparator object to define the rules.

Method 1: Customize the class to implement the Comparable interface and rewrite 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 is shown)

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

Output result (comparison based on age):

In the overridden method, the code after return determines what criteria the object will be compared according to, the comparison rules 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 for two elements
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 the two are considered to be duplicates.
Method 2: The collection comes with its own 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 based on the original, and its comparison criteria are the same as the previous ones The definition method is similar. Compared with the previous method, this method is more convenient and faster. We can use the Lambda expressions we learned before to simplify this code block.

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

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