Tes commentaires et ton code

Tes commentaires ne sont pas bons:
- bavards;
- imprécis;
- pas pertinents.

Ne le prends pas mal, c'est pour t'aider à t'améliorer.

int determ = 0, row, col;
 
 // On crée un tableau dans lesquel on stockera les déterminants des cofacteurs de la premiere ligne
 int detcofact[] = new int [matrice.col-1];

Cela s'écrit plutôt

int determ = 0, // accumulateur: calcul du déterminant
 row, // curseur des lignes
 col; // curseur des colonnes
 int detcofact[] = new int [matrice.col-1]; // déterminants des cofacteurs de la première ligne de matrice.T 

(Avec des alignements que je ne peux pas faire ici.)

Dans la deuxième version toutes les lignes sont documentées, la mention on crée un tableau pour y stocker disparaît: une variable sert à stocker une valeur, pas la peine de l'écrire, dit plutôt ce qui est dedans!

 public static int detcofacteur(mat matricofact,int rang, int dim)
...
// Retour à la ligne
System.out.println();

Tu trouves ça plus pertinent d'indiquer un retour à la ligne que d'expliquer ce que fait ta fonction auxiliaire et de décrire ses paramètres? Gros problème de hiérarchisation des informations, de plus la paraphrase du code est inutile ou nuisible. Si tu te donnais la peine de faire cette description, tu te donnerais une chance d'écrire une fonction qui fait ce que tu veux en éclaircissant cette histoire dans ta tête.

// si la dimension de la matrice entrée est 1*1, on retourne alors le seul nombre concerné
 if (dim == 1)
 {
 detcofact=matricofact.T[0][0];
 }
 // Sinon on définit la sous matrice par apport a matricofact dont on devra calculer le déterminant, qu'on appelle cofact
 else 

deviens

// Si la taille de la matrice entrée est 1x1, alors son déterminant detcofact est son unique coefficient
// sinon on construit le cofacteur cofact dont on calcule le déterminant detcofact.
 if (dim == 1)
 {
 detcofact=matricofact.T[0][0];
 }
 else

Ceci dit, dans ce fragment la logique me paraît suspecte. Tes commentaires doivent: 1. expliquer ce que font les fonctions et 2. expliquer pourquoi ce qu'elles font donne le bon résultat.

 /* Pour un affichage plus propre, si le nombre est négatif et comporte donc
 un "-", on mettra un espace de moins que si le nombre est positif
 De même si le nombre a 2 chiffres, on lui enlevera un espace ( donc un nombre a 2 chiffres max). */

C'est bavard, tu n'a pas décrit le travail que fait ta procédure et enfin, ne programmant pas en java j'hésite tout de même à croire qu'il n'y a pas de fonction de type printf qui t'aidera à afficher proprement un tableau de nombres.

Voilà un canvas pour ton programme:

// determinant(MATRICE)
// Renvoie le déterminant de la matrice carrée MATRICE. 
// Calcul par la méthode des cofacteurs.
public static int determinant(mat matrice)
 {
int determ = 0, // accumulateur: calcul du déterminant
 j; // curseur des colonnes
 
// Le déterminant d'une matrice 1x1 est son unique coefficeint, on développe le déterminant des matrices de taille plus grande selon la première ligne, grâce à la fonction `comatrice`. 
if (matrice.col == 1) {
 determ = matrice.T[0][0];
} else {
 for (j = 0; j < matrice.col; j++) 
 {
 determ += (-1^j)*matrice.T[0][j]*determinant(comatrice(matrice,0,j));
 }
 return determ;
}
// comatrice(MATRICE, I0, J0)
// Renvoie la comatrice de MATRICE relative à la position I0, J0.
public static mat comatrice(mat matrice, int i0, int j0)
{
int i, // curseur des lignes
int j; // curseur des colonnes
mat c = new mat();
c.row = matrice.row - 1;
c.col = matrice.col - 1;
c.T = new int[c.row][c.col];
for (i = 0; i < c.col; i++) {
 for(j = 0; j < c.row; j++) {
 c.T[i][j] = ...
}
}
}

Cette structure est meilleure parcequ'elle met en évidence le caractère récursif de determinantet l'opération élémentaire produire la comatrice qui apparaît dans ton algorithme mais pas dans ton code. Avec ce point de départ plus sein, tu devrais t'en sortir.