正则表达式将数字金额转成中文和英文

最新推荐文章于 2022-03-23 21:01:37 发布
最新推荐文章于 2022-03-23 21:01:37 发布
阅读量3.9k 收藏 1
点赞数
分类专栏： 基础 文章标签： 正则 金额 中文数字 英文数字
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gongkanaa/article/details/50722033
版权

   银行要求如下：

1，中文+数字，数字读中文数目； 例： 尾号1234.5 读：尾号一二三四点五

2， 英文+数字，数字读英文数目

    英文+数字+中文，数字读英文数目  

    例： Number1234.5 密码 读： number one two there four point five 密码

3， 中文+￥/$数字，数字读中文金额

    例：现金￥100  读：现金一百元 ，现金$100  读：现金一百美元，尾号1234的卡$100 读：尾号一二三四的卡一百美元
4， 英文+￥/$数字，数字读英文金额

    英文+￥/$数字+中文，数字读英文金额

    例：Money￥100 读：money one hundred yuan

        Money $100  读：money one hundred dollars

        Number1234money$100 读：number one two there four money one hundred dollars

        Money $100整 读：money one hundred dollars 整

5， 中文+￥数字带小数，小数翻译成元角分； 例：现金￥100.12  读：现金一百元一角两分

6， 中文+$数字带小数，小数直接读； 例：现金$100.12  读：现金一百元点一二美元

7，英文+￥数字带小数，小数直接读 ；例：Money￥100.12 读：money one hundred point one two yuan

8，英文+$数字带小数，小数直接读；例：Money$100.12 读：money one hundred point one two dollars

9，中文+￥/$数字—￥/$数字，“—”读至；

   例：现金￥100-200  读：现金一百至两百元

       现金$100-200  读：现金一百至两百美元

10，英文+￥/$数字—￥/$数字，“—”读to；

       例：Money ￥100-200  读：money one hundred to two hundred yuan

               Money $100-200  读：money one hundred to two hundred dollars

11， 中文+￥/$数字中带逗号，去除逗号方式播读

      例： 现金￥10,000 读：现金一万元

               现金$10,000 读：现金一万美元

12:，英文+￥/$数字中带逗号，去除逗号方式播读

       例：Money ￥10,000 读：money ten thousand yuan

              Money $10,000 读：money ten thousand  dollars


代码如下：

package com.geo.main;

