复习 | 随记

HashMap简介 #

HashMap用来存放键值对，基于哈希表的Map接口实现，是非线程安全的
可以存储null的key和value，但null作为键只能有一个
JDK8之前，HashMap由数组和链表组成，链表是为了解决哈希冲突而存在；JDK8之后，当链表大于阈值（默认8），则会选择转为红黑树（当数组长度大于64则进行转换，否则只是扩容），以减少搜索时间
HashMap默认初始化大小为16，每次扩容为原容量2倍，且总是使用2的幂作为哈希表的大小

底层数据结构分析 #

JDK8之前，HashMap底层是数组和链表，即链表散列；通过key的hashCode，经过扰动函数，获得hash值，然后再通过(n-1) & hash 判断当前元素存放位置（n指的是数组长度），如果当前位置存在元素，就判断元素与要存入的元素的hash值以及key是否相同，相同则覆盖，否则通过拉链法解决
ly-20241212141931350

扰动函数，即hash(Object key)方法

//JDK1.8  
static final int hash(Object key) {
      int h;
      // key.hashCode()：返回散列值也就是hashcode
      // ^ ：按位异或
      // >>>:无符号右移，忽略符号位，空位都以0补齐
      return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }

JDK1.7

//JDK1.7 , 则扰动了4次，性能较差
static int hash(int h) {
    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).

    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

JDK1.8之后，当链表长度大于阈值（默认为 8）时，会首先调用 treeifyBin()方法。这个方法会根据 HashMap 数组来决定是否转换为红黑树。只有当数组长度大于或者等于 64 的情况下，才会执行转换红黑树操作，以减少搜索时间。否则，就是只是执行 resize() 方法对数组扩容。相关源码这里就不贴了，重点关注 treeifyBin()方法即可！
...

ArrayList源码

2022年10月20日 17:01 周四

简介 #

底层是数组队列，相当于动态数组，能动态增长，可以在添加大量元素前先使用ensureCapacity来增加ArrayList容量，减少递增式再分配的数量 源码：
```
public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ }
```
1. Random Access，标志接口，表明这个接口的List集合支持快速随机访问，这里是指可通过元素序号快速访问
2. 实现Cloneable接口，能被克隆
3. 实现java.io.Serializable，支持序列化
ArrayList和Vector区别
- ArrayList和Vector都是List的实现类，Vector出现的比较早，底层都是Object[] 存储
- ArrayList线程不安全（适合频繁查找，线程不安全）
- Vector 线程安全的
ArrayList与LinkedList区别
- 都是不同步的，即不保证线程安全
- ArrayList底层为Object数组；LinkedList底层使用双向链表数据结构(1.6之前为循环链表，1.7取消了循环)
- 插入和删除是否受元素位置影响
  - ArrayList采用数组存储，所以插入和删除元素的时间复杂度受元素位置影响[ 默认增加到末尾，O(1) ; 在指定位置，则O(n) , 要往后移动]
  - LinkedList采用链表存储，所以对于add(E e)方法，还是O(1)；如果是在指定位置插入和删除，则为O(n) 因为需要遍历将指针移动到指定位置
```
//LinkedList默认添加到最后
public boolean add(E e) {
        linkLast(e);
        return true;
}
```
  - LinkedList不支持高效随机元素访问，而ArrayList支持（通过get(int index))
  - 内存空间占用 ArrayList的空间浪费主要体现在list列表的结尾会预留一定的容量空间，而LinkedList的空间花费在，每个元素都需要比ArrayList更多空间（要存放直接前驱和直接后继以及(当前)数据)

3. 扩容机制分析 ( JDK8 ) #

ArrayList的构造函数

