Hi Rhino,

Please know that I tried many different ways  to "get the complete
final answer" to display. But nothing seemed to work except as written
in the program.

At your request, here is the complete program. It compiles without
error.

import java.util.*;

public class Sudoku
{
   private Cell[][] squareContents;
   private ArrayList<Cell> remainingCells = new ArrayList<Cell>();
   private int lastSort;

   // Used to sort the cells in order of remaining possibilities.
   private class CellComparator implements Comparator<Cell>
   {
       public int compare(Cell cell1,Cell cell2)
       {
           return cell2.digitRuledOutCount - cell1.digitRuledOutCount;

       }
   }

   private CellComparator comp = new CellComparator();
   public static void main(String args[])
   {
       Sudoku sudoku = new Sudoku();
       System.out.println("Here 1");
       sudoku.test();

       System.out.println("Here 2");
       sudoku.test2();

   }

   // Information about a single cell.
   public class Cell
   {
       private int x;
       private int y;
       public int inSquare;
       public int[] digitRuledOut;
       public int digitRuledOutCount;
       public int value;

       public Cell(int x,int y)
       {
           this.x = x;
           this.y = y;
           this.inSquare = 3 * (x / 3) + (y / 3);
           this.digitRuledOutCount = 9;
           this.digitRuledOut = new int[10];
           this.value = 0;
       }

       // Rules out digit v in this cell.
       private boolean ruleOutDigit(int v,int depth)
       {
           if (value == 0 && digitRuledOut[v] == 0)
           {
               digitRuledOut[v] = depth;
               if (--digitRuledOutCount == 0)
                   return true;
           }
           return false;
       }

       // Rules in digit v in this cell.
       private void ruleInDigit(int v,int depth)
       {
           if (digitRuledOut[v] == depth)
           {
               digitRuledOut[v] = 0;
               digitRuledOutCount++;
           }
       }

       // Sets the value of this cell and rules it out in other cells.

       public boolean setValue(int value,int depth)
       {
           this.value = value;
           for(int i = 0; i < 9; i++)
           {
               if (board[x][i].ruleOutDigit(value,depth))
                   return true;
               if (board[i][y].ruleOutDigit(value,depth))
                   return true;
               if
(squareContents[inSquare][i].ruleOutDigit(value,depth))
                   return true;
           }
           return false;
       }

       // Erases the value of this cell, ruling it in in other cells.
       public void eraseValue(int depth)
       {
           for(int i = 0; i < 9; i++)
           {
               board[x][i].ruleInDigit(value,depth);
               board[i][y].ruleInDigit(value,depth);
               squareContents[inSquare][i].ruleInDigit(value,depth);
           }

           this.value = 0;
       }
   }

   public Cell[][] board;

   // Initialize the solver.
   public boolean solve(int[][] initBoard)
   {
       board = new Cell[9][9];
       squareContents = new Cell[9][9];
       int[] squareCount = new int[9];

       for(int x = 0; x < 9; x++)
           for(int y = 0; y < 9; y++)
       {
           Cell c = new Cell(x,y);
           board[x][y] = c;
           squareContents[c.inSquare][squareCount[c.inSquare]++] =
               board[x][y];

       }

       for(int x = 0; x < 9; x++)
           for(int y = 0; y < 9; y++)
           if (initBoard[x][y] > 0)
           board[x][y].setValue(initBoard[x][y],100);
       else
           remainingCells.add(board[x][y]);

       Collections.sort(remainingCells,comp);
       return backtrack(1);
   }

   // The backtracking search algorithm.
   public boolean backtrack(int depth)
   {
       if (remainingCells.isEmpty())
           return true;
       if (depth == lastSort + 5 || depth == lastSort - 5)
       {
           Collections.sort(remainingCells,comp);
           lastSort = depth;
       }
       Cell current =
(Cell)remainingCells.remove(remainingCells.size()-1);

       for(int v = 1; v <= 9; v++)
       {
           if (current.digitRuledOut[v] != 0)
               continue;

           if (current.setValue(v,depth))
               current.eraseValue(depth);
           else
           {
               if (backtrack(depth + 1))
                   return true;

               current.eraseValue(depth);
           }
       }

       remainingCells.add(current);
       return false;
   }

