三十三、Java基础之Set集合

一、Set集合介绍

/**
 * set集合:存储数据无序，不可重复
 * 无序是指存储的顺序可能和添加的顺序不一致
 */
例1：

public class Test01 {

    public static void main(String[] args){

        //1.创建set集合
        Set<String> set = new HashSet<>();

        //2.添加元素
        set.add("abc");
        set.add("woshizhongguoren");
        set.add("666");
        set.add("hahaha");

        //3.直接打印
        System.out.println(set);//[abc, hahaha, 666, woshizhongguoren]

        //4.添加重复元素
        set.add("666");
        set.add("hahaha");

        //Set集合中不能存储重复元素
        System.out.println(set);//[abc, hahaha, 666, woshizhongguoren]

        //5.删除
        set.remove("abc");
        System.out.println(set);

        //6.迭代
        Iterator<String> iterator = set.iterator();
        while(iterator.hasNext()){
            String string = (String)iterator.next();
            System.out.print(string + "\t");
        }
        System.out.println();
    }
}

二、HashSet集合介绍

/**
 * HashSet：
 * 1.HashSet底层是HashMap
 * 2.向HashSet中添加元素，实际上是把这个元素作为键添加到底层的HashMap中
 * 3.HashSet实际上是底层HashMap键的集合
 *
 */
例2：

public class Test02 {

    public static void main(String[] args){

        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("haha");
        System.out.println(hashSet);
    }
}

三、TreeSet集合

/**
 * TreeSet集合：
 *  可以对元素进行自然排序，要求元素必须石课比较的
 *      1>创建TreeSet集合时，通过构造方法指定Comparator比较器
 *      2>如果没有指定Comparator比较器。要求元素的类必须实现Comparator接口
 */
例3：
Person

public class Person implements Comparable<Person>{

    String name;
    int age;

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

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

    @Override
    public int compareTo(Person o) {
       //return this.name.compareTo(o.name);//年龄升序
        return o.age-this.age;
    }
}

 

public class Test03 {

    public static void main(String[] args){

        //1.创建TreeSet集合存储Person对象，存储Person对象，在构造方法中指定Comparator比较器
        TreeSet<Person> treeSet = new TreeSet<>(new Comparator<Person>() {
            //在匿名内部类中重写接口抽象方法
            @Override
            public int compare(Person o1, Person o2) {
                //指定一个比较规则
                return o1.name.compareTo(o2.name);//升序
            }
        });


        //2.添加元素
        treeSet.add(new Person("chu01",18));
        treeSet.add(new Person("chu02",19));
        treeSet.add(new Person("chu03",20));
        treeSet.add(new Person("chu04",21));
        treeSet.add(new Person("chu05",22));
        treeSet.add(new Person("chu06",23));

        //3.打印
        System.out.println(treeSet);

//[Person{name='chu01', age=18}, Person{name='chu02', age=19}, Person{name='chu03', age=20}, Person{name='chu04', age=21}, Person{name='chu05', age=22}, Person{name='chu06', age=23}]


        //4.根据已有的TreeSet创建新的TreeSet集合

        TreeSet<Person> treeSet1 = new TreeSet<>(treeSet);
        System.out.println(treeSet);

//[Person{name='chu01', age=18}, Person{name='chu02', age=19}, Person{name='chu03', age=20}, Person{name='chu04', age=21}, Person{name='chu05', age=22}, Person{name='chu06', age=23}]

        //5.使用TreeSet的额无参构造，没有指定Comparator比较器
        TreeSet<Person> treeSet2 = new TreeSet<>();
        treeSet2.addAll(treeSet);
        System.out.println(treeSet2);

//[Person{name='chu06', age=23}, Person{name='chu05', age=22}, Person{name='chu04', age=21}, Person{name='chu03', age=20}, Person{name='chu02', age=19}, Person{name='chu01', age=18}]


    }
}

四、TreeSet扩展

/**
 *注意：在TreeSet集合中，是根据Comparator/Comparator的比较结果是否为0来判断是否为同一对象，
 * 如果Comparator的compare()方法/Comparable的CompareTo()方法的返回值为0就认为是同一个对象
 */

public class Test04 {

    public static void main(String[] args){
        //创建TreeSet集合，存储Person对象，通过构造方法指定Comparator构造器，按照年龄降序排列
        TreeSet<Person> treeSet = new TreeSet<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o2.age-o1.age;
            }
        });

        //添加元素,当前treeSet是根据年龄比较Person大小的，我们在添加Person对象，如果年龄相同认为是一个对象
        treeSet.add(new Person("chu01",18));
        treeSet.add(new Person("chu02",18));
        treeSet.add(new Person("chu03",18));
        treeSet.add(new Person("chu04",18));
        treeSet.add(new Person("chu05",18));

        System.out.println(treeSet.size());//1
        System.out.println(treeSet);//[Person{name='chu01', age=18}]
        System.out.println(new Person("chu02",18));//true


    }
}

五、总结

/**
 *
 * Collection集合：
 *              只存储引用类型数据，单个存储
 *              基本操作：add().remove(),contains(),size(),iterator()
 *
 * List集合：
 *              特点：存储元素时有序的，可重复的
 *              为每个元素指定一个索引值
 *              增加的方法：针对索引值的操作，listIterator(),subList(),sort(Comparator),

 * ArrayList集合：
 *              底层是数组，访问快，添加/删除元素低
 *              初始化容量为10，扩容为1.5倍
 *
 * Vector集合：
 *              底层是数据，它是线程安全的，ArrayList是不是线程安全的
 *              初始化容量10，扩容为2倍
 *
 * LinkedList集合：
 *              底层是双向链表，添加删除效率高，访问慢
 *
 *List集合应用场景：
 *              ArrayList适用于以访问为主，很少添加/删除的情况
 *              LinkedList适用于经常添加/删除的情况
 *
 * Set集合：
 *              特点：数据无序，不可重复
 *HashSet集合：
 *              底层是HashMap，HashSet实际上就是HashMap键的集合
 *
 *TreeSet集合：
 *              底层是TreeMap，TreeSet实际上是TreeMap键的集合
 *              TreeSet实现了SortedSet接口，可以对元素自然排序，要求元素必须是可比较的：
 *              1.在构造方法中指定Comparator比较器对象
 *              2.如果没有Comparator比较器，集合元素的类必须实现Comparable接口
 *Set集合的应用场景：
 *              如果不需要对Set进行排序，就选择HashSet
 *              如果不需要对Set进行排序，就选择TreeSet
 *
 *注意：List集合/HashSet集合contains(e)/remove(e)等方法需要调用对象的equals()
 * 方法，这些集合中的元素的类需要重写equals()方法
 *    TreeSet集合中contains(e)/remove(e)等方法判断是否为同一对象是根据Comparator/Comparable的比较结果是否为0来判断的
 * 如果比较结果为0表示同一个元素
 *
 *
 *
 *
 */