Java Set 保存对象 java. set

转载

陌陌香阁 2023-06-16 21:58:01

文章标签 Java Set 保存对象 System java ide 文章分类 Java 后端开发

Set集合

java.util.Set 接口和 java.util.List 接口一样，同样继承自 Collection 接口，它与 Collection 接口中的方法基本一致，并没有对Collection 接口进行功能上的扩充，只是比 Collection 接口更加严格了。

Set集合与List集合的区别：

1、List集合是一个存储有序的集合，Set集合是一个存储无序的集合

2、List集合中的元素可以重复，Set集合中的元素会以某个规则保证元素不重复

Set的子类

Set 集合有多个子类，包括 java.util.HashSet 、 java.util.LinkedHashSet、java.util.TreeSet等。

HashSet集合

特点：

底层数据结构是哈希表，线程不安全，效率高，允许存储null值，元素无序
元素的唯一性是靠重写hashCode()方法和equals()方法

常见方法：

public boolean add(E e) ；添加元素

public void clear（）；移除set中所有的元素

public boolean contains(Object o);是否包含指定元素，如果包含则返回true

public boolean isEmpty()；如果set不包含元素，则返回true

Iterator<E> iterator（）；对set集合元素进行迭代的迭代器

public boolean remove(Object o);移除指定元素

public int size()；返回集合元素长度

import java.util.*;

public class SetDemo01 {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        //添加元素，元素不重复
        set.add("aa");
        set.add("bb");
        set.add("aa");
        set.add("cc");
        set.add("dd");
        set.add("ee");
        System.out.println(set);

        //是否包含指定元素，如果包含则返回true
        boolean cc = set.contains("cc");
        System.out.println(cc);

        //如果set不包含元素，则返回true
        System.out.println(set.isEmpty());

        //对set集合元素进行迭代的迭代器
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }

        //移除指定元素
        boolean dd = set.remove("dd");
        System.out.println(dd);

        //返回集合元素长度
        System.out.println(set.size());

        //移除set中所有的元素
        set.clear();
        System.out.println(set);

    }
}

LinkedHashSet集合

特点：

底层数据结构是链表和哈希表，线程不安全，效率高，元素有序且唯一

LinkedHashSet继承了类java.util.HashSet的方法

常见方法：

public void addFirst(E e) :将指定元素插入此列表的开头。
public void addLast(E e) :将指定元素添加到此列表的结尾。
public E getFirst() :返回此列表的第一个元素。
public E getLast() :返回此列表的最后一个元素。
public E removeFirst() :移除并返回此列表的第一个元素。
public E removeLast() :移除并返回此列表的最后一个元素。
public E pop() :从此列表所表示的堆栈处弹出一个元素。
public void push(E e) :将元素推入此列表所表示的堆栈。
public boolean isEmpty() ：如果列表不包含元素，则返回true。

import java.util.LinkedList;

public class LinkedHshSetDemo01 {
    public static void main(String[] args) {

        LinkedList<String> linkedList = new LinkedList<>();
        //元素可以重复
        linkedList.add("aa");
        linkedList.add("aa");
        linkedList.add("bb");
        linkedList.add("cc");
        linkedList.add("dd");
        linkedList.add("ee");
        System.out.println(linkedList);

//       将指定元素插入此列表的开头。
        linkedList.addFirst("first");
        System.out.println(linkedList);
//      将指定元素添加到此列表的结尾。
        linkedList.addLast("last");
        System.out.println(linkedList);

        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());

        linkedList.removeFirst();
        linkedList.removeLast();
        linkedList.remove(1);

//      从此列表所表示的堆栈处弹出一个元素。
        System.out.println(linkedList.pop());

//      将元素推入此列表所表示的堆栈。
        linkedList.push("push");
        System.out.println(linkedList);

        System.out.println(linkedList.isEmpty());
    }
}

TreeSet集合

特点：底层数据结构是二叉树，线程不安全，效率高，元素有序且唯一。不允许null元素。

TreeSet可以对元素进行排序，根据使用的构造方法，不同其使用的排序方式也不同。（自然排序、比较器排序）

构造方法：

`TreeSet()` 构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
`TreeSet(Collection<? extends E> c)` 构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
`TreeSet(Comparator<? super E> comparator)` 构造一个新的空 TreeSet，它根据指定比较器进行排序。
`TreeSet(SortedSet<E> s)` 构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。

自然排序

import java.util.Iterator;
import java.util.Objects;
import java.util.TreeSet;

class Student implements Comparable<Student> {


    private String name;

    private Integer age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Student() {
    }
    
    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name) &&
                Objects.equals(age, student.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }


  /*  @Override
    public int compareTo(Student o) {
        return 1;
    }*/

    @Override
    public int compareTo(Student s) {
        //return -1; //-1表示放在红黑树的左边,即逆序输出
        //return 1;  //1表示放在红黑树的右边，即顺序输出
        //return o;  //表示元素相同，仅存放第一个元素
      /*  int i = this.age.compareTo(s.age);//按照年龄的顺序
        System.out.println(i);
        return i;*/

      return this.age.compareTo(s.age);//按照年龄的顺序
      //return this.age-s.age;
    }
}


public class TreeSetDemo01 {
    public static void main(String[] args) {
        Student student = new Student("张三",20);
        Student student1 = new Student("李四",23);
        Student student2 = new Student("王五",19);

        TreeSet<Student> treeSet = new TreeSet<>();
        treeSet.add(student);
        treeSet.add(student1);
        treeSet.add(student2);
        Iterator<Student> it =treeSet.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s);
        }
    }
}

比较器排序（自定义比较器）

import java.util.Comparator;
import java.util.Iterator;
import java.util.Objects;
import java.util.TreeSet;

class Person{

    private String name;

    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(age, person.age);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }



    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

}

public class Gzqpaixu {
    public static void main(String[] args) {

        //自定义比较器，重写compare方法
        TreeSet<Person> treeSet = new TreeSet<>(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Person p =(Person) o1;
                Person p2 =(Person) o2;
                if(p.getAge()>p2.getAge())return 1;
                if(p.getAge()<p2.getAge())return -1;
                return 0;
            }
        });

        Person person = new Person("张三",20);
        Person person1 = new Person("李四",23);
        Person person2 = new Person("王五",19);
        treeSet.add(person);
        treeSet.add(person1);
        treeSet.add(person2);

        Iterator<Person> it =treeSet.iterator();

        while(it.hasNext()){
           Person s =it.next();
            System.out.println(s);
        }
    }
}

关于TreeSet集合的方法使用（参考java api文档）

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。