三种方式初始化，构造方法源码
空参，指定大小，指定集合（如果集合类型非Object[].class，则使用Arrays.copyOf转为Object[].class)
以无参构造方式创建ArrayList时，实际上初始化赋值的是空数组；当真正操作时才分配容量，即添加第一个元素时扩容为10


 /**
     * 默认初始容量大小
     */
    private static final int DEFAULT_CAPACITY = 10;


    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     *默认构造函数，使用初始容量10构造一个空列表(无参数构造)
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 带初始容量参数的构造函数。（用户自己指定容量）
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {//初始容量大于0
            //创建initialCapacity大小的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {//初始容量等于0
            //创建空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {//初始容量小于0，抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }


   /**
    *构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
    *如果指定的集合为null，throws NullPointerException。
    */
     public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

以无参构造参数函数为例 先看下面的 add()方法扩容
...

集合使用注意事项

2022年10月19日 17:26 周三

集合判空 #

isEmpty()可读性更好，且绝大部分情况下时间复杂度为O(1)

有例外：ConcurrentHashMap的size()和isEmpty() 时间复杂度均不是O(1)

public int size() {
    long n = sumCount();
    return ((n < 0L) ? 0 :
            (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
            (int)n);
}
final long sumCount() {
    CounterCell[] as = counterCells; CounterCell a;
    long sum = baseCount;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}
public boolean isEmpty() {
    return sumCount() <= 0L; // ignore transient negative values
}

集合转Map #

集合_2

2022年10月18日 08:54 周二

Map #

HashMap和Hashtable的区别

HashMap是非线程安全的，Hashtable是线程安全的，因为Hashtable内部方法都经过synchronized修饰（不过要保证线程安全一般用ConcurrentHashMap）
由于加了synchronized修饰，HashTable效率没有HashMap高
HashMap可以存储null的key和value，但null作为键只能有一个**；HashTable不允许有null键和null值**
初始容量及每次扩容
- Hashtable默认初始大小11，之后扩容为2n+1;HashMap初始大小16，之后扩容变为原来的2倍
- 如果指定初始大小，HashTable直接使用初始大小
  而HashMap 会将其扩充为 2 的幂次方大小（HashMap 中的**tableSizeFor()**方法保证，下面给出了源代码）。也就是说 HashMap 总是使用 2 的幂作为哈希表的大小,后面会介绍到为什么是 2 的幂次方

底层数据结构

JDK1.8之后HashMap解决哈希冲突时，当链表大于阈值（默认8）时，将链表转为红黑树（转换前判断，如果当前数组长度小于64，则先进行数组扩容，而不转成红黑树），以减少搜索时间。
Hashtable没有上面的机制

/**
HashMap 中带有初始容量的构造函数：
*/
public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
     public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    } 

/*下面这个方法保证了 HashMap 总是使用 2 的幂作为哈希表的大小。*/
/**
     * Returns a power of two size for the given target capacity.
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

HashMap和hashSet区别
...

集合_1

2022年10月17日 08:55 周一

集合包括`Collection`和`Map`，Collection 存放单一元素。Map 存放键值对 #

ly-20241212141928129

List，Set，Queue，Map区别 #

List(对付顺序的好帮手): 存储的元素是有序的、可重复的。
Set(注重独一无二的性质): 存储的元素是无序的、不可重复的。
Queue(实现排队功能的叫号机): 按特定的排队规则来确定先后顺序，存储的元素是有序的、可重复的。
Map(用 key 来搜索的专家): 使用键值对（key-value）存储，类似于数学上的函数 y=f(x)，“x” 代表 key，“y” 代表 value，key 是无序的、不可重复的，value 是无序的、可重复的，每个键最多映射到一个值。

各种集合框架–底层数据结构 #

List
- ArrayList、Vector —-> Object[] 数组
- LinkedList 双向链表 (jdk 1.6 之前为循环链表, 1.7 取消了循环)
Set
- HashSet （无序，唯一），且基于HashMap
- LinkedHashSet 是HashSet的子类，基于LinkedHashMap (LinkedHashMap内部基于HashMap实现)
- TreeSet(有序，唯一) ：红黑树（自平衡的排序二叉树）
Queue (队列)
- PriorityQueue：Object[] 数组来实现二叉堆
- ArrayQueue：Object[] 数组+ 双指针
Map
- HashMap： JDK1.8 之前 HashMap 由数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间
  ...

语法糖

2022年10月12日 17:36 周三

简介 #

语法糖（Syntactic Sugar）也称糖衣语法，指的是在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用，简而言之，让程序更加简洁，有更高的可读性

Java中有哪些语法糖 #

Java虚拟机并不支持这些语法糖，这些语法糖在编译阶段就会被还原成简单的基础语法结构，这个过程就是解语法糖

javac命令可以将后缀为.java的源文件编译为后缀名为.class的可以运行于Java虚拟机的字节码。其中，com.sun.tools.javac.main.JavaCompiler的源码中，compile()中有一个步骤就是调用desugar()，这个方法就是负责解语法糖的实现的
Java中的语法糖，包括泛型、变长参数、条件编译、自动拆装箱、内部类等

switch支持String与枚举 #

switch本身原本只支持基本类型，如int、char
ly-20241212141927344

int是比较数值，而char则是比较其ascii码，所以其实对于编译器来说，都是int类型(整型)，比如byte。short，char(ackii 码是整型)以及int。 ly-20241212141927646

ly-20241212141927801 而对于enum类型，
ly-20241212141927960

对于switch中使用String，则：

public class switchDemoString {
    public static void main(String[] args) {
        String str = "world";
        switch (str) {
        case "hello":
            System.out.println("hello");
            break;
        case "world":
            System.out.println("world");
            break;
        default:
            break;
        }
    }
}
//反编译之后
public class switchDemoString
{
    public switchDemoString()
    {
    }
    public static void main(String args[])
    {
        String str = "world";
        String s;
        switch((s = str).hashCode())
        {
        default:
            break;
        case 99162322:
            if(s.equals("hello"))
                System.out.println("hello");
            break;
        case 113318802:
            if(s.equals("world"))
                System.out.println("world");
            break;
        }
    }
}

即switch判断是通过**equals()和hashCode()**方法来实现的

...

java_spi

2022年10月12日 10:12 周三

简介 #

为了实现在模块装配的时候不用再程序里面动态指明，这就需要一种服务发现机制。JavaSPI就是提供了这样的一个机制：为某个接口寻找服务实现的机制。有点类似IoC的思想，将装配的控制权交到了程序之外

SPI介绍 #

SPI，ServiceProviderInterface 使用SPI：Spring框架、数据库加载驱动、日志接口、以及Dubbo的扩展实现

ly-20241212141926732

感觉下面这个图不太对，被调用方应该一般模块之间都是通过接口进行通讯，

实战演示 #

SLF4J只是一个日志门面（接口），但是SLF4J的具体实现可以有多种，如：Logback/Log4j/Log4j2等等

ly-20241212141927020

简易版本 #

ServiceProviderInterface

目录结构

│  service-provider-interface.iml
│
├─.idea
│  │  .gitignore
│  │  misc.xml
│  │  modules.xml
│  └─ workspace.xml
│
└─src
    └─edu
        └─jiangxuan
            └─up
                └─spi
                        Logger.java
                        LoggerService.java
                        Main.class

Logger接口，即SPI 服务提供者接口，后面的服务提供者要针对这个接口进行实现

package edu.jiangxuan.up.spi;

public interface Logger {
    void info(String msg);
    void debug(String msg);
}

LoggerService类，主要是为服务使用者（调用方）提供特定功能，这个类是实现JavaSPI机制的关键所在
...

unsafe类

2022年10月10日 17:10 周一

sun.misc.Unsafe

提供执行低级别、不安全操作的方法，如直接访问系统内存资源、自主管理内存资源等，效率快，但由于有了操作内存空间的能力，会增加指针问题风险。且这些功能的实现依赖于本地方法，Java代码中只是声明方法头，具体实现规则交给本地代码 ly-20241212141925562

为什么要使用本地方法 #

需要用到Java中不具备的依赖于操作系统的特性，跨平台的同时要实现对底层控制
对于其他语言已经完成的现成功能，可以使用Java调用
对时间敏感/性能要求非常高，有必要使用更为底层的语言

对于同一本地方法，不同的操作系统可能通过不同的方式来实现的

Unsafe创建 #

sun.misc.Unsafe部分源码

public final class Unsafe {
  // 单例对象
  private static final Unsafe theUnsafe;
  ......
  private Unsafe() {
  }
    
  //Sensitive : 敏感的 英[ˈsensətɪv]
  @CallerSensitive
  public static Unsafe getUnsafe() {
    Class var0 = Reflection.getCallerClass();
    // 仅在引导类加载器`BootstrapClassLoader`加载时才合法
    if(!VM.isSystemDomainLoader(var0.getClassLoader())) {
      throw new SecurityException("Unsafe");
    } else {
      return theUnsafe;
    }
  }
}

会先判断当前类是否由Bootstrap classloader加载。即只有启动类加载器加载的类才能够调用Unsafe类中的方法

如何使用Unsafe这个类

利用反射获得Unsafe类中已经实例化完成的单例对象theUnsafe

private static Unsafe reflectGetUnsafe() {
    try {
      Field field = Unsafe.class.getDeclaredField("theUnsafe");
      field.setAccessible(true);
      return (Unsafe) field.get(null);
    } catch (Exception e) {
      log.error(e.getMessage(), e);
      return null;
    }
}

通过Java命令行命令-Xbootclasspath/a把调用Unsafe相关方法的类A所在jar包路径追加到默认的bootstrap路径中，使得A被引导类加载器加载
...

big_decimal

2022年10月10日 14:56 周一

精度的丢失 #

float a = 2.0f - 1.9f;
float b = 1.8f - 1.7f;
System.out.println(a);// 0.100000024
System.out.println(b);// 0.099999905
System.out.println(a == b);// false

使用BigDecimal来定义浮点数的值，然后再进行浮点数的运算操作即可

BigDecimal常见方法 #

我们在使用 BigDecimal 时，为了防止精度丢失，推荐使用它的BigDecimal(String val)构造方法或者 BigDecimal.valueOf(double val) 静态方法来创建对象

加减乘除

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
System.out.println(a.add(b));// 1.9
System.out.println(a.subtract(b));// 0.1
System.out.println(a.multiply(b));// 0.90
System.out.println(a.divide(b));// 无法除尽，抛出 ArithmeticException 异常
System.out.println(a.divide(b, 2, RoundingMode.HALF_UP));// 1.11

使用divide方法的时候，尽量使用3个参数版本（roundingMode.oldMode)

保留规则

public enum RoundingMode {
   // 2.5 -> 3 , 1.6 -> 2
   // -1.6 -> -2 , -2.5 -> -3
			 UP(BigDecimal.ROUND_UP), //数轴上靠近哪个取哪个
   // 2.5 -> 2 , 1.6 -> 1
   // -1.6 -> -1 , -2.5 -> -2
			 DOWN(BigDecimal.ROUND_DOWN), //数轴上离哪个远取哪个
			 // 2.5 -> 3 , 1.6 -> 2
   // -1.6 -> -1 , -2.5 -> -2
			 CEILING(BigDecimal.ROUND_CEILING),
			 // 2.5 -> 2 , 1.6 -> 1
   // -1.6 -> -2 , -2.5 -> -3
			 FLOOR(BigDecimal.ROUND_FLOOR), ////数轴上 正数：远离哪个取哪个  负数：靠近哪个取哪个
   	// 2.5 -> 3 , 1.6 -> 2
   // -1.6 -> -2 , -2.5 -> -3
			 HALF_UP(BigDecimal.ROUND_HALF_UP),// 数轴上 正数：靠近哪个取哪个  负数：远离哪个取哪个
   //......
}

大小比较
使用compareTo
...

Java代理模式

2022年10月10日 14:30 周一