浮点型数字转换为中文人民币格式-Java

于 2022-12-28 17:47:35 发布
阅读量451 收藏 1
点赞数
分类专栏： How to Solve 文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38233104/article/details/128471949
版权 

import java.util.Scanner;

/**
 * @author Green.Gee
 * @date 2022/12/26 14:00
 * @email green.gee.lu@gmail.com
 */
public class ConvertRMB {

    /**
     * 描述
     * 1、中文大写金额数字前应标明“人民币”字样。
     * 中文大写金额数字应用壹、贰、叁、肆、伍、陆、柒、捌、玖、拾、佰、仟、万、亿、元、角、分、零、整等字样填写。
     * <p>
     * 2、中文大写金额数字到“元”为止的，在“元”之后，应写“整字，
     * 如532.00应写成“人民币伍佰叁拾贰元整”。在”角“和”分“后面不写”整字。
     * <p>
     * 3、阿拉伯数字中间有“0”时，中文大写要写“零”字，阿拉伯数字中间连续有几个“0”时，中文大写金额中间只写一个“零”字，
     * 如6007.14，应写成“人民币陆仟零柒元壹角肆分“。
     * <p>
     * 4、10应写作“拾”，100应写作“壹佰”。
     * 例如，1010.00应写作“人民币壹仟零拾元整”，110.00应写作“人民币壹佰拾元整”
     * <p>
     * 5、十万以上的数字接千不用加“零”，
     * 例如，30105000.00应写作“人民币叁仟零拾万伍仟元整”
     * <p>
     * 输入描述：
     * 输入一个double数
     * <p>
     * 输出描述：
     * 输出人民币格式
     * <p>
     * 示例1
     * 输入：
     * 151121.15
     * 复制
     * 输出：
     * 人民币拾伍万壹仟壹佰贰拾壹元壹角伍分
     * 复制
     * 示例2
     * 输入：
     * 1010.00
     * 复制
     * 输出：
     * 人民币壹仟零拾元整
     */
    static String[] rmb_nums = {
            "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖", "拾"
    };

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String[] rmb = in.nextLine().split("\\.");
            if (rmb.length == 2) {
                String prefix = prefixHandle(rmb[0]);
                String suffix = suffixHandle(rmb[1]);
                System.out.println(prefix + suffix);
            }
        }
    }

    private static String prefixHandle(String prefix) {
        StringBuffer prefixStr = new StringBuffer("人民币");
        long num = Long.parseLong(prefix);
        if (num / 100000000 >= 1) {
            long yi = num / 100000000;
            long yi_rest = num % 100000000;
            System.out.println(yi_rest);


        } else if (num / 10000 >= 1) {
            long wan = num / 10000;
            if (wan >= 1000) {
                long wan_unit = wan / 1000;
                prefixStr.append(rmb_nums[(int) wan_unit]).append("仟");
                long wan_unit_rest = wan % 1000;
                if (wan_unit_rest >= 1) {
                    if (wan_unit_rest >= 100) {
                        long bai = wan_unit_rest / 100;
                        prefixStr.append(rmb_nums[(int) bai]).append("佰");
                        if (wan_unit_rest % 100 != 0) {
                            long bai_rest = wan_unit_rest % 100;
                            if (bai_rest >= 10) {
                                long shi = bai_rest / 10;
                                if (shi == 1) {
                                    prefixStr.append("拾");
                                } else {
                                    prefixStr.append(rmb_nums[(int) shi]);
                                    prefixStr.append("拾");
                                }
                                if (bai_rest % 10 != 0) {
                                    long shi_rest = shi % 10;
                                    prefixStr.append(rmb_nums[(int) shi_rest]).append("万");
                                } else {
                                    prefixStr.append("万");
                                }
                            } else {
                                prefixStr.append("零");
                                prefixStr.append(rmb_nums[(int) bai_rest]).append("万");
                            }
                        } else {
                            prefixStr.append("万");
                        }
                    } else if (wan_unit_rest >= 10) {
                        prefixStr.append("零");
                        long shi = wan_unit_rest / 10;
                        if (shi == 1) {
                            prefixStr.append("拾");
                        } else {
                            prefixStr.append(rmb_nums[(int) shi]);
                            prefixStr.append("拾");
                        }
                        if (wan_unit_rest % 10 != 0) {
                            long shi_rest = wan_unit_rest % 10;
                            prefixStr.append(rmb_nums[(int) shi_rest]).append("万");
                        } else {
                            prefixStr.append("万");
                        }
                    } else {
                        prefixStr.append("零");
                        prefixStr.append(rmb_nums[(int) wan_unit_rest]).append("万");
                    }
                } else {
                    prefixStr.append("万");
                }
            } else if (wan >= 100) {
                long wan_unit = wan / 100;
                prefixStr.append(rmb_nums[(int) wan_unit]).append("佰");
                if (wan % 100 != 0) {
                    long wan_rest = wan % 100;
                    if (wan_rest >= 10) {
                        long shi = wan_rest / 10;
                        if (shi == 1) {
                            prefixStr.append("拾");
                        } else {
                            prefixStr.append(rmb_nums[(int) shi]);
                            prefixStr.append("拾");
                        }
                        if (wan_rest % 10 != 0) {
                            long shi_rest = shi % 10;
                            prefixStr.append(rmb_nums[(int) shi_rest]).append("万");
                        } else {
                            prefixStr.append("万");
                        }
                    } else {
                        prefixStr.append("零");
                        prefixStr.append(rmb_nums[(int) wan_rest]).append("万");
                    }
                } else {
                    prefixStr.append("万");
                }
            } else if (wan >= 10) {
                long shi = wan / 10;
                if (shi == 1) {
                    prefixStr.append("拾");
                } else {
                    prefixStr.append(rmb_nums[(int) shi]).append("拾");
                }
                if (wan % 10 != 0) {
                    long shi_rest = wan % 10;
                    prefixStr.append(rmb_nums[(int) shi_rest]).append("万");
                } else {
                    prefixStr.append("万");
                }
            } else {
                prefixStr.append(rmb_nums[(int) wan]).append("万");
            }

            // 万后缀
            long wan_rest = num % 10000;
            if (wan_rest >= 1) {
                if (wan_rest >= 1000) {
                    long wan_qian = wan_rest / 1000;
                    prefixStr.append(rmb_nums[(int) wan_qian]).append("仟");
                    long wan_unit_rest = wan_rest % 1000;
                    if (wan_unit_rest >= 1) {
                        if (wan_unit_rest >= 100) {
                            long wan_unit = wan_unit_rest / 100;
                            prefixStr.append(rmb_nums[(int) wan_unit]).append("佰");
                            if (wan_rest % 100 != 0) {

                                long wan_bai_rest = wan_rest % 100;
                                if (wan_bai_rest >= 10) {
                                    long shi = wan_bai_rest / 10;
                                    if (shi == 1) {
                                        prefixStr.append("拾");
                                    } else {
                                        prefixStr.append(rmb_nums[(int) shi]);
                                        prefixStr.append("拾");
                                    }
                                    if (wan_bai_rest % 10 != 0) {
                                        long shi_rest = wan_bai_rest % 10;
                                        prefixStr.append(rmb_nums[(int) shi_rest]).append("元");
                                    } else {
                                        prefixStr.append("元");
                                    }
                                } else {
                                    prefixStr.append("零");
                                    prefixStr.append(rmb_nums[(int) wan_rest]).append("元");
                                }

                            } else {
                                prefixStr.append("元");
                            }
                        } else if (wan_unit_rest >= 10) {
                            prefixStr.append("零");
                            long wan_unit_rest_shi = wan_unit_rest / 10;
                            if (wan_unit_rest_shi == 1) {
                                prefixStr.append("拾");
                            } else {
                                prefixStr.append(rmb_nums[(int) wan_unit_rest_shi]).append("拾");
                            }
                            if (wan_unit_rest % 10 != 0) {
                                long shi_rest = wan_unit_rest % 10;
                                prefixStr.append(rmb_nums[(int) shi_rest]).append("元");
                            } else {
                                prefixStr.append("元");
                            }
                        } else {
                            prefixStr.append("零");
                            prefixStr.append(rmb_nums[(int) wan_unit_rest]).append("元");
                        }
                    } else {
                        prefixStr.append("元");
                    }

                } else if (wan_rest >= 100) {
                    prefixStr.append("零");
                    long wan_unit = wan_rest / 100;
                    prefixStr.append(rmb_nums[(int) wan_unit]).append("佰");
                    if (wan_rest % 100 != 0) {
                        long wan_bai_rest = wan_rest % 100;
                        if (wan_bai_rest >= 10) {
                            long shi = wan_bai_rest / 10;
                            if (shi == 1) {
                                prefixStr.append("拾");
                            } else {
                                prefixStr.append(rmb_nums[(int) shi]);
                                prefixStr.append("拾");
                            }
                            if (wan_bai_rest % 10 != 0) {
                                long shi_rest = wan_bai_rest % 10;
                                prefixStr.append(rmb_nums[(int) shi_rest]).append("元");
                            } else {
                                prefixStr.append("元");
                            }
                        } else {
                            prefixStr.append("零");
                            prefixStr.append(rmb_nums[(int) wan_rest]).append("元");
                        }
                    } else {
                        prefixStr.append("元");
                    }


                } else if (wan_rest >= 10) {
                    prefixStr.append("零");
                    long shi = wan_rest / 10;
                    if (shi == 1) {
                        prefixStr.append("拾");
                    } else {
                        prefixStr.append(rmb_nums[(int) shi]);
                        prefixStr.append("拾");
                    }
                    if (wan_rest % 10 != 0) {
                        long shi_rest = wan_rest % 10;
                        prefixStr.append(rmb_nums[(int) shi_rest]).append("元");
                    } else {
                        prefixStr.append("元");
                    }
                } else {
                    prefixStr.append("零");
                    prefixStr.append(rmb_nums[(int) wan_rest]).append("元");
                }
            } else {
                prefixStr.append("零");
                prefixStr.append("元");
            }
        } else if (num / 1000 >= 1) {
            qian_append(prefixStr, num);
        } else if (num / 100 >= 1) {
            bai_append(prefixStr, num);
        } else if (num / 10 >= 1) {
            long shi = num / 10;
            shi_append(prefixStr, shi, num);
        } else {
            if (num != 0) {
                prefixStr.append(rmb_nums[(int) num]).append("元");
            }
        }
        return prefixStr.toString();
    }


    static void qian_append(StringBuffer prefixStr, long num) {
        long qian = num / 1000;
        prefixStr.append(rmb_nums[(int) qian]).append("仟");
        long qian_rest = num % 1000;
        if (qian_rest >= 1) {
            if (qian_rest >= 100) {
                bai_append(prefixStr, qian_rest);
            } else if (qian_rest >= 10) {
                prefixStr.append("零");
                long qian_shi_rest = qian_rest / 10;
                shi_append(prefixStr, qian_shi_rest, qian_rest);
            } else {
                prefixStr.append("零");
                prefixStr.append(rmb_nums[(int) qian_rest]).append("元");
            }
        } else {
            prefixStr.append("元");
        }
    }


    static void bai_append(StringBuffer prefixStr, long num) {
        long bai = num / 100;
        prefixStr.append(rmb_nums[(int) bai]).append("佰");
        if (num % 100 != 0) {
            long bai_rest = num % 100;
            if (bai_rest >= 10) {
                long bai_rest_shi = bai_rest / 10;
                shi_append(prefixStr, bai_rest_shi, bai_rest);
            } else {
                prefixStr.append("零");
                prefixStr.append(rmb_nums[(int) bai_rest]).append("元");
            }
        } else {
            prefixStr.append("元");
        }
    }

    static void shi_append(StringBuffer prefixStr, long shi, long num) {
        if (shi == 1) {
            prefixStr.append("拾");
        } else {
            prefixStr.append(rmb_nums[(int) shi]);
            prefixStr.append("拾");
        }
        ge_append(prefixStr, num);
    }

    static void ge_append(StringBuffer prefixStr, long num) {
        if (num % 10 != 0) {
            long shi_rest = num % 10;
            prefixStr.append(rmb_nums[(int) shi_rest]).append("元");
        } else {
            prefixStr.append("元");
        }
    }

    static String suffixHandle(String suffixStr) {
        StringBuffer suffix = new StringBuffer();
        char jiao = suffixStr.charAt(0);
        char fen = suffixStr.charAt(1);
        int i = Integer.parseInt(jiao + "");
        int j = Integer.parseInt(fen + "");
        if (jiao == '0' && fen == '0') {
            suffix.append("整");
        } else if (jiao != '0' && fen != '0') {
            suffix.append(rmb_nums[i]).append("角").append(rmb_nums[j]).append("分");
        } else if (jiao != '0') {
            suffix.append(rmb_nums[i]).append("角");
        } else {
            suffix.append(rmb_nums[j]).append("分");
        }
        return suffix.toString();
    }
}
P("Struggler") ?
关注
专栏目录
Java实现浮点数转换成人民币读法字符串
JUST DO IT.
11-14 1654
这段时间，正值大四上学期，同学们都各种忙着找工作，前一段时间，寝室的一个搞Java的同学参加完笔试，回到寝室后，拿着笔试卷子问我一道编程题：实现浮点数转换成人民币读法字符串的小程序。也忘了当时在忙什么把这事儿搁下了，过了几天，闲来无聊，正好想起这个问题来，索性就静下心来写了写。          现在，把我自已的想法拿出来和大家分享，算法上，一定有可以改进的地方，也希望大家能提出意见，帮我进步
java 浮点数变字符串_Java浮点数转化为人民币读法字符串
weixin_39767322的博客
02-25 256
import java.awt.desktop.SystemSleepEvent;import java.math.BigDecimal;import java.util.Arrays;import java.util.Scanner;public class Num2Rmb {private String[] hanArr = {"零","壹","贰","叁","肆","伍","陆","柒","...
Java 将浮点数转换成人民币读法字符串
YeJunqiao的博客
03-19 745
《疯狂Java讲义（第4版）》第4章 流程控制与数组 本章练习 5 编写一个程序，将浮点数转换成人民币读法字符串，例如，将1006.333转换成壹千零陆元叁角叁分。 参考已有的解决方案上进一步完善，在1000亿范围内基本符合人民币金额读写规范。 特殊情况解决： 输入的数为0直接输出“零元整” 小数位只有分位且整数位不为零时分位前应加“零”，例如，12.04应转换成“壹拾贰元零肆分” 小数位为零且整数位不为零时应在整数位后加“整”，例如，12应转换成“壹拾贰元整” 分组转换时，如...
Java浮点数转化为人民币读法字符串
Warms的博客
08-28 256
@TOC 效果图(有bug) import java.math.BigDecimal; import java.util.Arrays; import java.util.Scanner; public class Num2Rmb { private String[] hanArr = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"}; pri...
输入一个浮点数，打印出相对应的人民币读法的字符串，如：1605.22转换后为：壹仟陆佰零伍元贰角贰分
零点一二四
04-14 1119
输入一个浮点数，打印出相对应的人民币读法的字符串，如：1605.22转换后为：壹仟陆佰零伍元贰角贰分 package demo40; import java.util.Scanner; /** * 输入一个浮点数，打印出相对应的人民币读法的字符串，如：1605.22转换后为：壹仟陆佰零伍元贰角贰分 * * @author trust the process * */ public
java 货币格式 转换_java格式化数值成货币格式示例
weixin_42568714的博客
02-25 1664
java格式化数值成货币格式示例格式化一个数值,比如123456789.123,希望显示成"$123,456,789.123".要完成需求，可以用java.text.NumberFormat类来进行格式化NumberFormat类提供了对数值格式的封装。在JDK中，一般使用NumberFormt的子类----java.text.DecimalFormat完成这个功能。该类最常见的构造函数为:pub...
C1实训-Java薪资转换（适合初学者）
m0_50207094的博客
10-29 682
目录 一、实验任务 二、实验思路 三、涉及知识点 1. Java基本结构 2. Java控制台输入 3. Java控制台输出 4. 基本数据类型 5. 变量 6. while循环 7. 异常捕捉 8. 注释 四、实验过程 1. 创建Java类 2. 获取用户输入值 3. 计算并输出 五、实验测试 1. 控制台输入 2. 参数输入 六、生成文档 一、实验任务 用户输入月薪，程序内部实现薪资转换（每月工作22天，一年13薪），并输出到控制...
将浮点数值转化为人民币大写样式字符串（整数部分可以19位，小数部分2位）
zdl177的博客
04-06 456
如何将一个浮点数转化为人民币读法字符串 程序如下： public class NumToRmb { private String[] hanArr = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"}; private String[] unitArrZheng = {"圆","拾","佰","仟","万","拾","佰","仟","亿"}; ...
别跑！JAVA！-----------一篇关于JAVA的博客
chenzexuanyanyan的博客
11-23 765
视频简介 序 第一次接触Java，感觉有种莫名的奇妙感，觉得好高大上，“我的天，我要成为编程领域的天才啦…”林林总总 后来，通过学习，Java并不是想象的那样高深莫测，反而只是编程领域的敲门砖，所谓“活到老，学到老”，有所谓“上了贼船，入了贼窝”，我顿时发现这是个起点，起点往往预示了成功的一半，下面是我我对Java的理解： Java是一个面向对象的语言。对程序员来说，这意味着要注意应中的数据和操纵...
CSDN实训 - 薪资转换工具v1.0
weixin_51196032的博客
10-27 840
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、Java提供的标识符命名规范二、Java中的基本数据类型二、Java中的三类注释方法二、Java控制台的输入输出二、Java控制台的输入输出二、案例：薪资转换工具v1.0总结 前言 今天是参加CSDN实训实战任务挑战营第八期第二天，了解了Java提供的标识符命名规范、基本数据类型和注释，同时完成案例：薪资转换工具v1.0 提示：以下是本篇文章正文内容，下面案例可供参考 一、Java提供的标识符命名规范  &n
java数字转人民币大写
01-18
用java写的数字转人民币大写，在下java入门不久，望大家多多指点
Java将数字金额转为大写中文金额
08-25
主要为大家详细介绍了Java将数字金额转为大写中文金额，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
人民币数字转大写.java
10-29
人民币数字转大写.java
疯狂Java讲义 浮点数转换成人民币读法
12-11
疯狂java讲义里的课后题，自己编写的程序
java 浮点转字符串_浮点数转换为人名币读法字符串（JAVA）
weixin_30903865的博客
02-21 141
/*《java疯狂讲义》浮点数转换为人名币读法字符串这个用例，感觉没有考虑零的情况*/import java.util.Arrays;public class Num2Rmb {private String[] hanArr={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};private String[] unitArr={"","拾","佰","仟","万",...
将浮点数转换成人民币读法字符串（JAVA）
qq_39854944的博客
03-28 447
public class NumRmb{ private String[] hanArr = {"零" , "壹" , "贰" , "叁" , "肆" , "伍" , "陆" , "柒", "捌" , "玖"}; private String[] unitArr = {"分" , &
java中数字转换人民币
Angus博客
03-30 2167
网上查了些，基本都是无奈的，后来自己查看api解决 两种方式：都是一句话解决 第一种不带人民币羊字符： long b=200022;   DecimalFormat   fmt   =   new   DecimalFormat("##,###,###,###,##0.00");      System.out.println(fmt.format(b));   一
将输入的浮点数转换成RMB
mythosgyj的专栏
09-09 623
前两天老师留的作业,布置下来的时候就想了一下,觉得很简单,就没下手做，今天有空着手做才知道在读成RMB的时候要注意的不少看来真的是眼高手低啊,要改！！ public  void ChangeDisplay(float n) {  //调用这个数组对数字进行转换  ArrayList arrInteger = new ArrayList();  arrInteger.add("零
编写一个程序,将浮点数转换成人民币读法字符串
windy46的博客
08-15 1452
package crazy.lee.chapter04; import java.util.Arrays; /**  *   * @author Windy46  *  */ public class Question05 {     private String[] hanArr = {"零" , "壹" , "贰" , "叁" , "肆" ,             "伍" , &q
java中把浮点型转换为字符串型
最新发布
04-20
可以使用 String.valueOf() 方法将浮点型转换为字符串型，或者使用 Double.toString() 方法将 Double 类型的浮点数转换为字符串。例如： double num = 3.14; String str = String.valueOf(num); 或者： double num ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

P("Struggler") ?

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值