08Java语法回顾collection之set集合

Java语法回顾Collection之Set集合

---

读了那么多年的书让我明白一个道理。人要稳重，不要想到啥就做啥。做一行越久即使你不会，几年之后慢慢的你也会了，加上一点努力你或许你能成为别人眼中的专家。

HashSet集合

/*
 * Collection
 *      |--List
 *          元素有序(存储和取出顺序一致),可以重复
 *      |--Set
 *          元素无序,唯一
 * 
 * 通过查看API，我们发现，Set中的功能和Collection一样。所以。我们就不用在一个个的学习了，直接使用即可。
 * 又因为它是接口，所以，找一个实现类HashSet
 */

HashSet存储自定义对象解决重复元素

/*
 * HashSet存储自定义对象。
 * 需求：我们认为一个对象如果成员变量值都相同，则为同一个对象。
 * 
 * 请思考：
 *      A:哪里出问题了
 *          通过简单的分析，我们知道了在add方法出问题了。
 *      B:怎么解决
 *          看源码
 * 通过看源码：我们知道，最终的操作跟如下这个判断相关
 *      if(e.hash == hash && ((k = e.key) == key || key.equals(k)))
 *      {
 *          唯一。
 *      }
 * 分析条件：
 *      A:这个判断跟对象的hashCode()方法相关。
 *      B:这个判断跟equals()方法相关。
 * 
 * 
 * 总结：
 *      HashSet如何保证元素的唯一性的呢?
 *          HashSet的底层数据结构是哈希表。
 *          它依赖两个方法，hashCode()和equals()。
 *          顺序：
 *              首先，判断对象的hashCode()值是否相同。
 *                  相同：
 *                      继续走equals()。看返回值是true还是false
 *                          A:如果是true,说明有元素重复。该元素不添加到集合。
 *                          B:如果是false,说明元素不重复，该元素添加到集合。
 *                  不同：就直接添加到集合中了。
 */

如何在JavaBean中重新haseCode()和equals()

/*
 * hashCode():把所有成员变量值相加。如果是引用类型，用哈希值。如果是基本类型直接用值。
 *          Person:
 *              String name;
 *              int age;
 *              char sex;
 *              float score;
 * 
 *              public int hashCode()
 *              {
 *                  return this.name.hashCode()+this.age*13+this.sex*17+this.score*21;
 *              }
 * equals():三步。
 *              A:this == obj
 *              B:!(obj instanceof Student)
 *              C:this.name.equals(s.name) && this.age == s.age && this.sex == s.sex && this.score == s.socre;
 * 会但是不用记。理解即可。
 * 开发不这样用。怎么用呢?
 * 自动生成。
 */

TreeSet集合

/*
 * TreeSet可以对元素进行排序。
 * 自然排序：按照字典的拼音顺序排序
 * 使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。 
 */

TreeSet集合代码测试

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

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

        // 遍历
        for (String str : ts) {
            System.out.println(str);
        }
    }
}

TreeSet存储自定义对象保证元素的唯一性

/*
 * TreeSet存储自定义对象。
 * 保证元素有序和唯一。
 * 
 * Exception in thread "main" java.lang.ClassCastException: 
 * cn.itcast_03.Student cannot be cast to java.lang.Comparable
 * 
 * TreeSet保证元素排序有两种方式：
 * A:自然顺序 让对象所属的类去实现Comparable接口。无参构造。
 * B:比较器接口 Comparator。带参构造。
 * 
 * 在自然排序中，又是如何保证排序的呢?
 * 根据返回值看：
 *      正   就说明元素比以前的元素大，往后放。
 *      负   就说明元素比以前的元素小，往前放。
 *      0   元素就不添加到集合中。着就是保证唯一性的原理。
 * 
 * 需求：我想按照对象的年龄排序，从小到大排序。怎么做?
 * 
 * 需求:我想按照姓名的长度排序，从小到大排序。怎么做?
 */

TreeSet存储自定义对象保证元素的唯一性代码测试

public class TreeSetDemo {
    public static void main(String[] args) {

        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                // 按年龄排序，从小到大
                int num = s1.getAge() - s2.getAge();
                // 次要条件
                int num2 = (num == 0) ? (s1.getName().compareTo(s2.getName())) : num;
                return num2;
            }
        });

        // 创建元素对象
        Student s1 = new Student("liudehua", 52);
        Student s2 = new Student("chenglong", 60);
        Student s3 = new Student("zhouxinchi", 44);
        Student s4 = new Student("sunyanzi", 34);
        Student s5 = new Student("linqingxia", 26);
        Student s6 = new Student("linqingxia", 36);
        Student s7 = new Student("linqing", 26);
        Student s8 = new Student("linqingxia", 26);

        // 添加元素
        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());
        }
    }
}

Collection和Collections的区别

/*
 * 面试题：
 *  Collection和Collections的区别?
 *  Collection:是Collection集合的顶层接口，定义了Collection集合的共性方法。
 *  Collections:是一个类，定义了针对Collection集合操作的功能。有排序，查找，反转等。
 *  
 *  Collections的功能：
 *  排序：public static void sort(List list)
 *  二分查找：public static <T> int binarySearch(List list,T key)
 *  反转：public static void reverse(List list)
 *  最大值：public static  T max(Collection coll)
 *  随机置换：public static void shuffle(List list)
 */

Collection和Collections的区别代码测试

public class CollectionsDemo {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList<Integer> array = new ArrayList<Integer>();
        // 添加元素
        array.add(60);
        array.add(25);
        array.add(38);
        array.add(213);
        array.add(99);
        array.add(22);

        System.out.println("array:" + array);

        // 排序
        // public static void sort(List list)
        // Collections.sort(array);
        // System.out.println("array:" + array);

        // 二分查找
        // public static <T> int binarySearch(List list,T key)
        // [22, 25, 38, 60, 99, 213]
        // int index = Collections.binarySearch(array, 60);
        // System.out.println("index:" + index);

        // 反转
        // public static void reverse(List list)
        // [60, 25, 38, 213, 99, 22]
        // Collections.reverse(array);
        // System.out.println("array:" + array);

        // 最大值
        // public static T max(Collection coll)
        // Integer i = Collections.max(array);
        // System.out.println(i);

        // 随机置换：public static void shuffle(List list)
        Collections.shuffle(array);
        System.out.println("array:" + array);

    }
}