import java.text.DecimalFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class NumToChinese {
	/**
	 * 直接将数字翻译成对应的中英文的
	 * @param decimal
	 * @param isEnglish
	 * @return
	 */
	private static String formatFractionalPart(int decimal, boolean isEnglish) {
		String[] number;
		if (isEnglish) {
			number = new String[] { " zero", " one", " two", " three", " four",
					" five", " six", " seven", " eight", " nine" };
		} else {
			number = new String[] { "零", "一", "二", "三", "四", "五", "六", "七",
					"八", "九" };
		}
		char[] val = String.valueOf(decimal).toCharArray();
		int len = val.length;
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < len; i++) {
			int n = Integer.valueOf(val[i] + "");
			sb.append(number[n]);
		}
		return sb.toString();
	}
	/**
	 * 将数字翻译成中文，英文，或直接翻译
	 * @param money
	 * @param isEnglish
	 * @return
	 * @throws Exception
	 */
	private static String translateMoney(String money, boolean isEnglish)
			throws Exception {
		StringBuffer rsult = new StringBuffer();

		if (money.matches("[$￥][0-9,\\.]+[\\-][0-9,\\.]+")) {//转义带“-”的数字，例：$100-200
			boolean isYuan = money.startsWith("￥");
			String newMoney = money.replaceAll("[,$￥]", "");
			String[] nums = newMoney.split("-");
			for (int i = 0; i < nums.length; i++) {
				numToChinese(nums[i], rsult, isEnglish);
				if (i == 0) {
					if (isEnglish) {
						rsult.append(" to ");
					} else {
						rsult.append("到");
					}
				}
			}
			String rmb = "";
			if (isYuan) {
				rmb = isEnglish ? " yuan" : "";
			} else {
				rmb = isEnglish ? " dollar" : "美元";
			}
			rsult.append(rmb);
		} else if (money.matches("\\d+.*")) {//直接翻译数字，例1234.5
			int decIndex = money.indexOf(".");
			if (decIndex == -1) {
				rsult.append(formatFractionalPart(Integer.valueOf(money),
						isEnglish));
			} else {
				int integ = Integer.valueOf(money.substring(0, decIndex));
				int dec = Integer.valueOf(money.substring(decIndex + 1));
				String point = isEnglish ? " point " : "点";
				rsult.append(formatFractionalPart(integ, isEnglish) + point
						+ formatFractionalPart(dec, isEnglish));
			}
		} else if (money.trim().matches("\\$\\d+.*")) {//翻译“$”开头的数字
			// String [] unit =
			// {"千","百","十","亿","千","百","十","万","千","百","十","美元"};
			if (isEnglish) {
				numToChinese(money, rsult, isEnglish);
				rsult.append(" dollar");
			} else {
				numToDolor(money, rsult);
				rsult.append("美元");
			}
		} else if (money.matches("￥\\d+.*")) {//翻译“￥”开头的数字
			numToChinese(money, rsult, isEnglish);
			if (isEnglish) {

				rsult.append(" yuan");
			}
		}

		return rsult.toString();
	}

	private static void numToDolor(String money, StringBuffer rsult) {
		String allNum = money.replace("$", "").replace(",", "");
		int decIndex = allNum.indexOf(".");
		if (decIndex == -1) {
			rsult.append(formatInteger(Integer.valueOf(allNum)));
		} else {
			int integ = Integer.valueOf(allNum.substring(0, decIndex));
			int dec = Integer.valueOf(allNum.substring(decIndex + 1));
			rsult.append(formatInteger(integ) + "点"
					+ formatFractionalPart(dec, false));
		}
	}

	private static void numToChinese(String money, StringBuffer rsult,
			boolean isEnglish) {
		if (isEnglish) {
			String allNum = money.replaceAll("[￥,$]", "");
			int decIndex = allNum.indexOf(".");
			if (decIndex == -1) {
				rsult.append(convert(Long.valueOf(allNum)));
			} else {
				int integ = Integer.valueOf(allNum.substring(0, decIndex));
				int dec = Integer.valueOf(allNum.substring(decIndex + 1));
				rsult.append(convert(integ)).append(" point ")
						.append(formatFractionalPart(dec, isEnglish));
			}
		} else {
			String unit = "千百十亿千百十万千百十元角分";
			String number = "零一二三四五六七八九";
			String allNum = money.replace("￥", "").replace(",", "");

			String moneyStr = String.format("%.2f", Double.valueOf(allNum))
					.replace(".", "");

			int pos = unit.length() - moneyStr.length();
			boolean zero = false;
			for (int i = 0; i < moneyStr.length(); i++) {
				if (moneyStr.charAt(i) == '0') {
					zero = true;
					if (((pos + i + 1) % 4) == 0) {
						rsult.append(unit.charAt(pos + i));
						zero = false;
					}
				} else {
					if (zero) {
						rsult.append(number.charAt(0));
					}
					zero = false;
					rsult.append(number.charAt(moneyStr.charAt(i) - '0'))
							.append(unit.charAt(pos + i));
				}
			}
			if (moneyStr.startsWith("0")) {
				rsult.deleteCharAt(0);
			}
		}
	}

	private static String formatInteger(int integ) {
		String[] unit = { "千", "百", "十", "亿", "千", "百", "十", "万", "千", "百",
				"十", "" };
		String numStr = "零一二三四五六七八九";
		String moneyStr = String.valueOf(integ);
		StringBuffer rsult = new StringBuffer();
		int pos = unit.length - moneyStr.length();
		boolean zero = false;
		for (int i = 0; i < moneyStr.length(); i++) {
			if (moneyStr.charAt(i) == '0') {
				zero = true;
				if (((pos + i + 1) % 4) == 0) {
					rsult.append(unit[pos + i]);
					zero = false;
				}
			} else {
				if (zero) {
					rsult.append(numStr.charAt(0));
				}
				zero = false;
				rsult.append(numStr.charAt(moneyStr.charAt(i) - '0')).append(
						unit[pos + i]);
			}
		}
		return rsult.toString();
	}

	public static String match(String money) throws Exception {
		String regEx = "";
		boolean isEnglish = true;
		if (money.matches(".*[\\u4E00-\\u9FBF&&[^￥]]+.*")) {
			isEnglish = false;

		}
		if (money.matches(".*[$￥][0-9,\\.]+[\\-][0-9,\\.]+.*")) {
			regEx = "([$￥][0-9,\\.]+[\\-][0-9,\\.]+)";
		} else if (money.matches(".*[$￥][0-9]+,.*")) {
			regEx = "(([\\$￥])(([1-9]\\d{0,2}(,\\d+)*(\\.\\d+)?)|[0]\\.\\d+))";
		} else if (money.matches(".*[$￥]\\d+.*")) {
			regEx = "(([\\$￥])([1-9]\\d*(\\.\\d+)?|0\\.\\d+))";
		} else if (money.matches(".*[^$￥]\\d+.*")) {
			regEx = "(([1-9]\\d*(\\.\\d{1,})?|0\\.\\d+))";
		}
		if ("".equals(regEx)) {
			return money;
		} else {
			// |([$￥]？[1-9]\\d*(.\\d+)*)
			money.matches(regEx);
			Pattern pattern = Pattern.compile(regEx);
			Matcher matcher = pattern.matcher(money);
			String num = "";
			if (matcher.find()) {
				num = matcher.group();
			}
			String numMoey = money.replace(num, translateMoney(num, isEnglish));
			// return numMoey;
			return match(numMoey);
		}
	}

	private static String convertLessThanOneThousand(int number) {
		String[] numNames = { "", " one", " two", " three", " four", " five",
				" six", " seven", " eight", " nine", " ten", " eleven",
				" twelve", " thirteen", " fourteen", " fifteen", " sixteen",
				" seventeen", " eighteen", " nineteen" };
		String[] tensNames = { "", " ten", " twenty", " thirty", " forty",
				" fifty", " sixty", " seventy", " eighty", " ninety" };
		String soFar;

		if (number % 100 < 20) {
			soFar = numNames[number % 100];
			number /= 100;
		} else {
			soFar = numNames[number % 10];
			number /= 10;

			soFar = tensNames[number % 10] + soFar;
			number /= 10;
		}
		if (number == 0)
			return soFar;
		if (!"".equals(numNames[number]) && !"".endsWith(soFar)) {
			soFar = " and" + soFar;
		}
		return numNames[number] + " hundred" + soFar;
	}

	public static String convert(long number) {
		// 0 to 999 999 999 999
		if (number == 0) {
			return "zero";
		}

		String snumber = Long.toString(number);

		// pad with "0"
		String mask = "000000000000";
		DecimalFormat df = new DecimalFormat(mask);
		snumber = df.format(number);

		// XXXnnnnnnnnn
		int billions = Integer.parseInt(snumber.substring(0, 3));
		// nnnXXXnnnnnn
		int millions = Integer.parseInt(snumber.substring(3, 6));
		// nnnnnnXXXnnn
		int hundredThousands = Integer.parseInt(snumber.substring(6, 9));
		// nnnnnnnnnXXX
		int thousands = Integer.parseInt(snumber.substring(9, 12));

		String tradBillions;
		switch (billions) {
		case 0:
			tradBillions = "";
			break;
		case 1:
			tradBillions = convertLessThanOneThousand(billions) + " billion ";
			break;
		default:
			tradBillions = convertLessThanOneThousand(billions) + " billion ";
		}
		String result = tradBillions;

		String tradMillions;
		switch (millions) {
		case 0:
			tradMillions = "";
			break;
		case 1:
			tradMillions = convertLessThanOneThousand(millions) + " million ";
			break;
		default:
			tradMillions = convertLessThanOneThousand(millions) + " million ";
		}
		result = result + tradMillions;

		String tradHundredThousands;
		switch (hundredThousands) {
		case 0:
			tradHundredThousands = "";
			break;
		case 1:
			tradHundredThousands = "one thousand ";
			break;
		default:
			tradHundredThousands = convertLessThanOneThousand(hundredThousands)
					+ " thousand ";
		}
		result = result + tradHundredThousands;

		String tradThousand;
		tradThousand = convertLessThanOneThousand(thousands);
		result = result + tradThousand;

		// remove extra spaces!
		return result.replaceAll("^\\s+", "").replaceAll("\\b\\s{2,}\\b", " ");
	}
}



