Java学习 day32_Queue&Map

Queue

1.1 特点

1, Queue接口是Collection一个子接口, 描述的数据结构是队列
2, Queue存储元素是有序
3, Queue 允许存储重复元素
4, Queue 不允许存储null元素( LinkedList除外)

Queue的删除操作, 是以返回一个null值作为 标记, 标记没有元素存储了

1.2 API

1.2.1 注意

1, 如果Queue存储元素的时候, 没有位置/空间 可以存储了, 如果使用add方法抛出异常, 如果使用offer返回布尔值 假
2, 如果Queue存储元素,没有存储任何内容/里面是空的 如果使用remove方法抛出异常, 如果使用poll 会返回null
3, 如果Queue存储元素,没有存储任何内容/里面是空的 如果使用element方法抛出异常, 如果使用peek会返回null

2 Deque

2.1 特点

1, Deque接口是Queue接口的一个子接口
2, Deque描述的数据结构是: 双端队列, 普通队列, 栈
3, 有序
4, 允许重复元素
5, 不允许存储null ( LinkedList除外)

2.2 API

api很多，自己看文档

3 ArrayQueue

1, ArrayDeque 是Deque接口的一个具体子实现
2, ArrayDeque描述的数据结构是: 普通队列, 双端队列, 栈
3, 底层是个数组: 循环数组
4, 默认的初始容量16 , 扩容机制2倍 --> 底层数组长度是2的幂值
5, 有序
6, 允许存储重复元素
7, 不允许存储null
8, 线程不安全
9, 在给定长度的构造方法里, 如果我们给定一个长度是小于8的话底层数组创建一个长度为8的数组, 如果给定的值大于等于8 , 那么这个被创建的底层数组的长度是大于给定值的最小的2的幂值 --> 底层数组长度是2的幂值 (比较方便于用位运算取模, 计算速度更快)
注意：如果给了16，那创建的数组长度是32

循环数组的好处, 不需要在每次删除之后, 移动n-1个元素, 仅需要移动头标记

3.2 构造方法

4 BlockingQueue: 阻塞队列

什么是阻塞队列:
如果队列的大小是一定的, 当队列存满的时候, 添加线程阻塞,
当队列为空的时候, 删除线程阻塞

4.1 特点

阻塞队列
有一些阻塞方法
阻塞队列, 要求有大小

public static void main(String[] args) throws InterruptedException {

        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(3);
        queue.add("zs");
        queue.add("ls");
        queue.add("wu");

        // 容量只有3，这时使用put添加就会导致阻塞
        queue.put("zl");
    }

public class Demo01 {
    public static void main(String[] args) throws InterruptedException {

        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(3);
        queue.add("zs");
        queue.add("ls");
        queue.add("wu");

        Mythread mythread = new Mythread(queue);
        mythread.start();  // 这一步要放在前面，不然你阻塞了，后面的代码运行不到

        // 容量只有3，这时使用put添加就会导致阻塞
        queue.put("zl");



    }
}

class Mythread extends Thread{


    ArrayBlockingQueue<String> queue;

    public Mythread(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        queue.remove();

    }
}

阻塞队列：如果队列的大小是一定的，当队列存满的的时候，添加线程阻塞，当队列为空的时候，删除线程阻塞

阻塞队列一般用于生产者消费者模式，只能这么执行多任务，如果要进来就必须等我完成任务，比如分布式服务器之间通信，一个服务器可以一直发，但接收的服务器维护阻塞队列来接收，避免数据过大导致服务器瘫痪

阻塞队列构造方法要求有大小，不然自己扩容就失去阻塞的意义了

5 Map

Java集合类分为两套集合体系, 一个Collection 一个是Map
Collection存储的是单个元素
Map 存储的是Key-Value数据/ 键值对

在网页上下载东西的过程，其实就是通过key获得一个value

5.1 Map的特点

1, Map集合体系的顶级接口
2, 存储的是key-value数据 (我们在研究Map下的集合类的时候, 关注的核心点在key上)
3, 有的子实现key是有序的, 有的子实现key是无序的,
4, key是不允许重复的(重复的定义不一样, hashMap不允许存储哈希值相同的)
5, 有的子实现key允许存储null, 有的子实现key是不允许存储null

