Day17练习

A:简答题

1、请简述Set集合的特点？

元素唯一 可以添加一个null
存放数据是无序的(添加的顺序和取出的顺序不一致)
取出的顺序是固定的(不是添加顺序)

2、请简述HashSet是如何保证元素唯一性的?

HashSet集合第一次添加元素时 通过调用HashCode()方法计算出元素存放的位置
之后添加相同元素时 调用HashCode()方法计算出哈希值 确定元素位置 若该位置上有元素 就调用equals方法判断两个元素是否相同 若相同则不添加 若不同 则添加在前一个元素之后 形成链表结构

3、请简述TreeSet是如何保证元素唯一性与排序的？

两种方式:构造器不同
1.自然排序(升序排序)
	a.默认不写时 属于自然排序
	b.TreeSet所添加的元素或对象所在的类必须实现Comparable接口 否则无法自然排序
	  保证元素唯一是根据重写Comparable接口中的CompareTo方法 当返回0时表示两个元素相等 不重复存放

2.比较器排序(自定义排序)
	使用匿名内部类实现Comparator接口
	重写Comparator接口中Compare方法 当返回0时表示两个元素相等 不重复存放

4、请把今天讲解的方法在API中查找到，并使用自己的话进行描述

Set
	boolean add(E e) 
    集合中没有元素e时 添加元素e
    boolean addAll(Collection<? extends E> c) 
    集合中没有集合c中的元素时 将指定集合中的所有元素添加到该集合中。 
    void clear() 
    清空集合中的所有元素
    boolean remove(Object o) 
    删除一个元素o  
    boolean removeAll(Collection<?> c) 
    删除一个集合c中的所有元素(两个集合的交集元素)  
    boolean contains(Object o) 
    判断集合中是否有元素o
    boolean containsAll(Collection<?> c) 
    判断集合中是否有集合c的所有元素  
    boolean equals(Object o) 
    将集合中的两个元素进行比较
    boolean isEmpty() 
    判断集合是否为空  
    Iterator<E> iterator() 
    返回此集合中元素的迭代器。  
    default Spliterator<E> spliterator() 
    在这个集合中的元素创建一个 Spliterator。  
    boolean retainAll(Collection<?> c) 
    获取两个集合的交集元素  
    int size() 
    返回该集合中元素个数（其基数）。  
    int hashCode() 
    返回此元素的哈希码值 
    Object[] toArray() 
    返回一个包含此集合中所有元素的数组。  
    <T> T[] toArray(T[] a) 
    返回包含此集合中的所有元素的数组 返回的数组的运行时类型是指定的数组的运行时类型。  

HashSet 
    Object clone() 
    返回该 HashSet实例浅拷贝 元素本身不是克隆  

TreeSet
	TreeSet() 
    构造一个新的、空的树集，根据其元素的自然排序进行排序  
    TreeSet(Collection<? extends E> c) 
    构造一个新的树集包含在指定集合的元素，根据其元素的自然排序排序 
    TreeSet(Comparator<? super E> comparator) 
    构造一个新的、空的树集，根据指定的比较器进行排序  

B:看程序写结果(写出自己的分析理由)，程序填空，改错，看程序写结果。

class Student {
    private String name;
    private int age;
    public Student() {}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void show() {
        System.out.println(name + "..." + age);
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}

1、给出以下代码，请问该程序的运行结果是什么？如有问题，请说明原因。

学生类上面已给出Student

class Demo {
    public static void main (String[] args) {
        HashSet<Student> hs= new HashSet<Student>();
        hs.add( new Student("zhangsan", 19 ) );
        hs.add( new Student("zhangsan", 19 ) );
        hs.add( new Student("lisi", 20 ) );
        hs.add( new Student("wangwu", 22 ) );
        for (Student s : hs) {
            s.show();
        }
    }
}
/*
lisi...20
zhangsan...19
zhangsan...19
wangwu...22
在学生类里面没有重写HashCode() equals()方法
无法保证元素的唯一性
*/

2、给出以下代码，请问该程序的运行结果是什么？如有问题，请说明原因。

学生类上面已给出Student

class Demo {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<Student>();
        ts.add(new Student("zhangsan", 19));
        ts.add(new Student("zhangsan", 19));
        ts.add(new Student("lisi", 20));
        ts.add(new Student("wangwu", 22));
        for (Student s : ts) {
            s.show();
        }
    }
}
/*
默认是自然排序
自然排序需要Student类实现Comparable接口
重写CompareTo方法
*/

3、给出以下代码，请问该程序的运行结果是什么？如有问题，请说明原因。

学生类上面已给出Student

