手写快速排序

/**
 * date: 2021-01-09 00:05
 *
 * @author Yuankui Jing
 * @since JDK 1.8
 */
public class QuickSort {
    public static void main(String[] args) {
        int[] array = {1,5,7,9,2,567,346,7,46};
        quickSort(array, 0, array.length-1);
        
        for (int i=0; i<array.length; i++) {
            System.out.print(array[i]+"\t");
        }
    }

    /**
     * 快速排序方法
     * @param jykArray 需要快排的数组
     * @param low 基准数
     * @param high
     */
    private static void quickSort(int[] jykArray, int low, int high) {
        int i, j, temp,t;
        // 递归调用的退出条件
        if (low > high) {
            return;
        }

        // 下标
        i = low;
        j = high;
        // 基准位
        temp = jykArray[low];


        while (i < j) {
            // 从右往左(如果基准位 < array[j]，则哨兵j左移)
            while (temp<=jykArray[j] && i<j) {
                j--;
            }
            // 从左往右(如果基准位 > array[i]，则哨兵i左移)
            while (temp>=jykArray[i] && i<j) {
                i++;
            }

            // i与j满足条件，开始交换
            if (i < j) {
                t = jykArray[i];
                jykArray[i] = jykArray[j];
                jykArray[j] = t;
            }
        }

        // 将基准位与i=j所在的位置上的数字交换
        jykArray[low] = jykArray[i];
        jykArray[i] = temp;

        // 递归调用左右两部分
        quickSort(jykArray, low, j-1);
        quickSort(jykArray, j+1, high);

    }
}

被测系统的架构

逻辑架构：
取分期业务作为例子
前端交互：
现金分期、账单分期、单笔分期、自动分期
业务中台：
资金往来系统、支付平台、核心授权、核心账户、账户分期
基础服务：
分期表、卡片表、账户表等

物理架构：
接入层：
网关
业务服务层：
许多SpringBoot工程，以微服务的形式，部署在OpenShift上，一个工程大概3个Pod
还有SpringBatch工程，基本为晚上跑批
数据存储层：
GoldenDB（分布式MySQL）
Redis

Java基本数据类型各占多少字节

Java常量池

参考https://blog.csdn.net/qq_41376740/article/details/80338158

大体可以分为：静态常量池，运行时常量池。

• 静态常量池 存在于class文件中，比如经常使用的javap -verbose中，常量池总是在最前面把？
• 运行时常量池呢，就是在class文件被加载进了内存之后，常量池保存在了方法区中，通常说的常量池 值的是运行时常量池。所以呢，讨论的都是运行时常量池

字符串常量池
Java中String类，是有字符串常量池的，在方法区中。

String s1 = "Hello";
    String s2 = "Hello";
    String s3 = "Hel" + "lo";
    String s4 = "Hel" + new String("lo");
    String s5 = new String("Hello");
    String s6 = s5.intern();
    String s7 = "H";
    String s8 = "ello";
    String s9 = s7 + s8;

    System.out.println(s1 == s2);  // true
    System.out.println(s1 == s3);  // true
    System.out.println(s1 == s4);  // false
    System.out.println(s1 == s9);  // false
    System.out.println(s4 == s5);  // false
    System.out.println(s1 == s6);  // true

包装类的常量池技术（缓存）
自动装箱和自动拆箱，自动装箱常见的就是valueOf这个方法，自动拆箱就是intValue方法。
除了两个包装类Long和Double 没有实现这个缓存技术，其它的包装类均实现了它。

分析：我们可以看到从-128~127的数全部被自动加入到了常量池里面，意味着这个段的数使用的常量值的地址都是一样的。

public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
    return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}

private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];

static {
    // high value may be configured by property
    int h = 127;
    String integerCacheHighPropValue =
        VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    if (integerCacheHighPropValue != null) {
        try {
            int i = parseInt(integerCacheHighPropValue);
            i = Math.max(i, 127);
            // Maximum array size is Integer.MAX_VALUE
            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
        } catch( NumberFormatException nfe) {
            // If the property cannot be parsed into an int, ignore it.
        }
    }
    high = h;

    cache = new Integer[(high - low) + 1];
    int j = low;
    for(int k = 0; k < cache.length; k++)
        cache[k] = new Integer(j++);

    // range [-128, 127] must be interned (JLS7 5.1.7)
    assert IntegerCache.high >= 127;
}

private IntegerCache() {}
}

自动装箱和拆箱