将内层循环封装后效率更高的问题

bobo老师您好，我在练习时发现将选择排序的内层循环封装起来的效率会比不封装的效率快一些，但我想不明白程序运行的逻辑看上去一致，甚至封装后会多一步方法调用的步骤，但是效率反而更快。
麻烦bobo老师指点迷津。

未使用方法封装：

使用方法封装：

运行结果：

代码如下：

package coding.sorting;

import java.util.ArrayList;
import java.util.List;

public class SortTest {
    // 生成长度为n的数组
    static List<Integer> gen(int n){
        var A = new ArrayList<Integer>();
        for(int i = 0; i < n; i++) {
            A.add((int) (Math.random() * 10000));
        }
        return A;
    }

    // 交换数据的位置
    static void swap(int[] A, int i, int j){
        int temp = A[i];
        A[i] = A[j];
        A[j] = temp;
    }

    // 未使用方法封装
    static public void sort1(int[] arrays) {
        for (int i = arrays.length - 1; i >= 0; i--) {
            int maxIndex = i;
            int maxNum = Integer.MIN_VALUE;
            for (int j = maxIndex; j >= 0; j--) {
                if (maxNum < arrays[j]) {
                    maxNum = arrays[j];
                    maxIndex = j;
                }
            }
            swap(arrays, maxIndex, i);
        }
    }

    // 使用方法封装
    static public void sort2(int[] arrays) {
        for (int i = arrays.length - 1; i >= 0; i--) {
            int maxIndex = maxIndex(arrays, i);
            swap(arrays, maxIndex, i);
        }
    }

    static private int maxIndex(int[] arrays, int i) {
        int maxIndex = i;
        int maxNum = Integer.MIN_VALUE;
        for (int j = maxIndex; j >= 0; j--) {
            if (maxNum < arrays[j]) {
                maxNum = arrays[j];
                maxIndex = j;
            }
        }
        return maxIndex;
    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        var arrays = gen(100000).stream().mapToInt(x->x).toArray();
        sort1(arrays);
        System.out.println("time usage:" + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        sort2(arrays);
        System.out.println("time usage:" + (System.currentTimeMillis() - start));
    }
}