class Demo {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num1 = s1.getName().compareTo(s2.getName());
                int num2 = (num1 == 0) ? (s1.getAge() - s2.getAge()) : num1;
                return num2;
            }
        });
        ts.add(new Student("zhangsan", 19));
        ts.add(new Student("zhangsan", 19));
        ts.add(new Student("lisi", 20));
        ts.add(new Student("wangwu", 22));
        for (Student s : ts) {
            s.show();
        }
    }
}
/*
lisi...20
wangwu...22
zhangsan...19
*/

C:编程题

1、请编写程序，完成分包版本的登录注册案例

public class Homework01 {
    public static void main(String[] args) {
        //控制循环
        int count = 0;
        //创建数组 存储账号密码
        String[] strings = new String[2];
        //键盘录入
        Scanner sc = new Scanner(System.in);
        //功能展示
        gongNeng(count, strings, sc);
    }

    //功能展示
    private static void gongNeng(int count, String[] strings, Scanner sc) {
        while (count == 0) {
            System.out.println("======================");
            System.out.println("1.注册  2.登录  3.退出");
            System.out.println("输入 1/2/3 选择功能");
            System.out.println("======================");
            //key选择功能
            int key = sc.nextInt();
            if (key != 1 && key != 2 && key != 3) {
                System.out.println("功能选择有误 程序退出");
                break;
            }
            switch (key) {
                case 1:
                    zhuCe(sc,strings);
                    break;
                case 2:
                    dengLu(strings, sc);
                    break;
                case 3:
                    System.out.println("程序退出");
                    count = -1;
                    break;
            }
        }
    }
    
    //注册账号密码
    private static void zhuCe(Scanner sc,String[] strings) {
        //账号:6～12 个字符，可使用字母 数字 下划线 需要以字母开头
        String accountRegex = "[a-zA-Z]\\w{5,11}";
        //密码:6～18 个字符，可使用字母 数字 下划线 不能含有空格
        String passwdRegex = "\\w{6,18}";
        
        System.out.println("账号:6～12 个字符，可使用字母 数字 下划线 需要以字母开头");
        System.out.println("密码:6～18 个字符，可使用字母 数字 下划线 不能含有空格");
        System.out.println("输入账号");
        String zhangHao1 = sc.next();
        if (zhangHao1.matches(accountRegex) == true) {
            System.out.println("输入密码");
            String miMa1 = sc.next();

            if (miMa1.matches(passwdRegex) == true) {
                System.out.println("再次输入密码");
                String miMa2 = sc.next();

                if (miMa1.equals(miMa2)) {
                    System.out.println("注册成功");
                    strings[0] = zhangHao1;
                    strings[1] = miMa1;
                } else {
                    System.out.println("两次密码不一致");
                }

            } else {
                System.out.println("密码规则有误");
            }

        } else {
            System.out.println("账号规则有误");
        }
    }
    
    //登录
    private static void dengLu(String[] strings, Scanner sc) {
        System.out.println("输入账号");
        String zhangHao = sc.next();
        System.out.println("输入密码");
        String miMa = sc.next();
        if (zhangHao.equals(strings[0]) && miMa.equals(strings[1])){
            System.out.println("登录成功");
        }else {
            System.out.println("账号密码有误");
        }
    }
}

2、请编写程序，存储自定义对象到HashSet集合中，并遍历

public class Homework02 {
    public static void main(String[] args) {
        HashSet<Dog> hashSet = new HashSet<>();
        hashSet.add(new Dog("大黄", 2));
        hashSet.add(new Dog("小黄", 1));
        hashSet.add(new Dog("大白", 3));

        //遍历
        System.out.println("---迭代器---");
        Iterator<Dog> iterator = hashSet.iterator();
        while (iterator.hasNext()) {
            Dog dog = iterator.next();
            System.out.println(dog);
        }
        System.out.println("---增强for---");
        for (Dog dog : hashSet) {
            System.out.println(dog);
        }
        System.out.println("---forEach---");
        hashSet.forEach(new Consumer<Dog>() {
            @Override
            public void accept(Dog dog) {
                System.out.println(dog);
            }
        });
    }
}

class Dog {
    private String name;
    private int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3、请编写程序，存储自定义对象到TreeSet集合中，并遍历

a) 采用自然排序方式

b) 采用比较器排序方式

public class Homework03 {
    public static void main(String[] args) {
        //a.采用自然排序方式
        System.out.println("---自然排序---");
        TreeSet<Cat> treeSet1 = new TreeSet<>();
        treeSet1.add(new Cat("大花",3));
        treeSet1.add(new Cat("小花",1));
        treeSet1.add(new Cat("小喵",1));
        //遍历
        treeSet1.forEach(new Consumer<Cat>() {
            @Override
            public void accept(Cat cat) {
                System.out.println(cat);
            }
        });
        
        //b.采用比较器排序方式
        System.out.println("---比较器排序---");
        TreeSet<Cat> treeSet2 = new TreeSet<>(new Comparator<Cat>() {
            //根据年龄 然后名字排序
            @Override
            public int compare(Cat cat1, Cat cat2) {
                int i = cat1.getAge() - cat2.getAge();
                int j = i == 0 ? cat1.getName().compareTo(cat2.getName()) : i;
                return j;
            }
        });
        treeSet2.add(new Cat("大花",3));
        treeSet2.add(new Cat("小花",1));
        treeSet2.add(new Cat("小喵",1));
        //遍历
        treeSet2.forEach(new Consumer<Cat>() {
            @Override
            public void accept(Cat cat) {
                System.out.println(cat);
            }
        });
    }
}

