[JAVA] Comment remplacer des caractères que vous ne comprenez pas [Principe]

Le tri de classe Array est vraiment bon, n'est-ce pas? Il trie par ordre croissant sans autorisation, et même par ordre décroissant.
Cependant, j'avais peur de rester coincé si je ne connaissais pas l'essence du tri. Comment ne pas utiliser la méthode de tri.

Code cible

public class Change {

    public static void main(String[] args) {
        ListManager data = new ListManager();

        for (int i = 1; i < 100; i++) {
            /*
Les valeurs suivantes sont renvoyées en fonction du nombre passé à signum.
Si l'argument est supérieur à zéro ⇒ 1
Lorsque l'argument est nul ⇒ 0
Si l'argument est inférieur à zéro ⇒-1
             */
            int num1 = data.compare(i - 1, i);
            switch (num1) {
                case 1:
                    //Échanger
                    data.exchange(i - 1, i);
                    //Remplacer par derrière
                    for (int n = i; n > 0; n--) {
                        int num2 = data.compare(n - 1, n);
                        switch (num2) {
                            case 1:
                                data.exchange(n - 1, n);
                            default:
                                break;
                        }
                    }
                default:
                    break;
            }
        }
        data.checkResult();
    }
}

public class ListManager {
    private int[] dataList;
    private int compareCount;
    private int exchangeCount;

    public ListManager() {
        //Créer des données au hasard
        Random random = new Random();
        dataList = new int[100];
        for (int i = 0; i < dataList.length; i++) {
            dataList[i] = random.nextInt(10000);
        }
    }

    /**
     *Comparez deux données
     *
     * @param index1
     * @param index2
     * @return -1:Les données Index1 sont petites, 1:les données d'index2 sont petites, 0:Mêmes données
     */
    public int compare(int index1, int index2) {
        compareCount++;
        return (int) Math.signum(dataList[index1] - dataList[index2]);
    }

    /**
     *Échangez deux données
     *
     * @param index1
     * @param index2
     */
    public void exchange(int index1, int index2) {
        exchangeCount++;
        int tmp = dataList[index1];
        dataList[index1] = dataList[index2];
        dataList[index2] = tmp;
    }

    /**
     *Contrôle de tri
     */
    public void checkResult() {
        int data = dataList[0];
        for (int i = 1; i < dataList.length; i++) {
            if (data > dataList[i]) {
                throw new RuntimeException("Non trié: [" + (i - 1) + "]=" + data + ", [" + i + "]=" + dataList[i]);
            }
            data = dataList[i];
        }
        System.out.println("Trier OK:Comparaison=" + compareCount + ",Échanger=" + exchangeCount);
    }

J'ai l'impression d'écrire du code inutile, donc je le réparerai dès que je le comprendrai.

Si le remplacement ne se produit pas sur le premier commutateur, il sera confirmé que l'index est correctement disposé dans l'ordre croissant avant l'index que vous regardez à ce moment-là, mais dans le cas de mon code, le remplacement se produira sur le premier commutateur. Je me demande si c'est inutile car je vérifie la commande avant l'index.

Suffit-il de vérifier la commande précédente uniquement au moment du remplacement?

Je vais essayer de le raccourcir.