JAVA基础再回首（十七）——Set集合、增强for、HashSet类、LinkedHashSet类、TreeSet类、二叉树、Comparator 排序

JAVA基础再回首（十七）——Set集合、增强for、HashSet类、LinkedHashSet类、TreeSet类、二叉树、Comparator 排序

版权声明：转载必须注明本文转自程序员杜鹏程的博客:http://blog.csdn.net/m366917

---

前面我们学习了集合框架的List集合，根据前面我画的集合框架的图，可以看到还有Set集合和Map集合我们没有学习，这篇我们就来学习Set集合。

• Set
  
  • 元素是无序(存储顺序和取出顺序不一致),元素是唯一的，不可重复的

我们来看一下API

我们写一个简单的Demo看看它的元素是不是无序和唯一的

public class SetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        Set<String> set = new HashSet<String>();

        // 创建并添加元素
        set.add("hello");
        set.add("java");
        set.add("world");
        set.add("java");
        set.add("world");

        // 增强for遍历
        for (String s : set) {
            System.out.println(s);
        }
        //迭代器遍历
        Iterator it = set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

我们先来看结果：

在这里想给大家说一个要注意的地方
虽然Set集合的元素无序，但是，作为集合来说，它肯定有它自己的存储顺序，而你的顺序恰好和它的存储顺序一致，这代表不了有序，你可以多存储一些数据，就能看到效果。

上面我们使用了两种遍历的方式，用了增强的for循环和迭代器来遍历，前面我们学List集合的时候，我们还用了普通的for循环，但是在这里不能用普通的for循环了，迭代器遍历我们前面都学过，那我在下面就简单的提一下增强的for循环的简单使用。

增强for

增强for:是for循环的一种。

格式：
    for(元素数据类型 变量 : 数组或者Collection集合) {
        使用变量即可，该变量就是元素
    }

好处：简化了数组和集合的遍历。
弊端： 增强for的目标不能为null。
如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。

HashSet类

什么是HashSet？我们先来了解他的概述

• HashSet类概述
  
  • 不保证 set 的迭代顺序
  • 特别是它不保证该顺序恒久不变。
• HashSet如何保证元素唯一性
  
  • 底层数据结构是哈希表(元素是链表的数组)
  • 哈希表依赖于哈希值存储
  • 添加功能底层依赖两个方法：
    
    • int hashCode()
    • boolean equals(Object obj)

public class HashSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        HashSet<String> hs = new HashSet<String>();

        // 创建并添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        hs.add("world");

        // 遍历集合(这里可以用增强for也可以用迭代器，但是增强for比较简单点)
        for (String s : hs) {
            System.out.println(s);
        }
    }
}

输出结果：

为什么存储字符串的时候，字符串内容相同的只存储了一个呢?

我们可以查看add方法的源码，就可以知道这个方法底层依赖 两个方法：hashCode()和equals()。

• 步骤：
  
  • 首先比较哈希值
  • 如果相同，继续走，比较地址值或者走equals()
  • 如果不同,就直接添加到集合中
• 按照方法的步骤来说：
  
  • 先看hashCode()值是否相同
  • 相同:继续走equals()方法
  • 返回true： 说明元素重复，就不添加
  • 返回false：说明元素不重复，就添加到集合
  • 不同：就直接把元素添加到集合
• 如果类没有重写这两个方法，默认使用的Object()。一般来说不同相同。
• 而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。

存储自定义对象

我们存储自定义对象，并保证元素的唯一性，
要求：如果两个对象的成员变量值都相同，则为同一个元素。

public class HashSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        HashSet<Student> hs = new HashSet<Student>();

        // 创建学生对象
        Student s1 = new Student("朱婷", 22);
        Student s2 = new Student("惠若琪", 22);
        Student s3 = new Student("徐云丽", 21);
        Student s4 = new Student("朱婷", 22);
        Student s5 = new Student("郎平", 55);
        Student s6 = new Student("郎平", 57);

        // 添加元素
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);
        hs.add(s5);
        hs.add(s6);

        // 遍历集合
        for (Student s : hs) {
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

/**
 * 存储对象
 */
public class Student {
    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.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;
    }
}

输出结果：

我们看输出结果，很明显不符合我的要求。
因为我们知道HashSet底层依赖的是hashCode()和equals()方法。
而这两个方法我们在学生类中没有重写，所以，默认使用的是Object类。
这个时候，他们的哈希值是不会一样的，根本就不会继续判断，执行了添加操作。

所以我们要在Student类中重写hashCode()和equals()这两个方法
这两个方法都是重写的，不用自己去写

