[PHP知识库]2021.09.19

Java面向对象：

• 重点：
  拆箱与装箱 接口与抽象类的区别 多态机制 重载与重写的区别 Java跨平台原理 接口与抽象类的区别 Java两种核心机制

Java多线程：

• 重点：
  并行与并发的区别 为什么使用多线程 线程的阻塞 线程池

面向对象与面向过程的区别：

一个是按步骤分块，一个是按功能分块
就拿五子棋游戏举例子：
面向过程是分析问题的步骤：开始游戏，黑子先走，绘制画面，判断输赢，轮到白子，绘制画面，判断输赢…如此循环
面向对象设计思想解决问题涉及到功能分区，黑白双方，棋盘系统，规则系统

高内聚低耦合：

遍历Map集合两种方法：

package du;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class d699 {
    public static void main(String[] args) {
        HashMap<String,Integer> hm = new HashMap<>();

        hm.put("&#21334",8080);
        hm.put("&#21335",8081);
        hm.put("&#21336",8082);

        /*
        利用foreach遍历
        拿到的set是一个数组
        但不包含value值 [&#21336, &#21334, &#21335]
         */
        Set<String> set = hm.keySet();
        for (String string : set){
            System.out.println(string);
            System.out.println(hm.get(string));
        }
        System.out.println(set);
        System.out.println();
        System.out.println();
        /*
        将Map集合全部转换成Map集合
        调用entrySet方法
        返回的是一个数组 [&#21336=8082, &#21334=8080, &#21335=8081]

        foreach遍历
        每一次取出的是Node
        Node类有方法
        getKey()
        getValue()

        该方式效率较高
        因为把key和value放一起了
        不用从哈希表里面找元素
        适合大数据量情况
         */
        Set<Map.Entry<String, Integer>> entries = hm.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
        System.out.println(entries);
    }
}

哈希表数据结构概述：

package du;

public class d700 {
    /*
    哈希表/散列表数据结构
    哈希表是数组和单向链表的结合体
    数组随机增删效率低 单向链表查询效率低
    哈希表把以上两种数据结构融合在一起 充分利用他们各自的优点

    是一个数组
    数组中每一个元素都是单向链表
     */
}

/*
class HashMap{
    // HashMap底层就是一个数组
    Node<K,V> table;

    static class Node<K,V>{

        // 哈希值
        // key调用hashcode()的执行结果
        // 哈希值通过函数或算法可以转换成数组的下标）

        final int hash;
        final K key;
        V value;

        // 下一个节点的内存地址

        Node<K,V> next;
    }
}
*/

哈希表数据结构存取值操作原理：

package du;

public class d701 {
    public static void main(String[] args) {
        /*
        map.push(k,v); 实现原理
            1. 先将k,v封装到Node对象当中
            2. 底层调用k的hashcode()得到hash值
            3. 通过哈希函数/哈希算法，将hash值转换成数组的下标
            4. 下标位置上如果没有任何元素，就把Node添加到这个位置上
            5. 如果下标上有Node，就把k用equals方法与链表上的k逐一比较，
               如果都为false，则新的Node会被添加到链表的末尾
            6. 如果有一个equals返回了true，那么这个节点的value将会被覆盖
         */

        /*
        map.get(k); 实现原理
        1. 调用k的hashcode()方法得到哈希值，通过哈希算法得到数组下标，通过数组下标快速定位
        2. 如果这个节点上什么也没有，返回null
        3. 如果下标上有Node，就把k用equals方法与链表上的k逐一比较
        4. 如果都为false，则返回null
        5. 如果有一个equals返回了true，那么返回这个节点的value
         */

        /*
        为什么哈希表的随机增删和查询效率都很高
            增删是在链表上完成的 但没有纯链表的效率高
            查询也不需要扫描，只需要扫描其中一个 但没有纯数组的效率高
         */

        /*
        HashMap上的equals方法需要重写 因为要比较内容而非地址
        否则调用的就会是Object上的equals方法

        hashcode()方法同样需要重写

         */

        /*
        注意：
        同一个单向链表上的所有节点hashcode相同，
        因为他们数组下标是一样的，
        但同一个链表k和k的equals方法返回的都是false

        所以如果所有的节点hashcode相同，
        哈希表就是一个纯单向链表
        这种情况成为散列分布不均匀

        所有节点返回的hashcode都不一样
        就变成了纯数组
         */
    }
}