java基础学习_集合类03_用户登录注册案例(集合版)、Set集合、Collection集合总结_day17总结

=============================================================================
=============================================================================
涉及到的知识点有：
1:用户登录注册案例(集合版)(理解)
2:Set集合(理解)
　　(1)Set集合的特点
　　(2)HashSet集合(掌握)
　　(3)TreeSet集合(理解)
　　(4)案例
3:Collection集合总结(掌握)
4:针对Collection集合我们到底使用谁呢？(掌握)
5:在集合中常见的数据结构(掌握)
=============================================================================
=============================================================================
1:用户登录注册案例(集合版)(理解)
-----------------------------------------------------------------------------
2:Set集合(理解)
　　(1)Set集合的特点
　　　　无序:存和取的顺序不一致,无索引,不可以存储重复元素(唯一)
---------------------------------------
　　(2)HashSet集合(掌握)
　　　　A:底层的数据结构是哈希表(是一个元素为链表的数组)

　　　　
　　　　B:哈希表底层依赖两个方法：hashCode()和equals()
　　　　　　执行顺序：
　　　　　　　　首先比较哈希值是否相同
　　　　　　　　　　相同：继续执行equals()方法
　　　　　　　　　　　　返回true：元素重复了，不添加
　　　　　　　　　　　　返回false：直接把元素添加到集合
　　　　　　　　　　不相同：就直接把元素添加到集合
　　　　C:如何保证元素唯一性的呢?
　　　　　　由hashCode()和equals()保证的。
　　　　　　即：int hashCode()
　　　　　　　　boolean equals(Object obj)
　　　　D:开发的时候，代码非常的简单，自动生成即可。
　　　　E:案例
　　　　　　1.HashSet存储字符串并遍历(注意：字符串默认重写了hasCode()和equals()方法)
　　　　　　2.HashSet存储自定义对象并遍历(对象的成员变量值都相同即为同一个元素)
　　　　F:LinkedHashSet：底层的数据结构由哈希表和链表组成。
　　　　　　哈希表保证元素的唯一性。
　　　　　　链表保证元素有序。(存储和取出顺序一致)
　　　　注意事项：
　　　　　　1.一般来说，不同的字符串的哈希值是不同的。
　　　　　　　　哈希值仅仅是逻辑值，可能一样。
　　　　　　　　地址值是实际的物理值，不一样。
　　　　　　2.HashSet：它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
　　　　　　　　注意：虽然Set集合的元素无序，但是，作为集合来说，它肯定有它自己的存储顺序，
　　　　　　　　　　    而你的顺序恰好和它的存储顺序一致，这代表不了有序，你可以多存储一些数据，就能看到效果。

---------------------------------------
　　(3)TreeSet集合(理解)
　　　　A:底层数据结构是红黑树(是一个自平衡的二叉树)(自平衡:说明其结构不会太深)

　　　　
　　　　B:保证元素的排序方式(具体那种方式取决于使用TreeSet的构造方法)
　　　　　　a:自然排序(元素具备比较性)
　　　　　　　　让元素所属的类实现自然排序 Comparable接口。

　　　　　　　　示例代码如下：

package cn.itcast_06;

/*
 * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口，然后重写compareTo()方法
 */
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();
        // 次要条件1：姓名的长度相同，不代表姓名的内容相同
        int num2 = (num == 0 ? this.name.compareTo(s.name) : num);
        // 次要条件2：姓名的长度和内容相同，不代表年龄也相同，所以还得继续比较年龄
        int num3 = (num2 == 0 ? this.age - s.age : num2);
        return num3;
    }

}

package cn.itcast_06;

import java.util.TreeSet;

/*
 * TreeSet存储自定义对象并保证排序和唯一
 * 
 * 需求：请按照姓名的长度排序。
 * 
 * TreeSet集合保证元素排序和唯一性的原理：
 *         唯一性：是根据比较的返回是否是0来决定。
 *         排序：
 *             A:自然排序(元素具备比较性)
 *                 让元素所属的类实现自然排序 Comparable接口。
 *             B:比较器排序(集合具备比较性)
 *                 让集合的构造方法接收一个比较器接口 Comparator的实现类对象，一般用匿名内部类实现。
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        // TreeSet的构造方法：public TreeSet() // 自然排序
        TreeSet<Student> ts = new TreeSet<Student>(); 

        // 创建元素对象
        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());
        }
    }
}

　　　　　b:比较器排序(集合具备比较性)
　　　　　　　　让集合的构造方法接收一个比较器接口 Comparator的实现类对象，一般用匿名内部类实现。

　　　　　　　　示例代码如下：

　　　　　　　　（1）用自己新建的实现类实现

package cn.itcast_07;

/*
 * 如果一个类的元素要想能够进行比较器排序。
 */
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;
    }

}

package cn.itcast_07;

import java.util.Comparator;

public class MyComparator implements Comparator<Student> {

    @Override
    public int compare(Student s1, Student s2) {
        // return 0;
        
        // 需求：请按照姓名的长度排序
        // int num = this.name.length() - s.name.length();
        // this --> s1    // s1不能直接访问name，因为s1是在MyComparator类中，而name是在Student类中，要想访问，需要通过getXxx()方法
        // 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;
    }

}

package cn.itcast_07;

import java.util.TreeSet;