测试代码：

System.out.println(NumToChinese.match("尾号1234.5"));
System.out.println(NumToChinese.match("Number1234.5"));
System.out.println(NumToChinese.match("现金￥100"));
System.out.println(NumToChinese.match("现金$100 "));
System.out.println(NumToChinese.match("尾号1234的卡$100"));
System.out.println(NumToChinese.match("Money￥100"));
System.out.println(NumToChinese.match("Money $100"));
System.out.println(NumToChinese.match("Number 1234 money $100"));
System.out.println(NumToChinese.match("Money $100整"));
System.out.println(NumToChinese.match("现金￥100.12"));
System.out.println(NumToChinese.match("现金$100.12"));
System.out.println(NumToChinese.match("Money ￥100.12"));
System.out.println(NumToChinese.match("Money $100.12"));
System.out.println(NumToChinese.match("现金￥100-200"));
System.out.println(NumToChinese.match("现金￥100.1-200"));
System.out.println(NumToChinese.match("现金$100-200"));
System.out.println(NumToChinese.match("Money ￥100-200"));
System.out.println(NumToChinese.match("Money $100-200"));
System.out.println(NumToChinese.match("现金￥10,000"));
System.out.println(NumToChinese.match("现金$10,000"));
System.out.println(NumToChinese.match("Money ￥10,000"));
System.out.println(NumToChinese.match("Money $10,000"));


