day14

Set

HashSet:Set集合的子类

    底层数据结构是哈希表，查找速度快，且元素唯一
    HashSet中的add方法实际上调用的是HashMap中的put方法
    底层和元素的hashCode方法值有关
    我们发现，底层判断待插入的元素是否已经存在哈希表中的方式是：
    将待插入的元素的哈希值与已经存储在哈希表中元素哈希值进行比较，
    然后再调用待插入的元素的equals方法比较已经存储在哈希表中元素。
    若哈希值一样，且equals结果为true，就表示这两个元素是同一个元素，不做添加

结论：
    若想要使用HashSet对元素进行去重，需要元素类型本身重写hashCode方法和equals方法。

LinkedHashSet：HashSet的子类

底层数据结构是哈希表和双链表。哈希表保证元素唯一，双链表保证元素有序，元素唯一

Collection:

        List:
        Set:
            HashSet:
                - LinkedHashSet:
            TreeSet: 底层数据结构是红黑树（自平衡二叉树），具备了可预测的排序
                - 自然排序
                - 比较器排序

TreeSet中的add方法实际上是调用了TreeMap中的put方法
要想使用TreeSet集合存储自定义对象且使用的是无参构造方法创建TreeSet集合对象的话，
    需要元素类型实现Comparable<元素类型>接口,实现compareTo方法
    compareTo方法根据需求来定制

使用比较器排序

有参构造方法
public static void main(String[] args) {
        //使用比较器排序，按照年龄从小到大排序
        //    public TreeSet(Comparator<? super E> comparator) {
        //        this(new TreeMap<>(comparator));
        //    }
        TreeSet<Cat> set1 = new TreeSet<>(new Comparator<Cat>() {
            @Override
            public int compare(Cat o1, Cat o2) {
                // o1是待插入的元素
                // o2是要比较的根元素
                int i1 = o1.getAge() - o2.getAge();
                return (i1 == 0) ? o1.getName().compareTo(o2.getName()) : i1;
            }  
});

自然排序

无参构造方法需要元素类型实现Comparable<元素类型>接口,实现compareTo方法
compareTo方法根据需求来定制
public class Teacher implements Comparable<Teacher>{
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(String name, int age) {
        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 String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Teacher o) {
        //cmp = k.compareTo(t.key);
        // this - 待插入元素
        // o - 要比较的根元素
        //当姓名和年龄一样的时候去重，年龄需要从小到大排序
//        return this.age - o.getAge();
        //显式条件
        int i1 = this.age - o.getAge();
        //隐式条件
        //当年龄一样的时候，姓名不一定一样
        return (i1==0)?this.name.compareTo(o.name):i1;
    }
}

Map

Map集合：元素是键值对构成的

    Map特点：
        1、在同一个Map集合中，键是唯一的
        2、在同一个Map集合中，值可以发生重复
        3、一对键值，表示Map集合中的一个元素


    Map集合中的方法：
        V put(K key,V value)  向集合中添加一对元素  返回键原本的旧值
        V remove(Object key)  根据键移除一个键值对
        void clear()  清空
        boolean containsKey(Object key)  判断键是否存在
        boolean containsValue(Object value)  判断值是否存在
        boolean isEmpty()  判断Map集合中是否有键值对
        int size()  返回Map集合中键值对的元素个数
        V get(Object key)  根据键获取值
        Set<K> keySet()  获取所有的键
        Collection<V> values()  获取所有的值
        Set<Map.Entry<K,V>> entrySet() 获取所有键值对

增强for循环

/*
    增强for循环：是用来替代迭代器的，只能遍历数组以及Collection集合
    语句定义格式：
        for(元素的类型 变量名 : 数组|Collection集合){
            直接使用变量名相当于使用元素;
        }
 */

遍历

// 方式1：获取所有的键，遍历键，根据键获取值
//        Set<Integer> keySet = map1.keySet();
//        for (Integer key : keySet) {
//            String value = map1.get(key);
//            System.out.println(key + "-" + value);
//        }

        // 方式2：直接获取所有的键值对，遍历每一个键值对得到每一个键和值
        //Set<Map.Entry<K,V>> entrySet()
        Set<Map.Entry<Integer, String>> entries = map1.entrySet();
        for (Map.Entry<Integer, String> entry : entries) {
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + ":" + value);
        }

HashMap

import java.util.HashMap;

/*
    HashMap<Student3,String>

    Map的唯一性指的是键的唯一性，HashMap中需要键的类型要重写hashCode()方法和equals方法

 */
public class HashMapDemo1 {
    public static void main(String[] args) {
        HashMap<Student3, String> map1 = new HashMap<>();

        Student3 s1 = new Student3("李刚", 21);
        Student3 s2 = new Student3("钱志强", 22);
        Student3 s3 = new Student3("江川", 21);
        Student3 s4 = new Student3("李刚", 21);
        Student3 s5 = new Student3("吴问强", 23);

        map1.put(s1, "打羽毛球");
        map1.put(s2, "唱");
        map1.put(s3, "跳");
        map1.put(s4, "看美女");
        map1.put(s5, "打游戏");

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


    }
}

可变参数

import java.util.Arrays;
import java.util.List;

public class KeBianCanShuDemo {
    public static void main(String[] args) {
        //需求1：求两个int类型的数之和
        int a = 3;
        int b = 4;
        sum(a, b);

        //需求2：求三个int类型的数之和
        int c = 5;
        sum(a, b, c);

        //需求3：求四个int类型的数之和
        int d = 6;
        sum(a, b, c, d);

        int e = 7;
        sum(a,b,c,d,e);

        //需求：传入一个人的姓名和若干门考试成绩，求这个人的总分
        getSumScoreWithName("李刚",98,99,100);
        getSumScoreWithName("钱志强",78,88);
//        getSumScoreWithName2(78,88,"钱志强");

        //可变参数的应用
        //Arrays工具类中有一个方法是将传入的参数封装成一个List集合
        List<Integer> list = Arrays.asList(11, 22, 33, 44, 55); // ArrayList

    }

    //可变参数只能在最后一个参数定义出来
//    public static void getSumScoreWithName2(int... arr,String name) {
//        int sum = 0;
//        for (int i : arr) {
//            sum+=i;
//        }
//        System.out.println(name+"总分为："+sum);
//    }


    public static void getSumScoreWithName(String name,int... arr) {
        int sum = 0;
        for (int i : arr) {
            sum+=i;
        }
        System.out.println(name+"总分为："+sum);
    }

    public static void sum(int... arr) {
        int sum = 0;
        for (int i : arr) {
            sum+=i;
        }
        System.out.println(sum);
    }

//    public static void sum(int a, int b) {
//        System.out.println(a + b);
//    }
//
//    public static void sum(int a, int b, int c) {
//        System.out.println(a + b + c);
//    }
//
//    public static void sum(int a, int b, int c, int d) {
//        System.out.println(a + b + c + d);
//    }

}