@Override
    public int hashCode() {
        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 (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

然后我们运行程序，会出现以下结果，你会发现，符合了我们的要求

LinkedHashSet类

• 概述
  
  • 底层数据结构由哈希表和链表组成
  • 由链表保证元素有序(存储和取出是一致)
  • 由哈希表保证元素唯一性
    

    我们做个小练习来了解它

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedHashSet<String> hs = new LinkedHashSet<String>();

        // 创建并添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        hs.add("world");
        hs.add("java");

        // 遍历
        for (String s : hs) {
            System.out.println(s);
        }
    }
}

输出结果：

LinkedHashSet类很好理解，下面我们来继续学习TreeSet类

TreeSet类

• 概述
  
  • 使用元素的自然顺序对元素进行排序
  • 或者根据创建 set 时提供的 Comparator 进行排序
    
    • 所以排序有两种方式
      
      • 自然排序
      • 比较器排序
  • 具体取决于使用的构造方法。

我们先创建集合对象，运用自然排序的方式来写Demo

public class TreeSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        // 自然顺序进行排序
        TreeSet<Integer> ts = new TreeSet<Integer>();

        // 创建元素并添加
        // 20,18,23,22,17,24,19,18,24
        ts.add(20);
        ts.add(18);
        ts.add(23);
        ts.add(22);
        ts.add(17);
        ts.add(24);
        ts.add(19);
        ts.add(18);
        ts.add(24);

        // 遍历
        for (Integer i : ts) {
            System.out.println(i);
        }
    }
}

输出结果：
我们可以看到它使用元素的自然顺序对元素进行了排序

• TreeSet是如何保证元素的排序和唯一性的
  
  • 底层数据结构是红黑树(红黑树是一种自平衡的二叉树)

下面我们就来学习一下二叉树

二叉树

那么二叉树是怎么把元素存进去，又是怎么取出来的呢？
如果你弄懂了这个问题，那么你就明白了二叉树了

我们先来了解元素是如何存储进去的？

第一个元素存储的时候，直接作为根节点存储。
从第二个元素开始，每个元素从根节点开始比较
比根节点元素大，就放在右边
比根节点元素小，就放在左边
相等的话就忽略。

我们以上面的存储的元素20,18,23,22,17,24,19,18,24来画一个图帮助大家理解

元素是如何取出来的呢？

从根节点开始，按照左、中、右的原则依次取出元素即可。

Comparator 排序

上面我们学习了自然排序，接下来我们来学习比较器排序。

/*
 * 需求：请按照姓名的长度排序
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>();

        // 创建元素
        Student s1 = new Student("朱婷", 22);
        Student s2 = new Student("惠若琪", 22);
        Student s3 = new Student("徐云丽", 21);
        Student s4 = new Student("朱婷婷", 22);
        Student s5 = new Student("郎平", 55);
        Student s6 = new Student("林丹", 34);
        Student s7 = new Student("李宗伟", 33);
        Student s8 = new Student("阿杜", 23);

        // 添加元素
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);
        ts.add(s8);

        // 遍历
        for (Student s : ts) {
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}
/*
 * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口
 */
public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.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(Student s) {
        // 主要条件 姓名的长度
        int num = this.name.length() - s.name.length();
        // 姓名的长度相同，不代表姓名的内容相同
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        // 姓名的长度和内容相同，不代表年龄相同，所以还得继续判断年龄
        int num3 = num2 == 0 ? this.age - s.age : num2;
        return num3;
    }
}

输出结果：
我们就总结了以下几点内容

• TreeSet集合保证元素排序和唯一性的原理
• 唯一性：是根据比较的返回是否是0来决定。
• 排序：
  
  • A:自然排序(元素具备比较性)
    
    • 让元素所属的类实现自然排序接口 Comparable
  • B:比较器排序(集合具备比较性)
    
    • 让集合的构造方法接收一个比较器接口的子类对象 Comparator

最后，我们在做一个联系题吧
获取10个1至20的随机数，要求随机数不能重复。

我们先来分析一下：

• A:创建随机数对象
• B:创建一个HashSet集合
• C:判断集合的长度是不是小于10
  
  • 是：就创建一个随机数添加
  • 否：不理它
• D:遍历HashSet集合

知道了思路，那就开始写吧！

public class HashSetDemo {
    public static void main(String[] args) {
        // 创建随机数对象
        Random r = new Random();

        // 创建一个Set集合
        HashSet<Integer> ts = new HashSet<Integer>();

        // 判断集合的长度是不是小于10
        while (ts.size() < 10) {
            int num = r.nextInt(20) + 1;
            ts.add(num);
        }

        // 遍历Set集合
        for (Integer i : ts) {
            System.out.println(i);
        }
    }
}

运行程序，每次都会得到10个1-20以内的随机数

---

好了，这篇我们讲了Set集合和它的子类，没有掌握的，再好好理解一下，下篇我们学习Map集合。

欢迎有兴趣的同学加我朋友的QQ群：点击直接加群555974449 请备注：java基础再回首我们一起来玩吧。