Java 字符串轉 Double 二維數組：FastJSON 解析與手寫解析器雙重方案

在數據交換、配置解析、科學計算場景中，常需將類 JSON 格式的字符串轉換為 double[][] 二維數組。本文對比 FastJSON 自動映射與手寫解析器兩種方案，分析性能、健壯性、依賴體積差異，提供生產級代碼模板。

問題定義

String input = "{{10.14, 11.24, 44.55, 41.01},{12.10, 14.21, 52.14, 50.44},{14.44, 16.12, 45.42, 47.55}}";
// 目標：double[][] 
// [[10.14, 11.24, 44.55, 41.01],
//  [12.10, 14.21, 52.14, 50.44],
//  [14.44, 16.12, 45.42, 47.55]]

輸入特徵：雙層大括號、逗號分隔、可選空格、數值為十進制浮點數。

方案一：FastJSON 零代碼映射 (推薦生產環境)

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.47</version> <!-- 或 1.2.83 -->
</dependency>

public class FastJsonArrayParser {
    public static double[][] parse(String input) {
        // 1. 統一大括號為中括號 (JSON 標準數組語法)
        String json = input.replace('{', '[').replace('}', ']');
        
        // 2. 直接反序列化為 String[][] (FastJSON 智能類型轉換)
        String[][] strArr = JSON.parseObject(json, String[][].class);
        
        // 3. 轉換為 double[][]
        double[][] result = new double[strArr.length][];
        for (int i = 0; i < strArr.length; i++) {
            result[i] = new double[strArr[i].length];
            for (int j = 0; j < strArr[i].length; j++) {
                result[i][j] = Double.parseDouble(strArr[i][j].trim());
            }
        }
        return result;
    }
    
    // 一行代碼版 (FastJSON 2.x 支援直接解析為基本類型數組)
    public static double[][] parseV2(String input) {
        return JSON.parseObject(input.replace('{', '[').replace('}', ']'), double[][].class);
    }
}

FastJSON 優勢

• 零樣板代碼：自動處理空格、換行、科學計數法、null 值
• 高性能：ASM 字節碼生成、對象池復用、單次遍歷解析
• 健壯性：完善的錯誤提示、容錯解析模式 JSON.parseObject(json, double[][].class, Feature.TolerateError)
• 擴展性：支援 List<List<Double>>、Double[][]、自定義反序列化器

方案二：手寫流式解析器 (零依賴、極致性能、教學價值)

public class ManualArrayParser {
    
    public static double[][] parse(String input) {
        // 預處理：移除外層大括號、統一分隔符
        String s = input.trim();
        if (s.startsWith("{") && s.endsWith("}")) {
            s = s.substring(1, s.length() - 1);
        }
        
        // 分割行：按 "},{" 或 "},{"
        String[] rows = s.split("\\}\\s*,\\s*\\{");
        
        double[][] result = new double[rows.length][];
        for (int i = 0; i < rows.length; i++) {
            String row = rows[i].replace("{", "").replace("}", "").trim();
            if (row.isEmpty()) {
                result[i] = new double[0];
                continue;
            }
            
            // 分割列
            String[] cols = row.split("\\s*,\\s*");
            result[i] = new double[cols.length];
            for (int j = 0; j < cols.length; j++) {
                result[i][j] = Double.parseDouble(cols[j]);
            }
        }
        return result;
    }
    
    // 單次遍歷版 (更高性能，適合超大數據)
    public static double[][] parseStreaming(String input) {
        List<double[]> rows = new ArrayList<>();
        double[] currentRow = null;
        StringBuilder numBuf = new StringBuilder();
        boolean inNumber = false;
        
        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            
            if (c == '{') {
                currentRow = new double[16]; // 初始容量
                rows.add(currentRow);
            } else if (c == '}') {
                if (inNumber) {
                    currentRow = appendNumber(currentRow, rows.size()-1, numBuf);
                    numBuf.setLength(0);
                    inNumber = false;
                }
                // 行結束，可選擇 trimToSize
            } else if (c == ',') {
                if (inNumber) {
                    currentRow = appendNumber(currentRow, rows.size()-1, numBuf);
                    numBuf.setLength(0);
                    inNumber = false;
                }
            } else if (Character.isDigit(c) || c == '.' || c == '-' || c == 'e' || c == 'E') {
                numBuf.append(c);
                inNumber = true;
            }
            // 忽略空格、換行等
        }
        
        // 轉換 List 為 double[][]
        double[][] result = new double[rows.size()][];
        for (int i = 0; i < rows.size(); i++) {
            result[i] = Arrays.copyOf(rows.get(i), getActualLength(rows.get(i)));
        }
        return result;
    }
    
    private static double[] appendNumber(double[] arr, int rowIdx, StringBuilder buf) {
        // 擴容邏輯省略...
        return arr;
    }
}

方案對比測試

生產環境最佳實踐

1. 統一工具類封裝

public final class ArrayUtils {
    private ArrayUtils() {}
    
    public static double[][] parseDoubleMatrix(String input) {
        if (input == null || input.trim().isEmpty()) return new double[0][];
        try {
            return FastJsonArrayParser.parse(input);
        } catch (Exception e) {
            log.warn("FastJSON 解析失敗，嘗試手寫解析: {}", input, e);
            return ManualArrayParser.parse(input); // 降級
        }
    }
    
    public static String toJson(double[][] matrix) {
        return JSON.toJSONString(matrix); // 輸出標準 JSON 格式 [[...],[...]]
    }
}

2. 輸入驗證與防禦性編程

public static double[][] safeParse(String input, int maxRows, int maxCols) {
    if (input == null) throw new IllegalArgumentException("Input cannot be null");
    
    double[][] result = parseDoubleMatrix(input);
    
    if (result.length > maxRows) 
        throw new IllegalArgumentException("Row count exceeds limit: " + maxRows);
    
    for (double[] row : result) {
        if (row.length > maxCols)
            throw new IllegalArgumentException("Column count exceeds limit: " + maxCols);
        for (double v : row) {
            if (Double.isNaN(v) || Double.isInfinite(v))
                throw new IllegalArgumentException("Invalid number: " + v);
        }
    }
    return result;
}

3. 異常信息豐富化

try {
    return parseDoubleMatrix(input);
} catch (NumberFormatException e) {
    // 定位具體行列
    throw new ParseException("第 " + (row+1) + " 行第 " + (col+1) + " 列數值格式錯誤: " + val, e);
} catch (IndexOutOfBoundsException e) {
    throw new ParseException("數組維度不匹配或輸入格式異常", e);
}

擴展場景

• 三維數組：double[][][]，FastJSON 直接支援 JSON.parseObject(json, double[][][].class)
• 稀疏矩陣：Map<Long, Double> key = (row << 32) | col
• CSV 格式：1.1,2.2,3.3\n4.4,5.5,6.6，用 CSVParser 或 String.split("\n") 處理
• 科學計算庫整合：ND4J Nd4j.create(jsonString)、EJML、Apache Commons Math

總結

生產環境首選 FastJSON：依賴成熟、代碼極少、性能優異、容錯強。手寫解析器適合：嵌入式設備無依賴要求、極致性能敏感場景、教學演示解析器原理。核心技巧統一為：預處理統一格式 → 分層分割 (行/列) → 類型轉換 → 防禦性檢查。建議封裝為工具類統一入口，內部可根據項目依賴策略選擇實現，對外提供穩定 API。