Java 如何通过多级递归保留值？

我编写了一个快速排序程序，该程序计算按升序对数组排序时执行的交换次数。在这个程序中，我使用了一个全局变量来计算交换的数量，因为我无法计算如何通过多层递归来保留值。我理解这样一个概念，即当函数自身折叠时，通过多个递归级别来保留值，但我显然无法实现它。有人能告诉我怎么做吗

import java.util.Scanner;

public class QuickSort {

    // global variable for counting the quicksort shifts.
    private static int swapCount = 0;

    public static void main(String[] args) {

        // scanning the values;
        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt();
        int ar[] = new int[N];
        for(int i = 0 ; i < N ; i++){
            int value = scan.nextInt();
            ar[i] = value;
        }

        quickSort(ar, 0, ar.length-1);
        System.out.println(swapCount);

    }

    //quickSort
    public static void quickSort(int ar[], int start, int end){

        if(start<end){
            int pIndex = partition(ar, start, end);
            quickSort(ar,start, pIndex-1);
            quickSort(ar, pIndex+1, end);   
        }
    } 

    // partition function
    public static int partition(int ar[], int start, int end){
        int pivot = ar[end];
        int pIndex = start;
        for (int i = start ; i < end ; i++ ){
            if(ar[i] < pivot){
                int temp = ar[i];  
                ar[i] = ar[pIndex];
                ar[pIndex] = temp;
                swapCount++;
                pIndex++;
            }
        }
        int temp = ar[end];
        ar[end] = ar[pIndex];
        ar[pIndex] = temp;
        swapCount++;
        return pIndex;
    }  
}

import java.util.Scanner；
公共类快速排序{
//用于计算快速排序班次的全局变量。
私有静态int-swapCount=0；
公共静态void main（字符串[]args）{
//扫描数值；
扫描仪扫描=新扫描仪（System.in）；
int N=scan.nextInt（）；
int ar[]=新的int[N]；
对于（int i=0；iif（start您面临的问题是，在Java中，如果在函数返回后查看原始类型（如int）的值，那么在传递到函数中的int值不会反映在函数内部对它们所做的任何更改。解决该问题的方法，即使它不一定是“好的样式”，是将类对象而不是基元对象传递到函数中，然后在函数内部对类对象的成员变量所做的更改将稍后反映到函数外部

// in main()
Integer nbrSwaps = new Interger(0);
quickSort(ar, 0, ar.length-1, nbrSwaps);

//quickSort
public static void quickSort(int ar[], int start, int end, Integer swapCount) {

  if(start<end){
    int pIndex = partition(ar, start, end, swapCount);
    quickSort(ar,start, pIndex-1, swapCount);
    quickSort(ar, pIndex+1, end, swapCount);   
  }
}

// partition function
public static int partition(int ar[], int start, int end, Integer swapCount) {
  ... as before ...
}

//在main（）中
整数交换=新整数（0）；
快速排序（ar，0，ar.length-1，交换）；
//快速分类
公共静态void快速排序（int-ar[]，int-start，int-end，整数swapCount）{
if（start您面临的问题是，在Java中，如果在函数返回后查看原始类型（如int）的值，那么在传递到函数中的int值不会反映在函数内部对它们所做的任何更改。解决该问题的方法，即使它不一定是“好的样式”，是将类对象而不是基元对象传递到函数中，然后在函数内部对类对象的成员变量所做的更改将稍后反映到函数外部

// in main()
Integer nbrSwaps = new Interger(0);
quickSort(ar, 0, ar.length-1, nbrSwaps);

//quickSort
public static void quickSort(int ar[], int start, int end, Integer swapCount) {

  if(start<end){
    int pIndex = partition(ar, start, end, swapCount);
    quickSort(ar,start, pIndex-1, swapCount);
    quickSort(ar, pIndex+1, end, swapCount);   
  }
}

// partition function
public static int partition(int ar[], int start, int end, Integer swapCount) {
  ... as before ...
}

//在main（）中
整数交换=新整数（0）；
快速排序（ar，0，ar.length-1，交换）；
//快速分类
公共静态void快速排序（int-ar[]，int-start，int-end，整数swapCount）{
if（start）您可以将包含该值的对象向下传递到调用堆栈。这可能是一个特殊类，也可能只是一个
int[]
。在这种情况下，静态（全局）变量可能有意义。它允许您在不更改接口（调用参数）的情况下分析代码。您可以在测试完成后轻松删除它。如前所述，如果您确实希望将静态变量作为参数传递，则必须通过引用传递它，而Java不支持基本类型，因此如下所述，您必须创建一个类/对象才能通过引用传递。您可以传递一个包含值的对象n调用堆栈。这可能是一个特殊类，也可能只是一个
int[]
。在这种情况下，静态（全局）变量可能有意义。它允许您在不更改接口（调用参数）的情况下分析代码。您可以在测试完成后轻松删除它。如前所述，如果您确实希望将静态变量作为参数传递，则必须通过引用传递它，而Java不支持基本类型，因此如下所述，您必须创建一个类/对象才能通过引用传递。