中文數字轉阿拉伯數字

想上面的數字一樣，假設我們的中文數字是【一億七千七十九萬七千一百九十七】，

解題思路

首先我們需要將上面中文數字按阿拉伯數字進行分離，這里我們先提出一個思想前提：億、萬這種是高級單位；千、百、十這種是低級單位，所以我們先按高級單位將上面的進行拆分，

我們得到上面的三個數字，分別是【一億】、【七千零七十九萬】、【七千一百九十七】，下面我們針對這三個數字進行翻譯，

各個擊破

仔細分析下上面三個中文數字，不難得出結論-上面三個數字去掉高級單位剩下的都只有低級單位了，這也是我們實作的重點【低級單位內的數字轉換】
我們將三個數字分別轉換完成之后，剩下的就是將他們組合，組合的問題也就是中間補零和去零的操作，
【七千零七十九萬】去掉高級單位【七千零七十九】我們翻譯也很簡單就是將低級單位去掉變成【七零七九】及【7079】，那么上面的三位數字分別是

中文數字	去掉單位后	數字映射
一億	一	1
七千零七十九萬	七零七九	7079
七千一百九十七	七一九七	7197

三位數字翻譯好之后我們進行阿拉伯數字的拼接就完成了， 170797197

友情提醒

上面的數字翻譯的很是順利，但是又這么一類數字總是事與愿違，
【一億零七十九萬零一百九十七】==【100790197】
按照上面的思路我們會有如有推理

中文數字	去掉單位后	數字映射
一億	一	1
零七十九萬	零七九	079
零一百九十七	零一九七	0197

根據表格我們拼接得到的數字是【10790197】，這個時候問題就大了去了，我們丟失了一位0，原因也很簡單在中文數字中在同一高級單位維度里連續多個零的出現會同一讀零，但是阿拉伯數字中確實實實在在的占位的，所以這里就會缺失一位零，
這里的情況是一開始筆者沒喲注意到的，但是后來改正了，所以上面提到的合并方法是沒有問題的，上面是進行數字化乘以10000的，所以這里的0也不會丟失的，
正確的拼接方案是 ((110000)+079)10000+0197=100790197
這種問題反向過來同樣值得注意，在阿拉伯轉中文數字的時候我們需要注意0到底代表幾個0

阿拉伯數字轉中文數字

【100790197】 ==【一億零七十九萬零一百九十七】
【100000197】 ==【一億零一百九十七】
下面我們將對上面的兩個阿拉伯數字進行決議轉換，同樣我們對他們進行高位分離，這里需要注意的是我們需要從低位到高位方向進行分離

分離是從低位到高位，但是我們轉換卻要從高位到低位，順序不能錯，在我們阿拉伯數字轉中文數字的時候非零數字注解映射轉換就行了，但是遇到0的時候我們需要有一下三個條件才能轉換，否則就要忽略，
- 第一次遇到0
- 數字為0
- 統一高位單元內后面并不是全是0
簡單解釋下上面三個，第一個通過一個狀態為就能搞定，第二個其實就是保險點，可有可無，最重要第三點遇零后后面不能全是0.這個時候我們才可以將當前位置0翻譯成零，
每個非零數字翻譯后需要加上低級單位的，
所以上面的0079我們翻譯的是【零七十九】
但是零七九并不是真正的漢字數字，所以我們在每一次高位翻譯完成之后需要加上高位單位，所以【0079】==【零七十九萬】
所以我們得出如下

阿拉伯數字	數字映射
1	一億
0079	零七十九萬
0197	零一百九十七

所以【100790197】 ==【一億零七十九萬零一百九十七】

阿拉伯數字	數字映射
1	一億
0000
0197	零一百九十七

在加入高級單位時我們需要判斷高級單位內數字是否有效，因為我們上面三個原因，所以0000對應的中文數字就是空字串，這里我們認為是無效中文數字，所以萬單位也就沒有了，所以【100000197】==【一億零一百九十七】

測驗

光談理論不講實踐都是扯淡，下面我們需要對我們的設計進行驗證，如何驗證嗯，好在我們實作的【中文數字轉阿拉伯數字】、【阿拉伯數字轉中文數字】，那么我們直接通過兩個方法相互轉換，看看最終是不是原來的資料就能驗證出來了，話不多說、上代碼


