Sudoku generator using seed Sudoku

For this review, I'm operating under the assumption that this was a class assignment / programming challenge and/or has portions copy-pasted / is made by more than one person. The main reason for this is b/c of the excessive inconsistencies w/ formatting. Which is a pretty good segway into:

Formatting

Since you're using Java, I'll briefly touch on OOD (Object Oriented Design). Even though this is a controlled program / script, it would be a good practice to split up your main function into a separate class. This will let you design your Sedoku solver as a separate object. This is pretty important since you use SudokuGenerator in your main function.

On to styling, your for loops have awkwardly inconsistent formatting. You bounce btwn. using ++i and i++ (I prefer prefix b/c it used to give a performance boost, though now it probably doesn't matter), declaring variables inside and outside the loops, and using i < 9 and i <= 8. The principle here is to just one form of logic. So let's start just lightly changing the program using these principles.

Main.java

    public static void main(String[] args) {
        SudokuGenerator gen = new SudokuGenerator();
        // initial transpose, shuffle & seedChange happens in a constructor
        for (int i = 2; i > 0; --i) {
            System.out.println("\n\n------ New Board --------\n");
            gen.transpose();
            gen.shuffle();
            gen.display();
            gen.seedChanger();
        }
        /*
        int n = 2;
        s.transpose();
        s.shuffle();
        s.seedChanger();
        while (n > 0) {
            System.out.println("\n\n------ New Board --------\n");
            s.transpose();
            s.shuffle();
            s.display();
            s.seedChanger();
            n--;
        }
        */
    }

As the comment here says, the initial stuff you did to prepare the generator is now handled in its default constructor. You never edit n in those calls, so just declaring and modifying it in a for loop over a while is best here.

After some modification

Main.java

package T145.sudokugen;

public class Main {

    static char[][] transposedSeed = new char[][] {
        {'8', '2', '7', '1', '5', '4', '3', '9', '6'},
        {'9', '6', '5', '3', '2', '7', '1', '4', '8'},
        {'3', '4', '1', '6', '8', '9', '7', '5', '2'},
        {'5', '9', '3', '4', '6', '8', '2', '7', '1'},
        {'4', '7', '2', '5', '1', '3', '6', '8', '9'},
        {'6', '1', '8', '9', '7', '2', '4', '3', '5'},
        {'7', '8', '6', '2', '3', '5', '9', '1', '4'},
        {'1', '5', '4', '7', '9', '6', '8', '2', '3'},
        {'2', '3', '9', '8', '4', '1', '5', '6', '7'}
    };

    public static void main(String[] args) {
        Sudoku game = new Sudoku(transposedSeed);
        // initial transpose, shuffle & seedChange happens in a constructor
        for (int i = 2; i >= 0; --i) {
            System.out.println("\n\n------ New Board --------\n");
            game.transpose();
            game.shuffle();
            game.printBoard();
            game.seedChanger();
        }
    }
}

Sudoku.java

package T145.sudokugen;

import java.util.Random;

public class Sudoku {

    private final char[][] transposedSeed;

    private char[][] board = new char[9][9];
    private int[] randomizeSudoku = new int[9];
    private char[][] seed = new char[9][9];
    private Random random = new Random();

    public Sudoku(char[][] transposedSeed) {
        this.transposedSeed = transposedSeed;

        transpose();
        shuffle();
        seedChanger();
    }

    public void transpose() {
        for (short i = 0; i < 9; ++i) {
            for (short j = 0; j < 9; ++j) {
                seed[j][i] = transposedSeed[i][j];
            }
        }
    }

    public void seedChanger() {
        for (short i = 0; i < 9; ++i) {
            System.arraycopy(board[i], 0, transposedSeed[i], 0, board.length);
        }
    }

    public void randomSudokuGenerator() {
        short i = 0;

        for (i = 0; i < randomizeSudoku.length; ++i) {
            randomizeSudoku[i] = 9;
        }

        for (i = 0; i < randomizeSudoku.length; ++i) {
            int r = random.nextInt(2);

            for (int i1 = 0; i1 < i; ++i1) {
                int x = randomizeSudoku[i1];

                if (x == r) {
                    if (i < 3) {
                        r = random.nextInt(3);
                    } else if (i < 6) {
                        r = random.nextInt(3) + 3;
                    } else if (i < 9) {
                        r = random.nextInt(3) + 6;
                    }

                    i1 = -1;
                }
            }

            randomizeSudoku[i] = r;
        }
    }

    private void swap(char[][] a, int commonIndex, int first, int second) {
        char swap = a[commonIndex][first];
        a[commonIndex][first] = a[commonIndex][second];
        board[commonIndex][second] = swap;
    }

    public void shuffle() {
        randomSudokuGenerator();

        for (short x = 0; x < 9; ++x) {
            board[0][x] = seed[randomizeSudoku[0]][x];
            board[1][x] = seed[randomizeSudoku[1]][x];
            board[2][x] = seed[randomizeSudoku[2]][x];
            board[3][x] = seed[randomizeSudoku[3]][x];
            board[4][x] = seed[randomizeSudoku[4]][x];
            board[5][x] = seed[randomizeSudoku[5]][x];
            board[6][x] = seed[randomizeSudoku[6]][x];
            board[7][x] = seed[randomizeSudoku[7]][x];
            board[8][x] = seed[randomizeSudoku[8]][x];
        }

        for (short x = 0; x < 9; ++x) {
            if (randomizeSudoku[0] == 0) {
                swap(board, x, 1, 0);
            }

            if (randomizeSudoku[0] == 1) {
                swap(board, x, 2, 0);
            }

            if (randomizeSudoku[0] == 0) {
                swap(board, x, 5, 4);
            }

            if (randomizeSudoku[0] == 1) {
                swap(board, x, 5, 3);
            }

            if (randomizeSudoku[0] == 2) {
                swap(board, x, 8, 6);
            }
        }
    }

    public void printBoard() {
        for (short i = 0; i < 9; ++i) {

            if (i == 0) {
                System.out.print("\t\t\t_______________________________________\n\t row " + (i + 1) + "\t");
            } else {
                System.out.print("\t\t\t|---|---|---||---|---|---||---|---|---|\n\t row " + (i + 1) + "\t");
            }

            for (short j = 0; j < 9; ++j) {
                if (j == 3) {
                    System.out.print("|");
                }

                if (j == 6) {
                    System.out.print("|");
                }

                if (j == 8) {
                    System.out.println("| " + board[i][j] + " |");
                } else {
                    System.out.print("| " + board[i][j] + " ");
                }
            }

            if (i == 2) {
                System.out.println("\t\t\t|---|---|---||---|---|---||---|---|---|");
            }

            if (i == 5) {
                System.out.println("\t\t\t|---|---|---||---|---|---||---|---|---|");
            }

            if (i == 8) {
                System.out.println("\t\t\t---------------------------------------");
                System.out.println("\tcolumns   1   2   3    4   5   6    7   8   9  \n\n\n");
            }
        }
    }
}

A majority of this is just simple re-formatting. You'll notice I use short over int in some cases, and this is just simply b/c shorts have less of a memory imprint. It doesn't really matter b/c of just how much memory modern computers have, but I like to produce code that pays attention to the details.

I haven't modified any of your core logic b/c of my initial reasoning. But to point you in the right direction, think about:

1) Where the modulo operator (%) can be used to clean up some operations.

2) Where you can use other data structures to help optimize performance.

3) Where you can use Java 8+ abilities to optimize performance or at least slim down your code w/ equivalent performance.