Infinate loop issue

Hello. I have a very strange infinate loop issue.
My program is a sudoku generator. It can successfully generate a solution from scratch and solve a puzzle. However, occasionally it goes nuts and it loops infinately around the method Generate() and containsZeros() in the Solution Class.

I was hoping someone here may be able to help me. I am going insane.

My code is too large to paste in one so I will paste it in parts in the next few posts.

Code:

---

import java.util.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Sudoku extends JFrame
                                implements ActionListener
{
        static Numbers One            = new Numbers(1);
        static Numbers Two            = new Numbers(2);
        static Numbers Three          = new Numbers(3);
        static Numbers Four          = new Numbers(4);
        static Numbers Five          = new Numbers(5);
        static Numbers Six            = new Numbers(6);
        static Numbers Seven          = new Numbers(7);
        static Numbers Eight          = new Numbers(8);
        static Numbers Nine          = new Numbers(9);
        static Strings Possibilities        = new Strings(); //Must be below Numbers declarations
        static Solution Final                = new Solution();
        static Solution Initial                = new Solution();
        JButton btnOption = new JButton("Generate");
        JButton[][]btn = new JButton[9][9];
       
        public Sudoku()        //Method to set up Sudoku JFrame
        {
                super("Sudoku");
                setSize(250, 290);
                setResizable(false);
                setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                Container pane = getContentPane();
                setVisible(true);
                FlowLayout flow = new FlowLayout();
                pane.setLayout(flow);
                flow.setHgap(0); flow.setVgap(0);
                for(int r=0;r<9; r++) //Next 2 for loops are used to create and add 81 buttons. 1 button is 1 cell in the sudoku grid
                {
                        for(int c=0;c<9; c++)
                        {
                                btn[r][c] = new JButton();
                                btn[r][c].setMargin(new Insets(0,0,0,0));
                                btn[r][c].setPreferredSize(new Dimension(25,25));
                                btn[r][c].setText("0");
                                btn[r][c].setFocusPainted(false);
                                btn[r][c].addActionListener(this);
                                btn[r][c].setActionCommand(Integer.toString(r)+Integer.toString(c));
                                pane.add(btn[r][c]);
                        }
                }
                btnOption.addActionListener(this);
                btnOption.setFocusPainted(false);
                pane.add(btnOption);
                setContentPane(pane);
        }
       
        public static void main(String[] args)
        {
                Sudoku mainFrame = new Sudoku();        //Show Sudoku  JFrame
        }
       
        public void actionPerformed(ActionEvent e)
        {
                JButton buttonPressed = (JButton)e.getSource(); //Identify button pressed
                int btnRow=-1, btnCol=-1;
                for(int row=0; row<9; row++)
                {
                        for(int col=0; col<9; col++)
                        {
                                if(buttonPressed.equals(btn[row][col]))
                                {
                                        btnRow = row; btnCol=col;        //determines the coordinates of the cell button pressed.
                                }
                        }
                }
                if(btnRow!=-1 && btnCol!=-1) //when a cell button is pressed its value is incremented by one in the body of this if
                {
                        String buttonText = btn[btnRow][btnCol].getText();
                        int buttonInt = Integer.parseInt(buttonText);
                        if(buttonInt <9) buttonInt += 1;
                        else buttonInt = 0;
                        buttonText = Integer.toString(buttonInt);
                        btn[btnRow][btnCol].setText(buttonText);
                }
                else if ("Generate".equals(e.getActionCommand())) //else if the option button is pressed in generation mode a solution is generated
                {
                        for(int row=0; row<9; row++)
                        {
                                for(int col=0; col<9; col++)
                                {
                                        Initial.Table[row][col]=Integer.parseInt(btn[row][col].getText()); //The initial table is set using the values of the cell buttons
                                }
                        }
                        System.out.print("Initial Table Stored\n");
                        Final.setTable();        //The final solution is set to the same as the initial table
                        System.out.print("Final set to same as initial\n"); ///Error occurs after here
                        Final.Generate();        //Then the generation method is called
                        System.out.print("Solution Generated\n");
                        for(int row=0; row<9; row++)
                        {
                                for(int col=0; col<9; col++)
                                {
                                        btn[row][col].setText(Integer.toString(Final.Table[row][col]));        //The cell buttons text is changed to the new solution once it has been generated
                                }
                        }
                        System.out.print("Solution Output\n");
                        btnOption.setText("Reset");
                        btnOption.setActionCommand("Reset");
                        btnOption.setToolTipText("Click this button to reset");
                        System.out.print("Button Changed to Reset\n");
                }
                else if("Reset".equals(e.getActionCommand())) //else if the option button is pressed in reset mode the whole process is ready to start again.
                {
                        for(int row=0; row<9; row++)
                        {
                                for(int col=0; col<9; col++)
                                {
                                        btn[row][col].setText("0");
                                }
                        }
                        System.out.print("Cell Buttons Reset\n");
                        btnOption.setText("Generate");
                        btnOption.setActionCommand("Generate");
                        btnOption.setToolTipText("Click this button to generate a solution");
                        Initial.ZeroTable();
                        System.out.print("Initial Table Zeroed\n");
                        restart();
                        System.out.print("Restart Called\n\n");
                }
        }

        static void Update()
        {
                One.Update(1);
                Two.Update(2);
                Three.Update(3);
                Four.Update(4);
                Five.Update(5);
                Six.Update(6);
                Seven.Update(7);
                Eight.Update(8);
                Nine.Update(9);
                Possibilities.Update();
        }
   
        static void restart()
        {
                Sudoku.One.Initialise(1);
                Sudoku.Two.Initialise(2);
                Sudoku.Three.Initialise(3);
                Sudoku.Four.Initialise(4);
                Sudoku.Five.Initialise(5);
                Sudoku.Six.Initialise(6);
                Sudoku.Seven.Initialise(7);
                Sudoku.Eight.Initialise(8);
                Sudoku.Nine.Initialise(9);
                Sudoku.Final.setTable();
        }
}