Integer right = 0;
Integer total = 10000000;
List<Map<String, Object>> list = new ArrayList<>();
for (int i = 0; i < total; i++) {
    Integer number = MathUtil.getInstance().getRandom(1, 1000000000);
    //System.out.println(i);
    //Integer number = 400001989;
    String chinese = DigitUtil.getInstance().getNumberFromAlabo(number.toString());
    String alabo = DigitUtil.getInstance().getNumberFromChinese(chinese);
    boolean equals = alabo.equals(number.toString());
    if (equals) {
        right++;
    } else {
        Map<String, Object> map  = new HashMap<>();
        map.put("number", number);
        map.put("alabo", alabo);
        map.put("chinese", chinese);
        list.add(map);
    }
}
for (Map<String, Object> map : list) {
    System.out.println(map);
}
System.out.println("成功率："+Double.valueOf(right/(double)total));

測驗后的正確率是1 ，也就是0差錯，
歡迎指出錯誤，

原始碼


package org.zxhtom.utils;

import org.zxhtom.constant.ChineseNumber;

import java.util.*;

/**
 * @package org.zxhtom.utils
 * @Class DigitUtil
 * @Description 數字工具類
 * @Author zhangxinhua
 * @Date 19-7-2 下午3:47
 */
public class DigitUtil {
    private static DigitUtil util;

    public static DigitUtil getInstance() {
        if (null == util) {
            util = new DigitUtil();
        }
        return util;
    }

    /**
     * 中文數字轉阿拉伯數字
     *  一萬兩千三百五十四 --> 12354
     * @param chinese 阿拉伯數字
     * @return 中文數字
     */
    public String getNumberFromChinese(String chinese) {
        String result = "0";
        //將中文數字按四位進行截取，這樣每一位里只有單一
        List<String> lists = new ArrayList<>();
        //暫時未使用到
        int lastLevelIndex = 0;
        //回圈遍歷，目的是將億萬進行分離
        for (int i =  ChineseNumber.highLevel.size()-1; i>=0; i--) {
            //判斷億萬單位出現索引
            int levelIndex = chinese.indexOf(ChineseNumber.highLevel.get(i));
            if (levelIndex>0) {
                //表示有單位索引 ， 將單位前資料進行截取裝入lists中，后面的繼續回圈截取
                lists.add(chinese.substring(0, levelIndex));
                chinese = chinese.substring(levelIndex+1);
            } else if (levelIndex == -1) {
                //表示已經是最低單位了，不超過萬，直接加入lists中 ， 這里情況對應的是高位分離后，次高位開頭是0的情況
                lists.add(ChineseNumber.number.get(0));
            } else if (levelIndex == 0) {
                while (levelIndex > 1) {
                    levelIndex--;
                    lists.add(ChineseNumber.number.get(0));
                }
                //直接加入
                lists.add(chinese);
            }
        }
        //針對分離的四位資料，進行單獨翻譯
        for (int i = 0; i < lists.size(); i++) {
            //未使用
            Integer highLevelIndex = lists.size() - i - 1;
            //獲取單元資料
            String single = lists.get(i);
            //對單元資料進行翻譯 ，
            String nextResult = getNumberFromFChinese(single);
            //lists中每位都是4位數截取 ，所以這里需要乘以10000進行疊加
            Long next = Long.valueOf(Integer.valueOf(result) * (int)(Math.pow(10, 4)) + Integer.valueOf(nextResult));
            result = next.toString();
        }
        //將開頭0抹掉
        result = result.replaceFirst("^(0+)", "");
        return result;
    }