/*
 * 需求：请按照姓名的长度排序
 * 
 * TreeSet集合保证元素排序和唯一性的原理：
 *         唯一性：是根据比较的返回是否是0来决定。
 *         排序：
 *             A:自然排序(元素具备比较性)
 *                 让元素所属的类实现自然排序 Comparable接口。
 *             B:比较器排序(集合具备比较性)
 *                 让集合的构造方法接收一个比较器接口 Comparator的实现类对象，一般用匿名内部类实现。
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        // TreeSet的构造方法：public TreeSet(Comparator<? super E> comparator) // 比较器排序，传递的数据类型是引用数据类型中的接口，说明传递的是实现类对象
        TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());     // 示例：自己写了个具体实现类MyMyComparator，并重写compare()方法

        // 创建元素对象
        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());
        }
    }
}

　　　　　　　　（2）用用匿名内部类实现

package cn.itcast_07;

/*
 * 如果一个类的元素要想能够进行比较器排序。
 */
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;
    }

}

package cn.itcast_07;

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

/*
 * 需求：请按照姓名的长度排序
 * 
 * TreeSet集合保证元素排序和唯一性的原理：
 *         唯一性：是根据比较的返回是否是0来决定。
 *         排序：
 *             A:自然排序(元素具备比较性)
 *                 让元素所属的类实现自然排序 Comparable接口。
 *             B:比较器排序(集合具备比较性)
 *                 让集合的构造方法接收一个比较器接口 Comparator的实现类对象，一般用匿名内部类实现。
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        // TreeSet的构造方法：public TreeSet() // 自然排序
        // TreeSet<Student> ts = new TreeSet<Student>(); 
        
        // TreeSet的构造方法：public TreeSet(Comparator<? super E> comparator) // 比较器排序，传递的数据类型是引用数据类型中的接口，说明传递的是实现类对象
        // TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());     // 示例：自己写了个具体实现类MyComparator，并重写compare()方法

        // 如果一个方法的参数是接口，那么真正需要的是接口的实现类的对象，而且该方法只调用一次。
        // 所以使用匿名内部类就可以实现这个东西，这样就不用自己去重新写一个具体的实现类了。其实这种方式是很常见的。
        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的随机数，要求随机数不能重复。

　　　　1.用集合HashSet实现

package cn.itcast_08;

import java.util.HashSet;
import java.util.Random;

/*
 * 编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
 * 
 * 分析：
 *         A:创建随机数对象
 *         B:创建一个HashSet集合
 *         C:判断集合的长度是不是小于10，因为Integer包装类默认实现了Comparable接口，所以Integer类能自动判断是否有重复元素
 *             是：就创建一个随机数添加
 *             否：不搭理它
 *         D:遍历HashSet集合
 */
public class HashSetDemo {
    public static void main(String[] args) {
        // 创建随机数对象
        Random r = new Random();

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

        // 判断集合的长度是不是小于10，因为Integer包装类默认实现了Comparable接口，所以Integer类能自动判断是否有重复元素
        while (hs.size() < 10) {
            int num = r.nextInt(20) + 1;
            hs.add(num);
        }

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

　　　　2.用集合ArrayList实现

package cn.itcast_02;

import java.util.ArrayList;
import java.util.Random;

/*
 * 获取10个1-20之间的随机数，要求不能重复
 * 
 * 用数组实现，但是数组的长度是固定的。
 * 长度不好确定，所以我们使用集合实现。
 * 
 * 分析：
 *         A:创建产生随机数的对象。
 *         B:创建一个存储随机数的集合ArrayList。
 *         C:定义一个统计变量。从0开始。
 *         D:判断统计遍历是否小于10
 *             是:产生一个随机数，判断该随机数在集合中是否存在。
 *                     如果不存在:就添加，统计变量++。
 *                     如果存在:就不搭理它。
 *             否：不搭理它
 *         E:遍历ArrayList集合
 */
public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建产生随机数的对象。
        Random r = new Random();

        // 创建一个存储随机数的集合。
        ArrayList<Integer> array = new ArrayList<Integer>();

        // 定义一个统计变量。从0开始。
        int count = 0;

        // 判断统计遍历是否小于10
        while (count < 10) {
            // 产生一个随机数
            int number = r.nextInt(20) + 1;

            // 判断该随机数在集合中是否存在。
            if (!array.contains(number)) {
                // 如果不存在:就添加，统计变量++。
                array.add(number);
                count++;
            }
        }

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

　　　　B:键盘录入5个学生信息(姓名、语文成绩、数学成绩、英语成绩)，按照总分从高到低输出到控制台。

package cn.itcast_09;

public class Student {
    // 姓名
    private String name;
    // 语文成绩
    private int chinese;
    // 数学成绩
    private int math;
    // 英语成绩
    private int english;
    
    public Student() {
        super();
    }

    public Student(String name, int chinese, int math, int english) {
        super();
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getEnglish() {
        return english;
    }

    public void setEnglish(int english) {
        this.english = english;
    }

    public int getSum() {
        return this.chinese + this.math + this.english;
    }
}

package cn.itcast_09;

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

/*
 * 键盘录入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)); // 把字符串类型转换为int类型
            s.setMath(Integer.parseInt(mathString));        // 把字符串类型转换为int类型
            s.setEnglish(Integer.parseInt(englishString)); // 把字符串类型转换为int类型

            // 把学生对象添加到集合
            ts.add(s);
        }
        System.out.println("学生信息录入完毕");

        System.out.println("学习信息从高到低排序如下：");
        System.out.println("姓名	语文成绩	数学成绩	英语成绩");
        // 遍历TreeSet集合
        for (Student s : ts) {
            System.out.println(s.getName() + "	" + s.getChinese() + "	" + s.getMath() + "	" + 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。
    由此可见，ArrayList用的最多。

-----------------------------------------------------------------------------
5:在集合中常见的数据结构(掌握)

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