5.2 API

 public static void main(String[] args) {
        Map<String, String> map = new LinkedHashMap<>();

        map.put("zs", "13");
        map.put("ls", "14");
        map.put("wu", "15");

        //System.out.println(map);

        /*

        // 是视图方法，如果改动set会反映到原map中
        Collection set = map.keySet();
        System.out.println(set);


        set.remove("ls");

        */


        /*
        // value()也是视图方法，会对原来的map产生影响
        Collection values = map.values();

        values.remove("13");
        System.out.println(values);

        System.out.println(map);
        */

        // 视图  返回成对的key-value数据
        // 关于Map.Entry<K,V>，是Map接口的内部接口：
        Collection<Map.Entry<String, String>> collection = map.entrySet();
        for (Map.Entry<String, String> entry : collection) {
            //System.out.println(entry);

            System.out.println(entry.getKey() + "  " + entry.getValue());
        }

    }

6 HashMap: 重点, 必问

补充一下：
无符号右移：>>>
右移：>>

6.1 HashMap的结构

数组 + 链表 + 红黑树

常问点：HashMap和HashTable的区别，到时候我再补充

6.2 特点

HashMap的时间复杂度可以达到O(1)

• 1, HashMap是Map接口一个具体实现
• 2, HashMap的底层结构是 数组 + 链表 + 红黑树 (红黑树是jdk1.8版本新加的结构)
• 3, 数组的默认初始长度 16(第一添加元素产生长度为16，如果只定义一个HashMap不添加元素，底层数组不初始化，开始添加元素才初始化),数组的扩容机制(扩为原来的2倍) --> 数组长度必定2的幂值 --> 位运算
• 4, HashMap存储key是无序的，而且这个顺序会动态变化
• 5, HashMap不允许存储重复的key值 , 对于HashMap 的key的重复定义是什么? ：
• 6, HashMap允许存户 null 键，对应的hash值为0
• 7, HashMap线程不安全
• 8, HashMap的默认加载因子是0.75(我们也可以在构造方法中传入加载因子, 建议在0.5-1之间)
  什么是加载因子? 饱和度
  数组存储元素(key-value数据)到一定容量的时候, 就会扩容数组, 以避免链表和红黑树过多/过长导致存储效率降低
  扩容的阈值 = 加载因子 * 数组长度， 不是说在数组中存了阈值个位置就扩容，而是包含所有链表红黑树元素超过阈值就扩容，用空间换时间
  
  
  假如:
  数组长度 16
  默认加载因子 0.75
  阈值: 12（第13个往里存的时候就会扩容）

  注意: HashMap是怎么存储key-value数据的
  1, HashMap在存储一份key-value数据的时候, 先把key取出来, 计算
  2, key 经过计算, 得到一个 int类型 hash值
  3, 把这个经过计算的hash值和HashMap的数组长度取模, 得到下标
  4, 如果这个下标位置, 没有元素, 把这份key-value数据, 存到这个下标位置(存储的是一个结点类型, 这个结点类型里面包含key, value …)
  5, 如果这个下标位置, 已经存储了结点, 判断key值和这个下标位置的这些已经存在结点中的key值是否重复, 如果重复不添加, 如果不重复, 添加到这个位置(链表的尾部)
  6, 如果链表过长, 把链表转化为红黑树

注意: 从单纯的数学领域(当下), hash
Hash算法
MD4
MD5: 王小云
SHA1:
SHA2
····

• 9, HashMap中 hash值的计算:
  Hash = (h = key.hashCode()) ^ (h >>> 16);
  （key.hashCode()调用的是Object自带的hashCode方法）
  从主观上, 我们希望每一个key都可以散列到数组的不同位置, 实际上是没有办法保证的
  实际上在我们hash值取下标(和数组长度取模)的过程中, 只有hash值的低位才会有用, 也就意味着,我们最终在hashmap中数组上所散列的位置依赖于 hash的低位
  所以h >>> 16位的原因是因为, 希望高位数也能参加到取模运算中来, 已达到充分散列的效果(希望)
  1010101010110
  0000000101010
• 10, 如果我们在构造方法里给定一个长度, 那么HashMap会创建一个底层数组长度大于等于给定值的最小的2的幂值的一个数组
  10 -> 16
  16 -> 16
  20 -> 32
  (ArrayDeque是产生大于, 而非大于等于，给16会创建32)
• 11, 我们存储到数组位置的key-value数据, 实际上数组存储的是一个Node类型的结点, 这个Node类型包含四个参数: hash, key, value, next
• 12, 在HashMap中判断key重复的判断条件:
  判断两个要比较的key-value数据的key的hash值是否一样, 如果hash值一样, 会进一步判断, key值是否直接相等或者相equals