打印结果：

尾号一二三四点五
Number one two three four point  five
现金一百元
现金一百美元 
尾号一二三四的卡一百美元
Moneyone hundred yuan
Money one hundred dollar
Number  one two three four money one hundred dollar
Money 一百美元整
现金一百元一角二分
现金一百点一二美元
Money one hundred point  one two yuan
Money one hundred point  one two dollar
现金一百元到二百元
现金一百元一角到二百元
现金一百元到二百元美元
Money one hundred to two hundred yuan
Money one hundred to two hundred dollar
现金一万元
现金一万美元
Money ten thousand  yuan
Money ten thousand  dollar

}




gongkanaa
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#中利用正则表达式将人民币金额转换为大写汉字
09-02
主要介绍了C#中利用正则表达式将人民币金额转换为大写汉字的方法,需要的朋友可以参考下
Java之——数字金额转化为英文金额
冰河的专栏
09-20 7865
今天，给大家带来一篇基于Java将数字金额转化为英文金额的示例代码，网上有很多类似的代码，但是，它们不是转化错误就是不支持小数，那现在我们就一起实现一个完美的数字金额转化为英文金额的示例代码吧，不多说了，详情参见如下代码： package com.lyz.util; /** * 将数字转化为英文金额 * @author liuyazhuang * */ public class Num
【JAVA】金额工具类 金额千分位、中文大写金额、英文金额
weixin_46881270的博客
03-23 1790
金额工具类 金额千分位、中文大写金额、英文金额
java实现数字金钱转化为英文字母显示
天马波波的专栏
02-26 3223
public class MoneyUtil { String[] smallNumbers = new String[]{"ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", "TEN",
货币数字转英文类(java)
wpcxyking的专栏
11-11 1792
<br />/*<br /> * Created on 2005-3-2<br /> */<br /> package org.ofbase.test.util;<br />/**<br /> * 本类改写自于一个VBS的小程序:<br /> * http://www.6to23.com/s11/s11d1/s11d1d4/2003826151654.htmhttp://www.6to23.com/s11/s11d1/s11d1d4/2003826151654.htmhttp://www.6to2
JS常见简单正则表达式验证功能小结【手机,地址,企业税号,金额,身份证等】
11-29
本文实例总结了JS常见简单正则表达式验证功能。分享给大家供大家参考，具体如下： 下面都是一些比较常用简单的验证，像那些特殊的复杂的情况这里不进行考虑 1、验证电话号码或者手机号码 /** * 验证电话号码（手机...
js代码-数字金额格式化
07-16
本文将深入探讨如何使用JavaScript实现数字金额的格式化，并通过分析`main.js`文件和`README.txt`中的内容来详细阐述这一过程。 首先，我们需要理解数字格式化的几个关键要素： 1. **货币符号**：通常为人民币的...
各种规则校验方法、各种类型判断
09-07
将阿拉伯数字翻译成中文的大写数字 将数字转换为大写金额 小数点之后进行转化 判断一个元素是否在数组中 数组去重 数组删除其中一个元素 求数组中的最大值 求数组中的最小值 数组中的值求和 检测密码强度 16进制颜色...
js手工调薪输入表达式特效代码
03-20
半角字符通常指的是英文或数字字符，而不是全角字符（如中文字符或特殊符号）。 首先，我们需要理解JavaScript的基础语法，它是Web开发中的主要脚本语言，用于实现客户端的动态交互。在处理用户输入的表达式时，...
tesseract 安装版
12-19
3. **后处理**：识别结果可能包含错误，可以结合其他工具或算法进行后处理，如使用正则表达式匹配、人工校对等。 总结，Tesseract 3.05.01 exe安装版为用户提供了简单快捷的OCR解决方案，尤其适合那些希望快速部署...
正则表达式替换全部 中文汉字 英文 数字
热门推荐
ivanwfy的专栏
08-20 1万+
简单说明下用正则表达式替换全部中文汉字、英文、数字的方法 。 使用工具,Notepad2（或者支持正则表达式的都可以） 替换表达式： [a-zA-Z]+ [!^1-^127] 英文 数字 所有小写英文字母[a-z] 所有大写英文字母[A-Z] 所有西文字符[^1-^127] 所有中文汉字和中文标点[!^1-^127] 所有中文汉字（CJK统一字符）[一-龥] or [一-﨩]搜索 所有中文...
C#数字金额转换为中文大写金额
hugeben6的专栏
06-20 1000
static string ConvertToChinese(double x)         {             string s = x.ToString("#L#E#D#C#K#E#D#C#J#E#D#C#I#E#D#C#H#E#D#C#G#E#D#C#F#E#D#C#.0B0A");             string d = Regex.Replace(s, @"((?
【正则表达式】常用的正则表达式（数字，汉字，字符串，金额等的正则表达式）
坚持不懈 一往无前
12-13 2341
常用的正则表达式（数字，汉字，字符串，金额等的正则表达式）
好用的正则表达式
一克代码的专栏
11-26 1052
<br />1。 string s = "某某的面积是12345678平方米"; string t = Regex.Replace(s, @"(?<=/d)(?=(/d/d/d)+(?!/d))", ","); // 同理，这个正则的作用是把一串数字每3位加一个逗号。 Console.WriteLine(t); // 输出：某某的面积是12,345,678平方米 <br /> <br />2。<br />string s ="1234567890";<br /><br />// 考虑了一下，这样更简单：<b
php 千分制显示数字,金额转为千分制，金额转中文大写
weixin_29607637的博客
04-14 218
金额转关为大写/** 数字金额大写转换(可以处理整数,小数,负数) */function digitUppercase(n){if(!n) reutrn ""let fraction = ['角', '分'];let digit = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];let unit = [ ['元', '万', '亿'], ['...
正则将长数字转为英式写法（从后向前3个数字一个逗号）
zzz_781111的专栏
08-28 3664
在解决问题之前，我们需要了解一些关于‘零宽断言’特性         ⑴ 断言（锚点也一样）和一般的正则表达式符号不同，它不匹配实际的任何字符，而是寻找文本的中的位置，是0长度。                 他们匹配的是字符之前或之后的位置。如$并不是匹配换行符，而是匹配目标字符串的末尾或整个字符串末尾的换行符之前的位置                 (?=pattern), (?
Java 数字转成英文
09-03 5554
英文数词，按3位3位区分 Hundred: 100 Thousand:1,000 Million: 1,000,000 Billion: 1,000,000,000 Trillion: 1,000,000,000,000 Quintillion: 1,000,000,
常用正则表达式-数字、字母、金额等
maxiaole_z的博客
05-20 7765
一、校验数字的表达式 数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$ 零和非零开头的数字：^(0|[1-9][0-9]*)$ 非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(\.[0-9]{1,2})?$ 带1-2位小数的正数或负数：^(\-)?\d+(\.\d{1,2})$ 正数、负数、和小数：^(\-|\+)?\d+(\.\d+)?$ 有两位小数的正实数：^[0-9]+(\.[0-9]{2})?$
项目中常用的数字金额正则表达式
qq_34078119的博客
06-26 4235
/** * 验证价格 */ $.validator.addMethod('njzhnumber',function(value){ var ret=true; var pay_money = $("#njzh_price").val(); var meath = /(^[1-9]([0-9]+)?(\.[0-9]{...
正则表达式, 小写字符转成大写
最新发布
05-27
可以使用正则表达式实现小写字符转成大写，具体的实现方法如下： ```python import re # 定义要转换的字符串 text = "hello, world!" # 使用正则表达式将小写字符转成大写 result = re.sub('[a-z]', lambda x: x.group(0).upper(), text) # 输出转换后的字符串 print(result) ``` 运行上述代码，输出结果为： ``` Hello, World! ``` 其中，`re.sub` 函数用于替换字符串中匹配正则表达式的部分，第一个参数为正则表达式，第二个参数为替换函数，这里使用了 lambda 表达式将匹配到的小写字符转成大写。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值