   // A few test boards.
   public void test()
   {
       int[][] testBoard = { {0,6,0,1,0,4,0,5,0},
           {0,0,8,3,0,5,6,0,0},
           {2,0,0,0,0,0,0,0,1},

           {8,0,0,4,0,7,0,0,6},
           {0,0,6,0,0,0,3,0,0},
           {7,0,0,9,0,1,0,0,4},

           {5,0,0,0,0,0,0,0,2},
           {0,0,7,2,0,6,9,0,0},
           {0,4,0,5,0,8,0,7,0} };

       solve(testBoard);
       int c=0;
       for(int xc = 0; xc< 9; xc++){
           for(int yc = 0; yc < 9; yc++){
               System.out.println(c+". "+ board[xc][yc]);
               c++;
           }
       }
   }

   public void test2()
   {
       int[][] testBoard = { {0,0,0,0,0,0,0,3,8},
           {0,2,3,4,0,8,0,0,0},
           {0,8,0,5,2,0,1,0,9},

           {0,0,0,6,7,4,0,5,0},
           {0,0,0,0,0,0,0,0,0},
           {0,1,0,3,5,9,0,0,0},

           {1,0,5,0,4,7,0,9,0},
           {0,0,0,9,0,2,7,1,0},
           {2,9,0,0,0,0,0,0,0} };
       solve(testBoard);
       int d = 0;
       for(int xc = 0; xc< 9; xc++){
           for(int yc = 0; yc < 9; yc++){
               System.out.println(d+". "+ board[xc][yc]);
               d++;
           }
       }
   }
}

Thanks to all of you.

Looking at this original program, it is the most "?" that I have ever
seen. I truly
appreciate  your help, IchBin and others for  getting the solution to
be printed out.

As by changed design, I have done revisions by reading "in.txt" file
and after processing
writing an "out.txt" file.  Should there be an error/revisions in the
input then it can be
corrected by accessing the "in.txt" without doing a large amount of re
entering of the 81
numbers.

Thanks again,

Bob

import java.util.*;
import java.io.*;

public class SudokuReadWriteFile
{
   private Cell[][] squareContents;
   private ArrayList<Cell> remainingCells = new ArrayList<Cell>();
   private int lastSort;

   // Used to sort the cells in order of remaining possibilities.
   private class CellComparator implements Comparator<Cell>
   {
       public int compare(Cell cell1,Cell cell2)
       {
           return cell2.digitRuledOutCount - cell1.digitRuledOutCount;
       }
   }

   private CellComparator comp = new CellComparator();

   // main
   public static void main(String args[] ) throws Exception
   {
       SudokuReadWriteFile sudokrw = new SudokuReadWriteFile();
       //System.out.println("Here 1");
       sudokrw.test();
   }

   // Information about a single cell.
   public class Cell
   {
       private int x;
       private int y;
       public int inSquare;
       public int[] digitRuledOut;
       public int digitRuledOutCount;
       public int value;

       public Cell(int x,int y)
       {
           this.x = x;
           this.y = y;
           this.inSquare = 3 * (x / 3) + (y / 3);
           this.digitRuledOutCount = 9;
           this.digitRuledOut = new int[10];
           this.value = 0;

       }

       // Rules out digit v in this cell.
       private boolean ruleOutDigit(int v,int depth)
       {
           if (value == 0 && digitRuledOut[v] == 0)
           {
               digitRuledOut[v] = depth;
               if (--digitRuledOutCount == 0)
                   return true;
           }
           return false;
       }

       // Rules in digit v in this cell.
       private void ruleInDigit(int v,int depth)
       {
           if (digitRuledOut[v] == depth)
           {
               digitRuledOut[v] = 0;
               digitRuledOutCount++;
           }
       }

       // Sets the value of this cell and rules it out in other cells.
       public boolean setValue(int value,int depth)
       {
           this.value = value;
           for(int i = 0; i < 9; i++)
           {
               if (board[x][i].ruleOutDigit(value,depth))
                   return true;
               if (board[i][y].ruleOutDigit(value,depth))
                   return true;
               if
(squareContents[inSquare][i].ruleOutDigit(value,depth))
                   return true;
           }
           return false;
       }

       // Note : Added this to extract value of cell
       public int getCellValue( ) {
           return this.value;
       }

