set集合

java8 JDK

一、Set集合

Set子接口

• 特点：无序、无下标、元素不可重复。
• 方法：全部继承自Collection中的方法。

Set接口的使用

package qfClass.generic;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 * 测试Set接口的使用
 * 特点：（1）无序、没有下标（2）不能重复
 **/
public class Demo02 {
    public static void main(String[] args) {
        //创建集合
        Set<String> set = new HashSet<>();
        //1. 添加数据
        set.add("苹果");
        set.add("华为");
        set.add("小米");
        set.add("小米");
        System.out.println("数据个数："+set.size()); //数据个数：3
        System.out.println(set.toString()); //[苹果, 华为, 小米]

        //2. 删除数据
        set.remove("小米");
        System.out.println(set.toString()); //[苹果, 华为]

        //3. 遍历【重点】
        //3.1 使用增强for
        System.out.println("----增强for----");
        for (String string : set) {
            System.out.println(string);// 苹果 华为
        }
        //3.2 使用迭代器
        System.out.println("----使用迭代器----");
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());// 苹果 华为
        }

        //4. 判断
        System.out.println(set.contains("华为"));
        System.out.println(set.isEmpty());
    }
}

Set实现类

HashSet【重点】：

• 基于HashCode实现元素不重复
• 当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入。

HashSet的使用

import java.util.HashSet;
import java.util.Iterator;

/**
 * HashSet的集合的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 **/
public class Demo03 {
    public static void main(String[] args) {
        //创建集合
        HashSet<String> hashSet = new HashSet<>();
        //1. 添加元素
        hashSet.add("刘德华");
        hashSet.add("梁朝伟");
        hashSet.add("周润发");
        hashSet.add("林志玲");
        hashSet.add("刘德华");
        System.out.println("元素个数："+hashSet.size()); //元素个数：4
        System.out.println(hashSet.toString()); //[林志玲, 梁朝伟, 周润发, 刘德华]

        //2. 删除数据
        //hashSet.remove("刘德华");
        //System.out.println("删除之后："+hashSet.size());

        //3. 遍历操作
        //3.1 增强for
        System.out.println("----3.1 增强for----");
        for (String string : hashSet) {
            System.out.println(string);
        }
        //3.2 使用迭代器
        System.out.println("----3.2 迭代器----");
        Iterator<String> it = hashSet.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        //4. 判断
        System.out.println(hashSet.contains("郭富城")); //false
        System.out.println(hashSet.isEmpty()); //false
    }
}

HashSet的使用

package qfClass.generic;

import java.util.HashSet;
import java.util.Iterator;

/**
 * HashSet的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 * 储存过程（重复依据）
 * （1）根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二部。
 * （2）在执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表。
 **/
public class Demo04 {
    public static void main(String[] args) {
        //创建集合
        HashSet<Person> persons = new HashSet<>();

        //1. 添加数据
        Person p1 = new Person("刘德华", 20);
        Person p2 = new Person("林志祥", 22);
        Person p3 = new Person("梁朝伟", 25);
        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(p3); //重复
        persons.add(new Person("梁朝伟",25));
        System.out.println("元素个数："+persons.size()); //元素个数：3
        System.out.println(persons.toString()); //[Person{name='刘德华', age=20}, Person{name='梁朝伟', age=25}, Person{name='林志祥', age=22}]

        //2. 删除操作
        //persons.remove(p1);
        persons.remove(new Person("刘德华", 20));
        System.out.println("删除之后："+persons.size());//删除之后：2

        //3. 遍历【重点】
        //3.1 使用增强for
        for (Person person : persons) {
            System.out.println(person.toString());
        }
        //3.2 迭代器
        Iterator<Person> it = persons.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        //4. 判断
        System.out.println(persons.contains(p2));//true
        System.out.println(persons.contains(new Person("林志祥",22)));//true
        System.out.println(persons.isEmpty());//false
    }
}

Person类

package qfClass.generic;

/**
 * 人类
 **/
public class Person {
    private String name;
    private int age;

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

    public Person() {

    }

    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 String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int hashCode() {
        //int n1 = this.name.hashCode();
        //int n2 = this.age;
        //return n1+n2;

        //(1) 31是一个质数，减少散列冲突    (2)31提高执行效率 31*i=(i<<5)-i;
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (obj instanceof Person){
            Person p=(Person)obj;
            if (this.name.equals(p.getName())&&this.age==p.getAge()) {
                return true;
            }
        }

        return false;
    }
}

TreeSet：

• 基于排列顺序实现元素不重复。
• 实现了SortedSet接口，对集合元素自动排序。
• 元素对象的类型必须实现Comparable接口，指定排序规则。
• 通过CompareTo方法确定是否为重复元素。

TreeSet的使用

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

/**
 * TreeSet的使用
 * 存储结构：红黑树
 *
 **/
public class Demo05 {
    public static void main(String[] args) {
        //创建集合
        TreeSet<String> treeSet=new TreeSet<>();
        //1.添加元素
        treeSet.add("xyz");
        treeSet.add("abc");
        treeSet.add("hello");
        treeSet.add("xyz");
        System.out.println("元素个数"+treeSet.size()); //元素个数3
        System.out.println(treeSet.toString()); //[abc, hello, xyz]

        //2.删除
        treeSet.remove("xyz");
        System.out.println("删除之后："+treeSet.size());

        //3.遍历
        //3.1增强for循环
        System.out.println("------增强for循环------");
        for (String string : treeSet) {
            System.out.println(string);
        }
        //3.2使用迭代器
        System.out.println("------使用迭代器------");
        Iterator<String> it = treeSet.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        //4.判断
        System.out.println(treeSet.contains("abc"));
    }
}