// 即使很幸运通过两个对象的hash值算出下标是一样的，也必须先判断hash值，再看key值是否相同
// 所以没有重写hashCode，只要对象地址值不一样，就会被看成两个元素
p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))

• 13, 也就意味着, 如果我们用一个普通的java对象来充当key的时候, 我们希望比较的是这个对象里面的存储的内容, 那么要根据这个对象里面的参数重写hashCode 和 equals方法(仅重写equals是不行的)
  如果两个key的hashCode一样 并且 两个对象相equals, 那么对于hashmap来说这两个key就是重复的
  Eg: 如下: 如果我们希望这两个User对象被hashmap看做是同一个key值的话, 需要重写User类型的hashCode 和 equals方法, (按照 name和age重写)

public class Demo {
    public static void main(String[] args) {
        HashMap<User, String> map = new HashMap<>();

        // 二者的地址不相等，但内容相等
        map.put(new User("zs", 18), "20");
        map.put(new User("zs", 18), "20");
        System.out.println(map); // 此时map中只有一对元素
    }
}

class User{
    String name;
    int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age &&
                Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

• 14, 如果要存储的key-value数据, 这个key值已经在HashMap上存在, 那么我们会用新的这份key-value数据的value来覆盖已经存储到HashMap上的(已经存储的重复的)key-value的value值 (key值不会覆盖）

        map.put(new User("zs", 18), "20");
        map.put(new User("zs", 18), "90");
        System.out.println(map); // {User{name='zs', age=18}=90}

• 15, 在HashMap存储中, 如果多个key-value数据散列到同一个下标位置, key值也不重复, 那么这个位置就会构建出一个单链表, 如果单链表过长, 那么这个链表要转化为红黑树.
  过长意味着: 链表长度超过8达到9的时候
  (算上新添加的结点)
• 16, 在HashMap中, 某一个数组位置链表长度超过8达到9的时候, 一定会转化为红黑树吗?
  不一定,
  // 有两个选择
  // 如果底层数组长度是小于64的, 那么我们会对底层数组扩容
  // 如果底层数组长度是大于等于64的, 会对链表进行转化转化成红黑树

扩容,
key-value的hash是不变的, hash来源于key的hashCode
数组长度变了
取模结果变化 --> 存储位置有可能变化

• 17, 如果一个key-value数据, 原本在下标为x的位置, 当发生扩容的时候, 他只可能重新散列到两个位置: (原因是因为数组长度是2的幂值)
  原本的x位置
  X + 旧长度的位置

Eg: 数组长度16
原本 3
扩容 : 数组长度 32
这个元素: 3, 19

–

• 18, 红黑树什么时候转化会链表?
  有两种情况, 会导致红黑树转化会链表
  1, 删除元素的时候(删除的是红黑树上的元素),
  2, 在扩容的时候, 有可能会导致红黑树转化回链表(扩容会把一个元素位置的数据拆成两个位置)

删除的时候判断逻辑(红黑树 --> 链表)
根节点, 根节点的左右子结点, 根节点的左节点的左节点, 这个四个结点只要有一个是null, 那么就会在删除操作的时候, 把红黑树转化为链表

if (root == null || root.right == null ||
    (rl = root.left) == null || rl.left == null) {
    tab[index] = first.untreeify(map);  // too small
    return;
}

扩容的时候判断逻辑(红黑树 --> 链表)
由于扩容的时候, 红黑树的结点会散列成两部分(旧位置, 旧位置+旧长度), 这两部分经过散列之后, 任一个位置的key-value数据是小于等于6的话, 就要由红黑树转化回链表

• 19, 存储到红黑树(特殊的二叉搜索树) 是要能比较大小, 在hashmap的红黑树中,怎么比较key值的大小那, 就是通过key值的hash比较大小(int)

–

• 20, 已经存储到HashMap中的key-value数据, 不要通过引用来修改key值
  (可以先删除, 再重新添加)

6.3 构造方法

6.4 API

一点补充

前后端不分离：服务器要把数据和前端合并，服务器压力大

前后端分离：浏览器先去从前端服务器获取前端框架，前端代码会告诉你数据的位置在哪里，然后再从别的服务器那数据将前端填充，用户来完成前端和后端数据的合并，但是这样浏览器的消耗会相对大一点

key-value数据有自我描述性，在网络传输中适用