集合4

1:登录注册案例(理解)

2:Set集合(理解)
(1)Set集合的特点
无序,唯一
(2)HashSet集合(掌握)
A:底层数据结构是哈希表(是一个元素为链表的数组)
B:哈希表底层依赖两个方法：hashCode()和equals()
执行顺序：
首先比较哈希值是否相同
相同：继续执行equals()方法
返回true：元素重复了，不添加
返回false：直接把元素添加到集合
不同：就直接把元素添加到集合
C:如何保证元素唯一性的呢?
由hashCode()和equals()保证的
D:开发的时候，代码非常的简单，自动生成即可。
E:HashSet存储字符串并遍历
F:HashSet存储自定义对象并遍历(对象的成员变量值相同即为同一个元素)

/* * 需求：存储自定义对象，并保证元素的唯一性 * 要求：如果两个对象的成员变量值都相同，则为同一个元素。 *  * 目前是不符合我的要求的：因为我们知道HashSet底层依赖的是hashCode()和equals()方法。 * 而这两个方法我们在学生类中没有重写，所以，默认使用的是Object类。 * 这个时候，他们的哈希值是不会一样的，根本就不会继续判断，执行了添加操作。 */public class HashSetDemo2 {    public static void main(String[] args) {        // 创建集合对象        HashSet<Student> hs = new HashSet<Student>();        // 创建学生对象        Student s1 = new Student("林青霞", 27);        Student s2 = new Student("柳岩", 22);        Student s3 = new Student("王祖贤", 30);        Student s4 = new Student("林青霞", 27);        Student s5 = new Student("林青霞", 20);        Student s6 = new Student("范冰冰", 22);        // 添加元素        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());        }    }}

(3)TreeSet集合
A:底层数据结构是红黑树(是一个自平衡的二叉树)
B:保证元素的排序方式
a:自然排序(元素具备比较性)
让元素所属的类实现Comparable接口

/* * TreeSet：能够对元素按照某种规则进行排序。 * 排序有两种方式 * A:自然排序 * B:比较器排序 *  * TreeSet集合的特点：排序和唯一 *  * 通过观察TreeSet的add()方法，我们知道最终要看TreeMap的put()方法。 */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);        }    }}

        b:比较器排序(集合具备比较性)            让集合构造方法接收Comparator的实现类对象

public class MyComparator implements Comparator<Student> {    @Override    public int compare(Student s1, Student s2) {        // int num = this.name.length() - s.name.length();        // this -- s1        // s -- s2        // 姓名长度        int num = s1.getName().length() - s2.getName().length();        // 姓名内容        int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;        // 年龄        int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;        return num3;    }}

/* * 需求：请按照姓名的长度排序 *  * TreeSet集合保证元素排序和唯一性的原理 * 唯一性：是根据比较的返回是否是0来决定。 * 排序： *      A:自然排序(元素具备比较性) *          让元素所属的类实现自然排序接口 Comparable *      B:比较器排序(集合具备比较性) *          让集合的构造方法接收一个比较器接口的子类对象 Comparator */public class TreeSetDemo {    public static void main(String[] args) {        // 创建集合对象        // TreeSet<Student> ts = new TreeSet<Student>(); //自然排序        // public TreeSet(Comparator comparator) //比较器排序        // TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());        // 如果一个方法的参数是接口，那么真正要的是接口的实现类的对象        // 而匿名内部类就可以实现这个东西        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {            @Override            public int compare(Student s1, Student s2) {                // 姓名长度                int num = s1.getName().length() - s2.getName().length();                // 姓名内容                int num2 = num == 0 ? s1.getName().compareTo(s2.getName())                        : num;                // 年龄                int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;                return num3;            }        });        // 创建元素        Student s1 = new Student("linqingxia", 27);        Student s2 = new Student("zhangguorong", 29);        Student s3 = new Student("wanglihong", 23);        Student s4 = new Student("linqingxia", 27);        Student s5 = new Student("liushishi", 22);        Student s6 = new Student("wuqilong", 40);        Student s7 = new Student("fengqingy", 22);        Student s8 = new Student("linqingxia", 29);        // 添加元素        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());        }    }}

    C:把我们讲过的代码看一遍即可(4)案例：    A:获取无重复的随机数

/* * 编写一个程序，获取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);        }    }}

    B:键盘录入学生按照总分从高到底输出

/* * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台 *  * 分析： *      A:定义学生类 *      B:创建一个TreeSet集合 *      C:总分从高到底如何实现呢?       *      D:键盘录入5个学生信息 *      E:遍历TreeSet集合 */public class TreeSetDemo {    public static void main(String[] args) {        // 创建一个TreeSet集合        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {            @Override            public int compare(Student s1, Student s2) {                // 总分从高到低                int num = s2.getSum() - s1.getSum();                // 总分相同的不一定语文相同                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;                // 总分相同的不一定数序相同                int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;                // 总分相同的不一定英语相同                int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3;                // 姓名还不一定相同呢                int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName())                        : num4;                return num5;            }        });        System.out.println("学生信息录入开始");        // 键盘录入5个学生信息        for (int x = 1; x <= 5; x++) {            Scanner sc = new Scanner(System.in);            System.out.println("请输入第" + x + "个学生的姓名:");            String name = sc.nextLine();            System.out.println("请输入第" + x + "个学生的语文成绩:");            String chineseString = sc.nextLine();            System.out.println("请输入第" + x + "个学生的数学成绩:");            String mathString = sc.nextLine();            System.out.println("请输入第" + x + "个学生的英语成绩:");            String englishString = sc.nextLine();            // 把数据封装到学生对象中            Student s = new Student();            s.setName(name);            s.setChinese(Integer.parseInt(chineseString));            s.setMath(Integer.parseInt(mathString));            s.setEnglish(Integer.parseInt(englishString));            // 把学生对象添加到集合            ts.add(s);        }        System.out.println("学生信息录入完毕");        System.out.println("学习信息从高到低排序如下：");        System.out.println("姓名\t语文成绩\t数学成绩\t英语成绩");        // 遍历集合        for (Student s : ts) {            System.out.println(s.getName() + "\t" + s.getChinese() + "\t"                    + s.getMath() + "\t" + s.getEnglish());        }    }}

3:Collection集合总结(掌握)
Collection
|–List 有序,可重复
|–ArrayList
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高
|–Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低
|–LinkedList
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高
|–Set 无序,唯一
|–HashSet
底层数据结构是哈希表。
如何保证元素唯一性的呢?
依赖两个方法：hashCode()和equals()
开发中自动生成这两个方法即可
|–LinkedHashSet
底层数据结构是链表和哈希表
由链表保证元素有序
由哈希表保证元素唯一
|–TreeSet
底层数据结构是红黑树。
如何保证元素排序的呢?
自然排序
比较器排序
如何保证元素唯一性的呢?
根据比较的返回值是否是0来决定

4:针对Collection集合我们到底使用谁呢?(掌握)
唯一吗?
是：Set
排序吗?
是：TreeSet
否：HashSet
如果你知道是Set，但是不知道是哪个Set，就用HashSet。

    否：List        要安全吗?            是：Vector            否：ArrayList或者LinkedList                查询多：ArrayList                增删多：LinkedList    如果你知道是List，但是不知道是哪个List，就用ArrayList。如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。如果你知道用集合，就用ArrayList。

5:在集合中常见的数据结构(掌握)
ArrayXxx:底层数据结构是数组，查询快，增删慢
LinkedXxx:底层数据结构是链表，查询慢，增删快
HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序