class Numbers
{
        int[][]Table = new int[9][9];
   
        public Numbers(int value) 
        {
                Initialise(value);
        }
   
        void Initialise(int value)
        {
                for(int row=0; row<9; row++)      //Nested for loops used
                {                                  //to address each cell
                        for(int col=0; col<9; col++)  //of the objects table
                        {
                                Table[row][col]=value;
                        }
                }
        }

        void Update(int value)  //Update the strings table to show which values are still available for the puzzle
        {
                for(int row=0; row<9; row++)
                {
                        for(int col=0; col<9; col++)
                        {
                                boolean rowcon;
                                boolean colcon;
                                if(Sudoku.Final.Table[row][col]>0)Table[row][col] = 0;
                                rowcon  = Sudoku.Final.getRow(row, value);      //Check the current row for the table value
                                if(rowcon==true) Table[row][col] = 0;
                                colcon  = Sudoku.Final.getCol(col, value);      //Check the current col for the table value
                                if(colcon==true) Table[row][col] = 0;
                                boolean square  = Sudoku.Final.getSquare(row, col, value); //Check the square the cell is in for the table value
                                if(square==true) Table[row][col] = 0;
                        }
                }
        }
   
        void Zero(int row, int col) //Redundant, but can be used to speed up processing
        {
                Table[row][col] = 0;
        }
}

---

Code:

---

class Strings
{
        static String[][]Table = new String[9][9];
       
        String One, Two, Three, Four, Five, Six, Seven, Eight, Nine;
        public Strings()
        {
                Update();
        }
   
        void Update()
        {       
                for(int row=0; row<9; row++)
                {
                        for(int col=0; col<9; col++)
                        {
                                if(Sudoku.One.Table[row][col]==1)One="1"; else One="";
                                if(Sudoku.Two.Table[row][col]==2)Two="2"; else Two="";
                                if(Sudoku.Three.Table[row][col]==3)Three="3"; else Three="";
                                if(Sudoku.Four.Table[row][col]==4)Four="4"; else Four="";
                                if(Sudoku.Five.Table[row][col]==5)Five="5"; else Five="";
                                if(Sudoku.Six.Table[row][col]==6)Six="6"; else Six="";
                                if(Sudoku.Seven.Table[row][col]==7)Seven="7"; else Seven="";
                                if(Sudoku.Eight.Table[row][col]==8)Eight="8"; else Eight="";
                                if(Sudoku.Nine.Table[row][col]==9)Nine="9"; else Nine="";
                                Table[row][col]  = One+Two+Three+Four+Five+Six+Seven+Eight+Nine;
                        }
                }
        }
}

class Solution
{
        static Random generator = new Random();
        int[][]Table = new int[9][9];
   
        public Solution()
        {
                ZeroTable();
        }
   
        void setTable()
        {
                Table=Sudoku.Initial.Table;
                Sudoku.Update();
        }
   
        void ZeroTable()
        {
                for(int row=0;row<9;row++)
                {
                        for(int col=0; col<9; col++)
                        {
                                Table[row][col]=0;
                        }
                }
        }
   
        void Generate()
        {
                while(containsZeros()==true)///infinate loop here, unsure why?
                {
                        genCell();
                        System.out.print("\tgencell called\n");
                        Sudoku.Update();
                        System.out.print("\tUpdate all tables and possibilities\n");
                }
        }
   
