用Java编码实现，一个数独程序，用九行九列表示九宫格，每行数字以{开始，}结束，数字之间用逗号分隔，已知数字位用X表示，1≤X≤9，空缺位以数字0表示，输出一个包含所有数字的九宫格，与输入格式相同，结尾不包含空行

在Java中，我们可以创建一个类来处理数独的解析、填充和输出。以下是一个基础的数独解决方案，包括读取输入、填充缺失数字并打印解的过程：

import java.util.Scanner;
import java.util.StringTokenizer;

public class SudokuSolver {
    private final int[][] grid; // 数独网格

    public SudokuSolver(String input) {
        grid = new int[9][9];
        parseInput(input);
    }

    private void parseInput(String input) {
        StringTokenizer tokenizer = new StringTokenizer(input, "{");
        for (int i = 0; i < 9; i++) {
            tokenizer.nextToken(); // 跳过{}
            String rowStr = tokenizer.nextToken();
            int[] numbers = new int[9];
            StringTokenizer rowTokenizer = new StringTokenizer(rowStr, ",");
            for (int j = 0; j < 9; j++) {
                if (rowTokenizer.hasMoreTokens()) {
                    numbers[j] = Integer.parseInt(rowTokenizer.nextToken());
                } else if (numbers[j] == 0) { // 空位
                    break;
                }
            }
            for (int k = 0; k < 9 && numbers[k] != 0; k++) {
                grid[i][k] = numbers[k];
            }
        }
    }

    // 填充剩余位置（这里仅作简单示例，实际填充算法需要更复杂）
    public boolean solve() {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (grid[i][j] == 0) {
                    for (int num = 1; num <= 9; num++) {
                        if (isValid(i, j, num)) {
                            grid[i][j] = num;
                            if (solve()) {
                                return true;
                            } else {
                                grid[i][j] = 0; // 回溯
                            }
                        }
                    }
                    return false;
                }
            }
        }
        return true;
    }

    private boolean isValid(int row, int col, int num) {
        // 检查行、列以及3x3的小宫格内是否已经有num
        for (int i = 0; i < 9; i++) {
            if (grid[row][i] == num || grid[i][col] == num || getSubGridValue(row - row % 3, col - col % 3, num) > 0) {
                return false;
            }
        }
        return true;
    }

    private int getSubGridValue(int subRow, int subCol, int num) {
        for (int i = subRow * 3; i < subRow * 3 + 3; i++) {
            for (int j = subCol * 3; j < subCol * 3 + 3; j++) {
                if (grid[i][j] == num) {
                    return 1;
                }
            }
        }
        return 0;
    }

    public String outputSolution() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                sb.append(grid[i][j]);
                if (j != 8) {
                    sb.append(",");
                }
            }
            sb.append("{\n");
        }
        return sb.toString().trim();
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入数独（例如：{1,2,3,4,5,6,7,8,0}{0,0,0,0,0,0,0,0,0}{...}）：");
        String input = scanner.nextLine();
        SudokuSolver solver = new SudokuSolver(input);
        solver.solve();
        System.out.println(solver.outputSolution());
    }
}

在这个例子中，我们首先解析输入字符串，然后尝试填写每个空位，如果遇到无法填入的情况，则回溯到上一步，直到找到一个合法的解。最后，我们输出完整的解决后的数独。

请注意，这只是一个基本的解决方案，实际的数独算法通常会使用更为复杂的搜索策略，如A*搜索或递归回溯等。