Как отсортировать массив элементов некоторого класса в java по одному полю используя sort?

public static class individual {
        static int importance;
        static int field[][][] = new int[MAX_SIZE_OF_FIELD][MAX_SIZE_OF_FIELD][3];
        
        public int compareTo(individual  obj) {
            individual tmp = obj;
            if (this.importance < tmp.importance) return -1;
            if (this.importance > tmp.importance) return 1;
            return 0;  
        }
    };

at java.util.ComparableTimSort.countRunAndMakeAscending(ComparableTimSort.java:316)
    at java.util.ComparableTimSort.sort(ComparableTimSort.java:198)
    at java.util.Arrays.sort(Arrays.java:1246)
    at turn.on.the.light.TurnOnTheLight.solve(TurnOnTheLight.java:155)
    at turn.on.the.light.TurnOnTheLight.main(TurnOnTheLight.java:166)

package turn.on.the.light;
 
import java.util.*;
 
public class TurnOnTheLight {
    static int size_of_field = 0;
    final static int MAX_SIZE_OF_FIELD = 10;
    final static int MAX_SIZE_OF_POPULATION = 1000;
    final static int MAX_NUMBER_OF_GENERATIONS = 1000;
    
    public static class individual {
        public static int importance;
        public static int field[][][] = new int[MAX_SIZE_OF_FIELD][MAX_SIZE_OF_FIELD][3];
        
        public int compareTo(individual  obj) {
            individual tmp = obj;
            if (this.importance < tmp.importance) return -1;
            if (this.importance > tmp.importance) return 1;
            return 0;  
        }
    };
    static individual population[] = new individual[MAX_SIZE_OF_POPULATION];
   
    static Scanner sc = new Scanner(System.in);
    
    static char types[] = new char[4];
    static boolean directions[][][] = {
        {
            {false, true, true, true},
            {true, true, true, false},
            {true, false, true, true},
            {true, true, false, true}
        },    
        {    
            {false, true, true, false},
            {true, false, true, false},
            {true, false, false, true},
            {false, true, false, true}
        },
        {
            {false, false, true, false},
            {true, false, false, false},
            {false, false, false, true},
            {false, true, false, false}
        },
        {
            {false, false, true, true},
            {true, true, false, false},
            {false, false, true, true},
            {true, true, false, false}
        }
    };
 
    static void init_types_of_pipes() {
        types[0] = 'T';
        types[1] = 'L';
        types[2] = 'H';
        types[3] = 'I';
    }
    
    static int recognize_type_of_pipe(char c) {
        for (int t = 0; t < 4; t++) {
            if (types[t] == c) return t;
        }
        return -1;
    }
    
    static int input() {
        size_of_field = sc.nextInt();
        String str = sc.nextLine();
        for (int i = 0; i < size_of_field; i++) {
            str = sc.nextLine();
            for (int j = 0, pos = 0; pos < str.length(); j++, pos+=3) {
                if (recognize_type_of_pipe(str.charAt(pos)) != -1) {
                    population[0].field[i][j][0] = recognize_type_of_pipe(str.charAt(pos));
                    population[0].field[i][j][1] = (int)(str.charAt(pos+1)-'0');
                }
                else {
                    System.out.println("error recognize_type_of_pipe");
                    return -1;
                }
            }
        }
        return 0;
    }
    
    static void calculate_importance_of_individual(int individ) { 
        for (int i = 0; i < size_of_field; i++) {
            for (int j = 0; j < size_of_field; j++) {
                if (i-1 > 0) {
                    if (directions[population[individ].field[i][j][0]][population[individ].field[i][j][1]][0] == true) {
                        if (directions[population[individ].field[i-1][j][0]][population[individ].field[i-1][j][1]][1] == true) {
                            population[individ].importance++;
                            population[individ].field[i][j][2]++;
                        }
                    }
                }
                if (j-1 > 0) {
                    if (directions[population[individ].field[i][j][0]][population[individ].field[i][j][1]][2] == true) {
                        if (directions[population[individ].field[i][j-1][0]][population[individ].field[i][j-1][1]][3] == true) {
                            population[individ].importance++;
                            population[individ].field[i][j][2]++;
                        }
                    }
                }
                if (i+1 < size_of_field) {
                    if (directions[population[individ].field[i][j][0]][population[individ].field[i][j][1]][1] == true) {
                        if (directions[population[individ].field[i+1][j][0]][population[individ].field[i+1][j][1]][0] == true) {
                            population[individ].importance++;
                            population[individ].field[i][j][2]++;
                        }
                    }
                }
                if (j+1 < size_of_field) {
                    if (directions[population[individ].field[i][j][0]][population[individ].field[i][j][1]][3] == true) {
                        if (directions[population[individ].field[i][j+1][0]][population[individ].field[i][j+1][1]][2] == true) {
                            population[individ].importance++;
                            population[individ].field[i][j][2]++;
                        }
                    }
                }
            }
        }
    }
    
    static void create_population() {
        sc.nextLine();
        Random rand = new Random(1);
        for (int individ = 1; individ < MAX_SIZE_OF_POPULATION; individ++) {
            System.out.println(individ);
            for (int i = 0; i < size_of_field; i++) {
                for (int j = 0; j < size_of_field; j++) {
                    population[individ].field[i][j][0] = population[0].field[i][j][0];
                    population[individ].field[i][j][1] = individ%4;
                }
            }
            calculate_importance_of_individual(individ);
        }
        
        for (int t = 0; t < MAX_SIZE_OF_POPULATION; t++) {
            System.out.println(t);
            for (int i = 0; i < size_of_field; i++) {
                for (int j = 0; j < size_of_field; j++) {
                    System.out.print(population[t].field[i][j][0] + " " + population[t].field[i][j][1] + "  ");
                }
                System.out.println();
            }
            System.out.println();
            System.out.println();
            
        }
    }
    
    static void solve() {
        Arrays.sort(population);
        for (int individ = 0; individ < MAX_SIZE_OF_POPULATION; individ++) {
            System.out.print(population[individ].importance + " ");
        }
        for (int generation = 1; generation <= MAX_NUMBER_OF_GENERATIONS; generation++) {
            
        }
    }
    
    public static void main(String[] args) {
        init_types_of_pipes();
        int input_status = input();
        if (input_status == -1) return;
        create_population();
        solve();
    } 
}