        private void genCell()
        {
                int row=0, col=0, cellLength=9;
               
                for(int r=0; r<9; r++)  //Following for loops used to choose the cell with the minimum possibilities
                {
                        for(int c=0; c<9; c++)
                        {
                                if(Sudoku.Possibilities.Table[r][c].length()<cellLength)
                                {
                                        if(Sudoku.Possibilities.Table[r][c].length()==0){}
                                        else
                                        {
                                                cellLength = Sudoku.Possibilities.Table[r][c].length();
                                                row = r;
                                                col = c;
                                        }
                                }
                        }
                }
         
                int value=0, index=0, length=Sudoku.Possibilities.Table[row][col].length();
                if(length>0)
                {
                        index=generator.nextInt(length);
                        value = Sudoku.Possibilities.Table[row][col].charAt(index);//This returns the ascii code of the char at point index
                }
                else
                {
                        Sudoku.restart();
                }       
       
                //Convert the ascii code to its char equivelent but as an integer using these else if statements
                if(value=='1')value=1;
                else if(value=='2')value=2;
                else if(value=='3')value=3;   
                else if(value=='4')value=4;
                else if(value=='5')value=5;
                else if(value=='6')value=6;   
                else if(value=='7')value=7;
                else if(value=='8')value=8;
                else if(value=='9')value=9;
       
                Table[row][col]=value;
        }

        private boolean containsZeros()
        {
                boolean contains=false;
                int attempts=0;
                for(int row=0; row<9; row++)
                {
                        for(int col=0; col<9; col++)
                        {
                                if(Table[row][col]==0)
                                {
                                        contains=true;
                                        System.out.print("\t\tIt contains zeros... col=" +col+ "... row="+row+"\n");
                                }
                                attempts+=1;
                               
                        }
                       
                }
                return(contains);
        }
   
        boolean getRow(int row, int value)
        {
                boolean contains=false, end=false;
                int col=0;
                while(contains==false && end==false)
                {
                        if(Sudoku.Final.Table[row][col]==value) contains = true;
                        else contains = false;
                        col++;
                        if(col>8) end=true;
                }
                return(contains);
        }
   
        boolean getCol(int col, int value)
        {
                boolean contains=false, end=false;
                int row=0;
                while(contains==false && end==false)
                {
                        if(Sudoku.Final.Table[row][col]==value) contains = true;
                        row++;
                        if(row>8) end=true;
                }
                return(contains);
        }
   
        boolean getSquare(int row, int col, int value)
        {
                boolean contains=false;
                if(row==0 || row==1 || row==2)
                {
                        if(col==0 || col==1 || col==2)
                        {
                                contains=checkSquare(0, 0, value);
                        }
                        if(col==3 || col==4 || col==5)
                        {
                                contains=checkSquare(0, 3, value);
                        }
                        if(col==6 || col==7 || col==8)
                        {
                                contains=checkSquare(0, 6, value);
                        }
                }
                if(row==3 || row==4 || row==5)
                {
                        if(col==0 || col==1 || col==2)
                        {
                                contains=checkSquare(3, 0, value);
                        }
                        if(col==3 || col==4 || col==5)
                        {
                                contains=checkSquare(3, 3, value);
                        }
                        if(col==6 || col==7 || col==8)
                        {
                                contains=checkSquare(3, 6, value);
                        }
                }
                if(row==6 || row==7 || row==8)
                {
                        if(col==0 || col==1 || col==2)
                        {
                                contains=checkSquare(6, 0, value);
                        }
                        if(col==3 || col==4 || col==5)
                        {
                                contains=checkSquare(6, 3, value);
                        }
                        if(col==6 || col==7 || col==8)
                        {
                                contains=checkSquare(6, 6, value);
                        }
                }
                return(contains);
        }

        public void Print()
        {
                System.out.print(" ------- ------- -------        \n");
                for(int row=0; row<9; row++)
                {
                        System.out.print("| ");
                        for(int col=0; col<9; col++)
                        {
                                System.out.print(+ Table[row][col] + " ");
                                if(col==2||col==5||col==8)System.out.print("| ");
                        }
                        System.out.print("\n");
                        if(row==2||row==5||row==8)System.out.print(" ------- ------- -------        \n");
                }
                System.out.print("\n");
        }
   
        boolean checkSquare(int row, int col, int value)
        {
                boolean contains=false;
                int r0w=row, c0l=col;
                for(int n=0; n<9; n++)
                {
                        if(Sudoku.Final.Table[r0w][c0l]==value)
                        {
                                contains = true;
                                break;
                        }
                        if(++c0l > col+2)
                        {
                                c0l=col;
                                r0w++;
                        }
                }
                return(contains);
        }
}

---

I appreciate I may not get any replies here due to the large nature of the code