集合框架：HashSet，TreeSet

集合框架

Set集合概述

特点：无序，无下标，元素不可重复

特点：全部继承自Collection中的方法

Set实现类

HashSet【重点】

基于HashCode实现元素不重复

当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入

TreeSet：

基于排列顺序实现元素不重复

Set集合的使用

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

public class Demo01 {
    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());
        System.out.println(set.toString());//无序
        //2.数据删除
//        set.remove("小米");
//        System.out.println(set.toString());
//        set.clear();
        //3.遍历【重点】
        //没有下标，不能使用for，可以用增强for
        //3.1增强for
        for (String string: set) {
            System.out.println(string);
        }
        System.out.println("================");
        //3.2迭代器
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("================");
        //4.判断
        System.out.println(set.contains("华为"));
        System.out.println(set.isEmpty());
    }
}

HashSet使用

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

/**
 * HashSet集合的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 *
 */

public class Demo02 {
    public static void main(String[] args) {
     //创建集合
        HashSet<String>hashSet = new HashSet<String>();
        //添加元素
        hashSet.add("刘德华");
        hashSet.add("梁朝伟");
        hashSet.add("林志玲");
        hashSet.add("周润发");
        //hashSet.add("刘德华");重复不能添加
        System.out.println("元素个数:"+hashSet.size());
        System.out.println(hashSet.toString());
        //2.删除
        hashSet.remove("刘德华");
        System.out.println("元素个数："+hashSet.size());
        //3.遍历操作
        //3.1增强for
        for(String string : hashSet){
            System.out.println(string);
        }
        //3.2使用迭代器
        Iterator<String> it = hashSet.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //4判断
        System.out.println(hashSet.contains("郭富城"));
        System.out.println(hashSet.isEmpty());
    }
}

import java.util.HashSet;

public class Demo03 {
    public static void main(String[] args) {
        //创建集合
        HashSet<Person> person = new HashSet<>();
        //1.添加数据
        Person p1 = new Person("刘德华",20);
        Person p2 = new Person("林志玲",22);
        Person p3 = new Person("梁朝伟",25);

        person.add(p1);
        person.add(p2);
        person.add(p3);
        person.add(new Person("梁朝伟",25));//new 一个新对象可以添加，创建了一个新的对象

        System.out.println("元素个数："+person.size());
        System.out.println(person.toString());
    }

}

HashSet存储方式

HashSet集合的使用
存储结构：哈希表（数组+链表+红黑树）
存储过程
(1)根据hashcode计算保存的位置，如果位置为空，则直接保存，如果不为空执行第二步
(2)再执行equals方法，如果equals方法为true,则认为重复,否则，形成链表

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

public class Demo03 {
    public static void main(String[] args) {
        //创建集合
        HashSet<Person> person = new HashSet<>();
        //1.添加数据
        Person p1 = new Person("刘德华",20);
        Person p2 = new Person("林志玲",22);
        Person p3 = new Person("梁朝伟",25);

        person.add(p1);
        person.add(p2);
        person.add(p3);
        person.add(new Person("梁朝伟",25));//new 一个新对象可以添加，创建了一个新的对象
        //重写了hashcode和equals之后，同样的元素也不能添加

        System.out.println("元素个数："+person.size());
        System.out.println(person.toString());

        //2.删除操作
//        person.remove(p1);
//        person.remove(new Person("林志玲",22));
//        System.out.println("删除之后"+person.size());

        System.out.println("====================");
        //3.遍历
        //3.1增强for
        for (Person person2 : person){
            System.out.println(person2.toString());
        }
        System.out.println("====================");
        //3.2迭代器
        Iterator<Person> it = person.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //4.判断
        System.out.println(person.contains(p1));
        System.out.println(person.contains(new Person("林志玲",22)));
        System.out.println(person.isEmpty());
    }

}

hashCode和equals方法重写

@Override
public int hashCode(){
    int n1 = this.name.hashCode();
    int n2 = this.age;
    return n1 + n2;
}
@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;
}

HashSet补充

（1）31是一个质数，减少散列冲突

（2）31提高执行效率 31*i=(i<<5)-i，转换为以为运算

TreeSet：

红黑树：保证平衡

基于排列顺序实现元素不重复

