Java 如何改进返回给定整数数组的带有排序索引的整数数组的代码？

我创建了一个方法，我相信它会得到一个数组a，取数组中的前三个值，然后从低到高查找值。然后将这些值放入一个新数组中，并按排序发回。这意味着，例如： int[]a={9,5,7}返回{1,2,0}。这是因为a[1]=5，a[2]=7，a[0]=9。 int[]a={1,3,2}应该返回{0,2,1}不应更改阵列a

public class Testprogram {

public static void main(String[] args) {
    int[] a = {9,8,7,2,7,8};                          
    System.out.println(Arrays.toString(index(a)));

}

public static int[] index(int[] a)
{
    int n = a.length;

    if (n < 3)
    {
        throw new IllegalArgumentException("array must have at least 3 elements!"); 
    }


    int min = 0;                    //lowest index
    int nmin = 1;                   //second lowest index
    int tmin = 2;                   //third lowest index

    // Controlling that the values in start are in the correct position
    if (a[2] < a[1] && a[1] < a[0]) 
    { 
        min = 2; 
        nmin = 1; 
        tmin = 0; 
    } 
    else if (a[2] < a[0] && a[0] < a[1]) 
    { 
        min = 2; 
        nmin = 0; 
        tmin = 1; 
    } 
    else if (a[1] < a[2] && a[2] < a[0]) 
    { 
        min = 1; 
        nmin = 2; 
        tmin = 0; 
    } else if (a[1] < a[0] && a[0] < a[2]) 
    { 
        min = 1; 
        nmin = 0; 
        tmin = 2; 
    } 
    else if(a[0] < a[1] && a[1] < a[2]) 
    { 
        min = 0; 
        nmin = 1; 
        tmin = 2; 
    } else if(a[0] < a[2] && a[2] < a[1]) 
    { 
        min = 0; 
        nmin = 2; 
        tmin = 1; 
    }

    int[] index = new int[] {min, nmin, tmin};

    return index;  //returns the array
}}

公共类测试程序{
公共静态void main（字符串[]args）{
int[]a={9,8,7,2,7,8}；
System.out.println（Arrays.toString（索引（a））；
}
公共静态int[]索引（int[]a）
{
int n=a.长度；
if（n<3）
{
抛出新的IllegalArgumentException（“数组必须至少有3个元素！”）；
}
int min=0；//最低索引
int nmin=1；//第二低索引
int tmin=2；//第三个最低索引
//控制start中的值是否处于正确位置
if（a[2]

此方法应仅适用于三次比较（最多三次交换（更改？）

我的方法和if（n<3）有7个比较。

---

有人能帮我改进代码吗？

这里有一个可能的解决方案

    if(a[0]>a[1]){
        min=1;
        nmin=0;
    }
    if(a[nmin]>a[tmin]){
        int tmp =nmin;
        nmin=tmin;
        tmin=tmp;
    }
    if(a[min]>a[nmin]){
        int tmp =min;
        min=nmin;
        nmin=tmp;
    }

这是一种针对这种特殊情况的冒泡排序（3个元素的数组）