    /**
     * 通過中文數字獲取4位數阿拉伯數字
     * 萬以內的資料轉換
     * @param single
     * @return
     */
    private String getNumberFromFChinese(String single) {
        String result = "0";
        Integer highIndex = 1;
        for (int i = 0; i < single.length(); i++) {
            String str = String.valueOf(single.charAt(i));
            int unit = ChineseNumber.level.indexOf(str);
            int number = ChineseNumber.number.indexOf(str);
            if (unit == -1) {
                //當前數字是萬以內的單位即  千百十其中之一
                int next = 0;
                if (i < single.length() - 1) {
                    //如果不是最后一位，則需要考慮當前位的權重
                    next = ChineseNumber.level.indexOf(String.valueOf(single.charAt(i + 1)));
                }
                result=String.valueOf(Integer.valueOf(result)+number * (int) (Math.pow(10, next)));
            }
        }
        //權重疊加
        result = ""+Integer.valueOf(result) * (int) (Math.pow(10, highIndex - 1));
        return result;
    }

    /**
     * 阿拉伯數字轉中文數字
     * 12354 --> 一萬兩千三百五十四
     * @param alabo 阿拉伯數字
     * @return 中文數字
     */
    public String getNumberFromAlabo(String alabo) {
        String result = "";
        List<String> list = new ArrayList<>();
        for (int length = alabo.length()-1; length >= 0; length--) {
            list.add(String.valueOf(alabo.charAt(length)));
        }
        List<List<String>> lists = CollectionUtil.averageSize(list, 4);
        Collections.reverse(lists);
        if (CollectionUtil.isNotEmpty(lists)) {
            for (int index=0;index<lists.size();index++) {
                List<String> singleNumList = lists.get(index);
                //反轉集合
                Collections.reverse(singleNumList);
                //默認0 false
                Boolean zeroflag =false;
                String chinese = "";
                for (int j=0 ; j<singleNumList.size();j++) {
                    Integer number = Integer.valueOf(singleNumList.get(j));
                    if (number == 0 && !zeroflag && afterNotAllZero(singleNumList, j)) {
                        //第一次遇到0 且后面有小單位內并不是全為0
                        chinese += ChineseNumber.number.get(number);
                        //修改遇零狀態true
                        zeroflag = true;
                    } else if(number!=0) {
                        //映射出對應的中文數字
                        chinese += ChineseNumber.number.get(number) + ChineseNumber.level.get(singleNumList.size()-j-1);
                    }
                }
                if (index==lists.size()&&chinese.substring(0, 1).equals(ChineseNumber.number.get(0))) {
                    //條件永遠不成立，
                    chinese = chinese.substring(1);
                }
                //并不是全部為0，該高級單位才會生效
                if (chinese.length()>0&&!ChineseNumber.highLevel.contains(chinese.substring(chinese.length() - 1))) {
                    result += chinese + ChineseNumber.highLevel.get(lists.size() - 1 - index);
                }
            }
        }
        return result;
    }

    /**
     * 判斷singleNumList在j位置之后是否全是0
     * @param singleNumList
     * @param j
     * @return
     */
    private boolean afterNotAllZero(List<String> singleNumList, int j) {
        for (int i = j+1; i < singleNumList.size(); i++) {
            if (!"0".equals(singleNumList.get(i))) {
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Integer right = 0;
        Integer total = 10000000;
        List<Map<String, Object>> list = new ArrayList<>();
        for (int i = 0; i < total; i++) {
            Integer number = MathUtil.getInstance().getRandom(1, 1000000000);
            //System.out.println(i);
            //Integer number = 400001989;
            String chinese = DigitUtil.getInstance().getNumberFromAlabo(number.toString());
            String alabo = DigitUtil.getInstance().getNumberFromChinese(chinese);
            boolean equals = alabo.equals(number.toString());
            if (equals) {
                right++;
            } else {
                Map<String, Object> map  = new HashMap<>();
                map.put("number", number);
                map.put("alabo", alabo);
                map.put("chinese", chinese);
                list.add(map);
            }
        }
        for (Map<String, Object> map : list) {
            System.out.println(map);
        }
        System.out.println("成功率："+Double.valueOf(right/(double)total));
    }
}

加入戰隊

# 加入戰隊

微信公眾號

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/138058.html

標籤：Java

上一篇：多執行緒，并發編程

下一篇：怎么找出消耗 CPU 的罪魁禍首？！

中文數字阿拉伯數字相互轉換

中文數字轉阿拉伯數字

解題思路

各個擊破

友情提醒

阿拉伯數字轉中文數字

測驗

原始碼

# 加入戰隊

微信公眾號