集合——Set

m0_59138290

于 2022-10-27 22:42:03 发布

阅读量257

点赞数

分类专栏： javaSE 文章标签： java 数据结构开发语言

本文链接：https://blog.csdn.net/m0_59138290/article/details/127562349

版权

javaSE 专栏收录该内容

35 篇文章 0 订阅

订阅专栏

文章目录

Set<E>

Set

不支持角标操作，不包含重复元素，允许null元素最多1个

Set用于存储不重复的元素集合，它主要提供以下几个方法：

将元素添加进Set<E>：boolean add(E e)
将元素从Set<E>删除：boolean remove(Object e)
判断是否包含元素：boolean contains(Object e)

Set实际上相当于只存储key、不存储value的Map。我们经常用Set用于去除重复元素。

因为放入Set的元素和Map的key类似，都要正确实现equals()和hashCode()方法，否则该元素无法正确地放入Set。

HashSet

此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。

最常用的Set实现类是HashSet，实际上，HashSet仅仅是对HashMap的一个简单封装

底层数据结构数组(哈希表)+链表+红黑树实现的
平均每个链表长度>8的时候每个链表转换为红黑树
平均每个红黑树长度<6的时候，每个红黑树转换为链表
本质上哈希表要么是一个链表的数组LinkedList[] 要么是红黑树的数组TreeSet[] 桶-容器
它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变
允许null值，禁止重复元素线程不安全不同步
默认初始容量是 16 数组的长度
默认的加载因子 0.75 桶的个数 / 桶中元素的个数
无序集合

class Person implements Comparable<Person>{
    private String name;
    private int age;

    //构造函数
    public Person() {
    }

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

    public Person(int age) {
        this.age = age;
    }

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

    @Override
    public boolean equals(Object o) {
        System.out.println("person equals....");
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        System.out.println("person hashCode....");
        return Objects.hash(name, age);
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //修改器和访问器
    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;
    }

    @Override
    public int compareTo(Person o) {
        return name.compareTo(o.getName());
    }
}

HashSet<Person> set1 = new HashSet<>();
for (int i = 1; i <= 10; i++) {
//每一次添加元素时，都会调用该元素的hashCode函数来返回哈希值 用于计算元素要去的桶角标
//但是此处 的每一个Person内容都不一样 所以哈希值也都不一样
set1.add(new Person("person" + i, 10 + i));
}
System.out.println(set1);
//每一次添加元素时，都会调用该元素的hashCode函数来返回哈希值 用于计算元素要去的桶角标
Person p = new Person("person1", 11);
set1.add(p);
//如果发现哈希值对应的桶中已经有元素了 接着调用元素的equals方法来判断和桶中元素的内容是否一样，内容一样，则不进入
//否则(哈希值一样 但内容不一样) 则进入到表中
System.out.println(set1);

TreeSet

基于 TreeMap的 NavigableSet实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。

底层数据结构-红黑树-二分搜索树
使用元素的自然顺序对元素进行排序二分搜索树中序遍历是有序的
不同步的线程不安全函数没有同步关键synchronized - 适用于单线程情况
不允许存储null值不允许重复

方法摘要
`boolean`	`add(E e)` 将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
`E`	`ceiling(E e)` 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 `null`。
`void`	`clear()` 移除此 set 中的所有元素。
`Object`	`clone()` 返回 `TreeSet` 实例的浅表副本。
`Comparator<? super E>`	`comparator()` 返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 `null`。
`E`	`first()` 返回此 set 中当前第一个（最低）元素。
`E`	`floor(E e)` 返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 `null`。
`SortedSet<E>`	`headSet(E toElement)` 返回此 set 的部分视图，其元素严格小于 `toElement`。
`E`	`higher(E e)` 返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 `null`。
`boolean`	`isEmpty()` 如果此 set 不包含任何元素，则返回 `true`。
`Iterator<E>`	`iterator()` 返回在此 set 中的元素上按升序进行迭代的迭代器。
`E`	`last()` 返回此 set 中当前最后一个（最高）元素。
`E`	`lower(E e)` 返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 `null`。
`E`	`pollFirst()` 获取并移除第一个（最低）元素；如果此 set 为空，则返回 `null`。
`E`	`pollLast()` 获取并移除最后一个（最高）元素；如果此 set 为空，则返回 `null`。
`boolean`	`remove(Object o)` 将指定的元素从 set 中移除（如果该元素存在于此 set 中）。
`int`	`size()` 返回 set 中的元素数（set 的容量）。
`SortedSet<E>`	`subSet (E fromElement, E toElement)` 返回此 set 的部分视图，其元素从 `fromElement`（包括）到 `toElement`（不包括）。
`SortedSet<E>`	`tailSet (E fromElement)` 返回此 set 的部分视图，其元素大于等于 `fromElement`。

Set接口并不保证有序，而SortedSet接口则保证元素是有序的：

HashSet是无序的，因为它实现了Set接口，并没有实现SortedSet接口；
TreeSet是有序的，因为它实现了SortedSet接口。

使用TreeSet和使用TreeMap的要求一样，添加的元素必须正确实现Comparable接口，如果没有实现Comparable接口，那么创建TreeSet时必须传入一个Comparator对象。

有序：元素的进入顺序与遍历顺序是相关的不代表排序！

TreeSet<Integer> set = new TreeSet<>();
set.add(7);
set.add(4);
set.add(8);
set.add(3);
set.add(5);
set.add(6);

去除重复元素的使用场景

Random random = new Random();
ArrayList<Integer> list = new ArrayList<>();
for (int i = 1; i <= 50; i++) {
list.add(random.nextInt(10));
}
System.out.println(list);
TreeSet<Integer> set3 = new TreeSet<>();
for (int i = 0; i < list.size(); i++) {
set3.add(list.get(i));
}
System.out.println(set3);

比较器的优先级 > 元素自身的比较性


TreeSet<Person> set4 = new TreeSet<>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
//所谓的大小不是绝对的
//                return o1.getAge() - o2.getAge(); //从小到大
return o2.getAge() - o1.getAge();   //从大到小
}
});
set4.add(new Person("cat", 12));
set4.add(new Person("dog",10));
set4.add(new Person("banana",13));
set4.add(new Person("animal", 14));
System.out.println(set4);

for (Person p : set4) {
System.out.println(p);
}
Iterator<Person> it = set4.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}

LinkedHashSet

LinkedHashSet是 HashSet的子类 LinkedHashSet根据元素的hashCode值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。 LinkedHashSet插入性能略低于 HashSet，但在迭代访问Set里的全部元素时有很好的性能。 LinkedHashSet不允许集合元素重复。

原理和用法和HashSet是一致的是HashSet的子类
LinkedHashSet实现是LinkedHashMap的一种
此实现与 HashSet 的不同之外在于，LinkedHashSet维护着一个运行于所有条目的双重链接列表。
此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代
如果要求元素进入顺序和迭代顺序一致的话 LinkedHashSet
实际上就是HashSet + 双向链表实现的
HashSet还是按照上述的内容进行元素管理
双向链表专门用于按照进入顺序存储管理元素

import java.util.LinkedHashSet;
 
public class Test {
	public static void main(String[] args) {
		LinkedHashSet<String> hs=new LinkedHashSet<String>();
		
		hs.add("hello");
		hs.add("world");
		hs.add("java");
		
		for(String h:hs) {
			System.out.println(h);
		}
	}
}
 
//输出： 
//hello
//world
//java