day18

day18

一、Map的常见子类

HashMap
LinkedHashMap

1.1 HashMap

基于哈希表的 Map 接口的实现。

可以存储null键和null值。

不同步，不安全，效率高

构造方法

HashMap() 		构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap

public class Demo {

    public static void main(String[] args) {

        HashMap<String, String> hs = new HashMap<>();

        hs.put("9527", "华安");
        hs.put(null, "张三");
        hs.put("9528", null);

        System.out.println(hs);     //{null=张三, 9528=null, 9527=华安}
        System.out.println("----------------");
        hs.put(null, "李四");
        System.out.println(hs);

    }
}

HashMap键的唯一性

<String, Person>
<Person, String>
<Integer, String>

1. 官方定义好的类，可以保证去重效果
2. 自定义的类，不能保证去重效果
        如何才能去重呢？
        重写equals和hashCode方法即可。
        
注意：之前学习的HashSet实际上就是HashMap的键组成的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GBV65npO-1620344986948)(img/image-20210428103830626.png)]

HashMap是如何扩容的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WRS5HKRR-1620344986950)(img/HashSet(HashMap)]是如何存储存储数据的.jpg)

1. 默认容量是16，并且以后扩容的时候都必须得是2的倍数（也就是：16 32 64 ...）
2. 加载因子：就是决定在使用多少容量后就开始扩容（也就是在将容量用完之前就提前扩容）。 
		2.1 比如原来的容量是16，总不可能用到16才扩容（因为万一在16后面我们添加了大量的数据，那么就不够用，所以我们应该提前就创建好够用的容量）。
		2.2 目前加载因子默认是0.75。默认容量为16，那么16*0.75=12。也就是虽然目前容量是16，但是用到12个容量的时候，就会进行扩容为16*2=32。 下一次用到32*0.75=24的时候就会扩容，依次类推 
	
3. 在Java8中：
		如果一条链表中元素的个数达到TREEIFY_THRESHOLD(默认是8)，并且table的长度大于MIN_TREEIFY_CAPACITY(默认是64)，就会将链表转为红黑树（因为这样使用效率更高）。
		如果一条链表中元素的个数达到TREEIFY_THRESHOLD(默认是8)，并且table的长度小于MIN_TREEIFY_CAPACITY(默认是64)，那么链表并不会转为红黑树，而是将数组扩大2倍（并且是每添加一次就扩大2倍），直到数组长度达到64（此时链表就可以转为红黑树了），也就达到了效率最佳

/*
	探究加载因子和扩容的代码：  
 */
 package com.ujiuye.demo01_HashMap;

import java.util.HashMap;

class Dog {

    int age;

    public Dog(int age){
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Dog dog = (Dog) o;

        return age == dog.age;
    }

    @Override
    public int hashCode() {
        return age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                '}';
    }
}

public class Demo6 {

    public static void main(String[] args) {

        HashMap<Dog, String> hm = new HashMap<>();

        for(int i = 1; i <= 26; i++){

            hm.put(new Dog(i), "hello");
        }

    }
}

/*
	探究链表是如何转为红黑树的，及此期间容量的变量规律：
 */
 package com.ujiuye.demo01_HashMap;

import java.util.HashMap;

class Cat {

    int age;

    public Cat(int age){

        this.age = age;
    }

    @Override
    public int hashCode() {

        //重写hashCode方法，并且固定返回值。
        //那么所有Cat对象都会有一个相同的hashCode，所以这些对象都会存到同一个索引下面，形成一个链表
        return 666;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "age=" + age +
                '}';
    }
}

public class Demo5 {

    public static void main(String[] args) {

        HashMap<Cat, String> hm = new HashMap<>();

        for(int i = 1; i <= 12; i++){

            hm.put(new Cat(i), "hello");
        }

    }
}

1.2 LinkedHashMap

可以保证插入元素的有序性。

不同步，不安全，效率高

构造方法

LinkedHashMap() 	构造一个带默认初始容量 (16) 和加载因子 (0.75) 的空插入顺序 LinkedHashMap 实例

public class Demo {

    public static void main(String[] args) {

        LinkedHashMap<String, String> lhm = new LinkedHashMap<>();

        lhm.put("hello", "world");
        lhm.put("ted", "neo");
        lhm.put("himym", "ram");

        System.out.println(lhm);        //{hello=world, ted=neo, himym=ram}
    }
}

二、Collections工具类

2.1 可变参数

就是长度可变的参数。

可以代表0个或者多个参数

格式

数据类型... 变量名

注意

1. 可变参数实际上就是一个数组，变量名就是数组名
2. 可变参数只能放在所有参数的最后面
3. 一个方法只能同时使用一个可变参数

public class Demo {

    public static void main(String[] args) {

//        sum();  //0
        sum(1, 3, 5);   //9

    }

    public static void sum(int... a){

        int total = 0;

        for(int i = 0; i < a.length; i++){

            total += a[i];
        }

        System.out.println(total);
    }

}

2.2 Collections类

有很多操作集合的方法。

常见方法

static <T> boolean addAll(Collection<? super T> c, T... elements)  		
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 
static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) 
static void reverse(List<?> list)  
static <T extends Comparable<? super T>> void sort(List<T> list)  
static <T> void sort(List<T> list, Comparator<? super T> c) 
static <T> Comparator<T> reverseOrder() 
static void shuffle(List<?> list)  

public class Demo2 {

    public static void main(String[] args) {

        ArrayList<Integer> al = new ArrayList<>();

        al.add(11);
        al.add(66);
        al.add(33);
        al.add(22);
        al.add(99);

        System.out.println(al);     //[11, 66, 33, 22, 99]

        //static <T> boolean addAll(Collection<? super T> c, T... elements)
        Collections.addAll(al, 100, 200, 300);
        System.out.println(al);

        //static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
//        System.out.println(Collections.max(al));        //99

        //static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
//        System.out.println(Collections.min(al));        //11

        //static void reverse(List<?> list)
//        Collections.reverse(al);
//        System.out.println(al);    //[99, 22, 33, 66, 11]

        //static <T extends Comparable<? super T>> void sort(List<T> list)
//        Collections.sort(al);
//        System.out.println(al);      //[11, 22, 33, 66, 99]

        //static <T> void sort(List<T> list, Comparator<? super T> c)
//        Collections.sort(al, Collections.reverseOrder());
//        System.out.println(al);         //[99, 66, 33, 22, 11]

        //static void shuffle(List<?> list)
//        Collections.shuffle(al);
//        System.out.println(al);

    }
}

三、学生管理系统

详见附录笔记

// Collections.sort(al, Collections.reverseOrder());
// System.out.println(al); //[99, 66, 33, 22, 11]

    //static void shuffle(List<?> list)

// Collections.shuffle(al);
// System.out.println(al);

}

}

### 三、学生管理系统

详见附录笔记