       // Erases the value of this cell, ruling it in in other cells.
       public void eraseValue(int depth)
       {
           for(int i = 0; i < 9; i++)
           {
               board[x][i].ruleInDigit(value,depth);
               board[i][y].ruleInDigit(value,depth);
               squareContents[inSquare][i].ruleInDigit(value,depth);
           }
           this.value = 0;
       }
   }

   public Cell[][] board;
   // Initialize the solver.
   public boolean solve(int[][] initBoard)
   {
       board = new Cell[9][9];
       squareContents = new Cell[9][9];
       int[] squareCount = new int[9];

       for(int x = 0; x < 9; x++)
           for(int y = 0; y < 9; y++)
       {
           Cell c = new Cell(x,y);
           board[x][y] = c;
           squareContents[c.inSquare][squareCount[c.inSquare]++] =
               board[x][y];
       }

       for(int x = 0; x < 9; x++)
           for(int y = 0; y < 9; y++)
           if (initBoard[x][y] > 0)
           board[x][y].setValue(initBoard[x][y],100);
       else
           remainingCells.add(board[x][y]);

       Collections.sort(remainingCells,comp);
       return backtrack(1);
   }

   // The backtracking search algorithm.
   public boolean backtrack(int depth)
   {
       if (remainingCells.isEmpty())
           return true;
       if (depth == lastSort + 5 || depth == lastSort - 5)
       {
           Collections.sort(remainingCells,comp);
           lastSort = depth;
       }
       Cell current =
(Cell)remainingCells.remove(remainingCells.size()-1);

       for(int v = 1; v <= 9; v++)
       {
           if (current.digitRuledOut[v] != 0)
               continue;

           if (current.setValue(v,depth))
               current.eraseValue(depth);
           else
           {
               if (backtrack(depth + 1))
                   return true;

               current.eraseValue(depth);
           }
       }

       remainingCells.add(current);
       return false;
   }
   // get stored file
   public void test()
   {
       try{
           FileInputStream  fis= new FileInputStream("MySudoku.txt");
           BufferedReader bor = new BufferedReader(new
InputStreamReader(fis));
           String str ="";
           int[][] testBoard= new int[9][9];
           for(int i=0; i<9; i++) {
               str = bor.readLine();
               for(int j=0; j<9; j++){
                   testBoard[i][j] =
Integer.parseInt(str.substring(j, j+1));
                   System.out.println (testBoard[i][j]);

               }
           }
           bor.close();
           solve(testBoard);

       }
       catch (Exception e) {
           System.out.println("error getting data");
       }

       // be sure to add above    public int getCellValue( ) {  return
this.value; }
       // Getting output, saving it to file and showing it in the
System.out.

       System.out.println("Saving TestBoard 1");

       try {
           FileOutputStream  fos= new
FileOutputStream("MySudokuSolution.txt");
           BufferedWriter bow = new BufferedWriter(new
OutputStreamWriter(fos));
           bow.write("{");
           for(int xc = 0; xc< 9; xc++){
               bow.write("{");
               for(int yc = 0; yc < 9; yc++){
                   if(yc == 8){
                       bow.write( board[xc][yc].getCellValue( )+" ");
                   }
                   else  bow.write( board[xc][yc].getCellValue(
)+",");
               }
               if(xc == 8){
                   bow.write( "}}"+"\n"+"\n");
               }
               else bow.write( "},"+"\n"+"\n");
           }
           bow.close();
       }
       catch (IOException ioe) {
           System.out.println("IOException writing
MySudokuSolution.txt");
       }

       System.out.println("Show System Out of TestBoard 1");

       System.out.print("{");
       for(int xc = 0; xc< 9; xc++){
           System.out.print("{");
           for(int yc = 0; yc < 9; yc++){
               if(yc== 8){
                   System.out.print( board[xc][yc].getCellValue( ));
               }
               else  System.out.print( board[xc][yc].getCellValue(
)+",");
           }
           if(xc== 8){
               System.out.print( "}}"+"\n");
           }
           else System.out.println( "},");
       }
   }
}
MySudoku.txt

060104050
008305600
200000001
800407006
006000300
700901004
500000002
007206900
040508070

MySudokuSolution.txt

{{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 }}