实现了SortedSet接口，对集合元素自动排序

元素对象的类型必须实现接口Comparable接口，指定排序规则。

通过CompareTo方法确定是否为重复元素

TreeSet使用

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

/**
 * TreeSet的使用
 * 存储结构：红黑树
 */

public class Demo04 {
    public static void main(String[] args) {
        //创建集合
        TreeSet<String> treeSet = new TreeSet<>();
        //1.添加元素
        treeSet.add("xyz");
        treeSet.add("abc");
        treeSet.add("hello");
        System.out.println("元素个数："+treeSet.size());
        System.out.println(treeSet.toString());//有排序

        //2.删除
//        treeSet.remove("xzy");
//        treeSet.clear();
        //3.遍历
        //3.1增强for
        for(String string : treeSet){
            System.out.println(string);
        }
        System.out.println("===================");
        //3.2迭代器
        Iterator<String> it = treeSet.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //4.判断
        System.out.println(treeSet.contains("abc"));
        System.out.println(treeSet.isEmpty());
    }
}

(2)

package X;

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

/**
 * 使用TreeSet保存数据
 * 存储结构：红黑树
 * 要求：元素必须实现Comparable接口，compareTo()方法返回值为0，认为是重复元素
 */

public class Demo05 {
    public static void main(String[] args) {
        //创建集合
        TreeSet<Person> persons = new TreeSet<>();
        //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);
        System.out.println("元素个数："+persons.size());
        System.out.println(persons.toString());//有排列顺序
        //报错ClassCastException
        //红黑树存储结构，需要比较左右两边大小，元素必须实现Comparable接口，否则报错

        //2.删除
//        persons.remove(new Person("梁朝伟",25));//比的是年龄姓名，能删除
//        persons.remove(p1);
        //3.遍历
        //3.1增强for
        for (Person person1 : persons){
            System.out.println(person1.toString());
        }
        System.out.println("========================");
        //3.2迭代器
        Iterator<Person> it = persons.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //4.判断
        
    }
}

报错：ClassCastException
红黑树存储结构，需要比较左右两边大小，元素必须实现Comparable接口，否则报错

compareTo()方法返回值为0，认为是重复元素

public class Person implements Comparable<Person>{
    //先按姓名比，然后按年龄比
    @Override
    public int compareTo(Person o){
        int n1 = this.getName().compareTo(o.getName());
        int n2 = this.age-o.getAge();
        return n1==0?n2:n1;//n1==0返回n2，否则返回n1
    }

}

Comparator接口

import java.util.Comparator;
import java.util.TreeSet;

/**
 * TreeSet集合的使用
 * Comparator：实现定制比较（比较器）
 * Comparable：可比较的
 */

public class Demo06 {
    public static void main(String[] args) {
        //创建集合,并指定比较规则
        TreeSet<Person> persons = new TreeSet<>(new Comparator<Person>(){

            @Override
            public int compare(Person o1, Person o2) {
                int n1 = o1.getAge() - o2.getAge();
                int n2 = o1.getName() .compareTo(o2.getName());
                return n1 == 0?n2:n1;
            }
        });
        Person p1 = new Person("刘德华",22);
        Person p2 = new Person("林志玲",20);
        Person p3 = new Person("梁朝伟",25);

        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        System.out.println(persons.toString());//会进行排序
    }
}

TreeSet案例

使用TreeSet集合实现字符串按照长度进行排序

import java.util.Comparator;
import java.util.TreeSet;

/**
 * 需求：使用TreeSet集合实现字符串按照长度进行排序
 * helloworld  zhang  lisi  wangwu  beijing  xian  nanjing
 */

public class Demo07 {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>(){

            @Override
            public int compare(String o1, String o2) {
                int n1 = o1.length() - o2.length();
                int n2 = o1.compareTo(o2);
                return n1 == 0?n2:n1;
            }
        });
        //添加数据
        treeSet.add("helloworld");
        treeSet.add("pingguo");
        treeSet.add("lisi");
        treeSet.add("zhangsan");
        treeSet.add("beijing");
        treeSet.add("cat");
        treeSet.add("nanjing");
        treeSet.add("xian");
        System.out.println(treeSet.toString());
    }
}