class Cat implements Comparable<Cat> {
    private String name;
    private int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Cat cat) {
        //根据年龄 然后名字排序
        int i = this.age - cat.age;
        int j = i == 0 ? this.name.compareTo(cat.name) : i;
        return j;
    }
    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;
    }
}

4、请编写程序，完成键盘录入学生信息按照总分排序后输出在控制台，并测试

需求：键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)

按照总分从高到低输出到控制台

public class Homework04 {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        //录入信息
        entryInformation(students);
        //排序
        sort(students);
        //打印
        print(students);
    }
    /*序号 姓名 语文 数学 英语 总成绩
      1	  jies	100	90	90	 280
      2	  king	100	70	110	 280
      3	  wang	90	90	90	 270
      4	  jone	90	80	70	 240
      5	  gong	80	80	60	 220*/
    
    //录入信息
    private static void entryInformation(ArrayList<Student> students) {
        //录入学生信息
        Scanner sc = new Scanner(System.in);
        for (int i = 1; i <= 5; i++) {
            System.out.println("输入第" + i + "个学生名字");
            String name = sc.next();
            System.out.println("输入第" + i + "个学生语文成绩");
            int chinaScore = sc.nextInt();
            System.out.println("输入第" + i + "个学生数学成绩");
            int mathScore = sc.nextInt();
            System.out.println("输入第" + i + "个学生英语成绩");
            int englishScore = sc.nextInt();
            int score = chinaScore + mathScore + englishScore;
            students.add(new Student(name, chinaScore, mathScore, englishScore, score));
        }
    }
    
    //排序
    private static void sort(ArrayList<Student> students) {
        //排序
        students.sort(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //先比总分-语文成绩-数学成绩-英语成绩
                int num1 = s2.getScore() - s1.getScore();
                int num2 = num1 == 0 ? s2.getChinaScore() - s1.getChinaScore() : num1;
                int num3 = num2 == 0 ? s2.getMathScore() - s1.getMathScore() : num2;
                int num4 = num3 == 0 ? s2.getEnglishScore() - s1.getEnglishScore() : num3;
                return num4;
            }
        });
    }
    
    //打印
    private static void print(ArrayList<Student> students) {
        //遍历
        System.out.println("序号 姓名 语文 数学 英语 总成绩");
        students.forEach(new Consumer<Student>() {
            int count = 1;

            @Override
            public void accept(Student student) {
                System.out.println(count++ + "\t" + student);
            }
        });
    }
}

class Student {
    private String name;
    private int chinaScore;//语文成绩
    private int mathScore;//数学成绩
    private int englishScore;//英语成绩
    private int score;//总成绩
    public Student(String name, int chinaScore, int mathScore, int englishScore, int score) {
        this.name = name;
        this.chinaScore = chinaScore;
        this.mathScore = mathScore;
        this.englishScore = englishScore;
        this.score = score;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getChinaScore() {
        return chinaScore;
    }
    public void setChinaScore(int chinaScore) {
        this.chinaScore = chinaScore;
    }
    public int getMathScore() {
        return mathScore;
    }
    public void setMathScore(int mathScore) {
        this.mathScore = mathScore;
    }
    public int getEnglishScore() {
        return englishScore;
    }
    public void setEnglishScore(int englishScore) {
        this.englishScore = englishScore;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    @Override
    public String toString() {
        return name + "\t" +
                chinaScore + "\t" +
                mathScore + "\t" +
                englishScore + "\t" +
                score;
    }
}

5、请编写程序，产生10个1-100之间的随机数要求随机数不能重复，并测试

需求：编写一个程序，获取10个1至100的随机数

​ 要求随机数不能重复，并把最终的随机数输出到控制台。

public class Homework05 {
    public static void main(String[] args) {
        //产生10个1-100之间的随机数要求随机数不能重复
        HashSet<Integer> hashSet = new HashSet<>();
        Random random = new Random();
        while (true) {
            int i = random.nextInt(100) + 1;
            hashSet.add(i);
            if (hashSet.size() == 10) {
                break;
            }
        }
        System.out.println(hashSet);
        //[96, 48, 49, 67, 99, 54, 41, 57, 43, 31]
    }
}