Sudoku solution validator/verifier/checker implemented in Java

I suggest you implement checking the minisquares in a double loop that iterates over all minisquares and for each minisquare checks that it is valid.

Also, I would have used counter[10]. That way, I don't have to translate between sudoku numbers and the indices to counter.

All in all, I had this in mind:

package com.github.coderodde.sudoku;

public final class SudokuChecker {

    private static final int SUDOKU_DIMENSIONS = 9;
    private static final int MINISQUARE_DIMENSIONS = 3;
    
    public static boolean isValidSolution(final int[][] sudoku) {
        checkDimensions(sudoku);
        preCheck(sudoku);
        
        final IntSet intSet = new IntSet(10);
        
        // Check rows:
        for (int r = 0; r < sudoku.length; r++) {
            for (int c = 0; c < sudoku.length; c++) {
                final int number = sudoku[r][c];
                
                if (intSet.read(number)) {
                    return false;
                }
                
                intSet.add(number);
            }
            
            intSet.clear();
        }
        
        // Check columns:
        for (int c = 0; c < sudoku.length; c++) {
            for (int r = 0; r < sudoku.length; r++) {
                final int number = sudoku[r][c];
                
                if (intSet.read(number)) {
                    return false;
                }
                
                intSet.add(number);
            }
            
            intSet.clear();
        }
        
        // Check minisquares:
        for (int minisquareY = 0;
                 minisquareY < MINISQUARE_DIMENSIONS; 
                 minisquareY++) {
            
            for (int minisquareX = 0;
                     minisquareX < MINISQUARE_DIMENSIONS;
                     minisquareX++) {
                
                for (int r = 0; r < MINISQUARE_DIMENSIONS; r++) {
                    for (int c = 0; c < MINISQUARE_DIMENSIONS; c++) {
                        final int number =
                                sudoku[MINISQUARE_DIMENSIONS * minisquareY + r]
                                      [MINISQUARE_DIMENSIONS * minisquareX + c];
                        
                        if (intSet.read(number)) {
                            return false;
                        }
                        
                        intSet.add(number);
                    }
                }
                
                intSet.clear();
            }
        }
        
        return true;
    } 
    
    public static void main(String[] args) {
        int[][] sudoku = {
                { 9, 6, 3, 1, 7, 4, 2, 5, 8 },
                { 1, 7, 8, 3, 2, 5, 6, 4, 9 },
                { 2, 5, 4, 6, 8, 9, 7, 3, 1 },
                { 8, 2, 1, 4, 3, 7, 5, 9, 6 },
                { 4, 9, 6, 8, 5, 2, 3, 1, 7 },
                { 7, 3, 5, 9, 6, 1, 8, 2, 4 },
                { 5, 8, 9, 7, 1, 3, 4, 6, 2 },
                { 3, 1, 7, 2, 4, 6, 9, 8, 5 },
                { 6, 4, 2, 5, 9, 8, 1, 7, 3 }
        };
        
        System.out.println(isValidSolution(sudoku));
    }
    
    private static boolean isValidNumber(final int number) {
        return 1 <= number && number <= SUDOKU_DIMENSIONS;
    }
    
    private static void checkDimensions(final int[][] sudoku) {
        if (sudoku.length != SUDOKU_DIMENSIONS) {
            throw new IllegalArgumentException(
                    "A sudoku with invalid dimensions.");
        }
        
        for (int i = 0; i < sudoku.length; i++) {
            if (sudoku[i].length != SUDOKU_DIMENSIONS) {
                throw new IllegalArgumentException(
                        "A sudoku with invalid dimensions.");
            }
        }
    }
    
    private static void preCheck(final int[][] sudoku) {
        for (final int[] row : sudoku) {
            for (final int number : row) {
                if (!isValidNumber(number)) {
                    throw new IllegalArgumentException(
                            "Contains invalid number: " + number);
                }
            }
        }
    }
}

class IntSet {
    private final boolean[] array;
    
    IntSet(final int length) {
        array = new boolean[length];
    }
    
    void add(final int index) {
        array[index] = true;
    }
    
    boolean read(final int index) {
        return array[index];
    }
    
    void clear() {
        for (int i = 0; i < array.length; i++) {
            array[i] = false;
        }
    }
}

Finally, your count array works like this: if the solution contains numbers outside of the set of allowed numbers, you will get an ArrayIndexOutOfBoundsException. If you have duplicates, some array components will remain zero yet some another array component must become larger than one.

You've already received some good responses about writing this operation in Java.

Here is a pseudocode reimplementation of the scanning/tabulating loops as a more compact single loop.

for cell = 0 to 80 // IDs of 81 cells
    row = cell / 9
    col = cell % 9
    sqr = row/3*3 + col/3

    val = board[row][col]

    countRow[row][val]++
    countCol[col][val]++
    countSqr[sqr][val]++

Left as an exercise is to evaluate the tabulations to ensure the Sudoku meets the criteria.

Because this single purpose operation is unlikely to change to accommodate future enhancements, it is even possible to check the value of each 'tabulator' element (before or after incrementing) to facilitate early (immediate) detection of an invalid Sudoko solution. However, good counter arguments can be put forward for retaining KISS "isolation of purpose" of regions of code.

Code Review

Too much code!

Write less code that gets the job done (correctly.)