zhouxy108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-08-18 20:38:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1436 from totalo/v5-dev

Browse Source 
feat:增加数字转换简写，如2100 =>2.1k
This commit is contained in:
Golden Looly
2021-02-20 10:23:37 +08:00
committed by GitHub
parent 7da89f48b2 4f329cfa8a
commit c5530facdf
2 changed files with 204 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

318
hutool-core/src/main/java/cn/hutool/core/convert/NumberWordFormatter.java
View File

@@ -1,140 +1,180 @@
package cn.hutool.core.convert; package cn.hutool.core.convert;
import cn.hutool.core.util.StrUtil; import cn.hutool.core.util.StrUtil;
/** import java.text.DecimalFormat;
* 将浮点数类型的number转换成英语的表达方式 <br>
* 参考博客：http://blog.csdn.net/eric_sunah/article/details/8713226 /**
* * 将浮点数类型的number转换成英语的表达方式 <br>
* @author Looly * 参考博客：http://blog.csdn.net/eric_sunah/article/details/8713226
* @since 3.0.9 *
*/ * @author Looly
public class NumberWordFormatter { * @since 3.0.9
*/
private static final String[] NUMBER = new String[]{"", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", public class NumberWordFormatter {
"EIGHT", "NINE"};
private static final String[] NUMBER_TEEN = new String[]{"TEN", "ELEVEN", "TWELVE", "THIRTEEN", "FOURTEEN", private static final String[] NUMBER = new String[]{"", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN",
"FIFTEEN", "SIXTEEN", "SEVENTEEN", "EIGHTEEN", "NINETEEN"}; "EIGHT", "NINE"};
private static final String[] NUMBER_TEN = new String[]{"TEN", "TWENTY", "THIRTY", "FORTY", "FIFTY", "SIXTY", private static final String[] NUMBER_TEEN = new String[]{"TEN", "ELEVEN", "TWELVE", "THIRTEEN", "FOURTEEN",
"SEVENTY", "EIGHTY", "NINETY"}; "FIFTEEN", "SIXTEEN", "SEVENTEEN", "EIGHTEEN", "NINETEEN"};
private static final String[] NUMBER_MORE = new String[]{"", "THOUSAND", "MILLION", "BILLION"}; private static final String[] NUMBER_TEN = new String[]{"TEN", "TWENTY", "THIRTY", "FORTY", "FIFTY", "SIXTY",
"SEVENTY", "EIGHTY", "NINETY"};
/** private static final String[] NUMBER_MORE = new String[]{"", "THOUSAND", "MILLION", "BILLION"};
* 将阿拉伯数字转为英文表达式
* private static final String[] NUMBER_SUFFIX = new String[]{"k", "w", "", "m", "", "", "b", "", "", "t", "", "", "p", "", "", "e"};
* @param x 阿拉伯数字，可以为{@link Number}对象，也可以是普通对象，最后会使用字符串方式处理
* @return 英文表达式 /**
*/ * 将阿拉伯数字转为英文表达式
public static String format(Object x) { *
if (x != null) { * @param x 阿拉伯数字，可以为{@link Number}对象，也可以是普通对象，最后会使用字符串方式处理
return format(x.toString()); * @return 英文表达式
} else { */
return ""; public static String format(Object x) {
} if (x != null) {
} return format(x.toString());
} else {
/** return "";
* 将阿拉伯数字转为英文表达式 }
* }
* @param x 阿拉伯数字字符串
* @return 英文表达式 /**
*/ * 将阿拉伯数字转化为简介计数单位，例如 2100 => 2.1k
private static String format(String x) { * 范围默认只到w
int z = x.indexOf("."); // 取小数点位置 * @param value
String lstr, rstr = ""; * @return
if (z > -1) { // 看是否有小数，如果有，则分别取左边和右边 */
lstr = x.substring(0, z); public static String formatValue(long value) {
rstr = x.substring(z + 1); return formatValue(value, true);
} else { }
// 否则就是全部
lstr = x; /**
} * 将阿拉伯数字转化为简介计数单位，例如 2100 => 2.1k
* @param value 对应数字的值
String lstrrev = StrUtil.reverse(lstr); // 对左边的字串取反 * @param isTwo 控制是否为k、w
String[] a = new String[5]; // 定义5个字串变量来存放解析出来的叁位一组的字串 * @return
*/
switch (lstrrev.length() % 3) { public static String formatValue(long value, boolean isTwo) {
case 1: if (value < 1000) {
lstrrev += "00"; return String.valueOf(value);
break; }
case 2: int index = -1;
lstrrev += "0"; double res = value * 1.0d;
break; while (res > 10 && (!isTwo || index < 1)) {
} if (res > 1000) {
StringBuilder lm = new StringBuilder(); // 用来存放转换后的整数部分 res = res / 1000;
for (int i = 0; i < lstrrev.length() / 3; i++) { index++;
a[i] = StrUtil.reverse(lstrrev.substring(3 * i, 3 * i + 3)); // 截取第一个三位 }
if (false == "000".equals(a[i])) { // 用来避免这种情况：1000000 = one million if (res > 10) {
// thousand only res = res / 10;
if (i != 0) { index++;
lm.insert(0, transThree(a[i]) + " " + parseMore(i) + " "); // 加: }
// thousand、million、billion }
} else { DecimalFormat decimalFormat = new DecimalFormat("#.##");
// 防止i=0时， 在多加两个空格. return String.format("%s%s", decimalFormat.format(res), NUMBER_SUFFIX[index]);
lm = new StringBuilder(transThree(a[i])); }
}
} else { /**
lm.append(transThree(a[i])); * 将阿拉伯数字转为英文表达式
} *
} * @param x 阿拉伯数字字符串
* @return 英文表达式
String xs = ""; // 用来存放转换后小数部分 */
if (z > -1) { private static String format(String x) {
xs = "AND CENTS " + transTwo(rstr) + " "; // 小数部分存在时转换小数 int z = x.indexOf("."); // 取小数点位置
} String lstr, rstr = "";
if (z > -1) { // 看是否有小数，如果有，则分别取左边和右边
return lm.toString().trim() + " " + xs + "ONLY"; lstr = x.substring(0, z);
} rstr = x.substring(z + 1);
} else {
private static String parseFirst(String s) { // 否则就是全部
return NUMBER[Integer.parseInt(s.substring(s.length() - 1))]; lstr = x;
} }
private static String parseTeen(String s) { String lstrrev = StrUtil.reverse(lstr); // 对左边的字串取反
return NUMBER_TEEN[Integer.parseInt(s) - 10]; String[] a = new String[5]; // 定义5个字串变量来存放解析出来的叁位一组的字串
}
switch (lstrrev.length() % 3) {
private static String parseTen(String s) { case 1:
return NUMBER_TEN[Integer.parseInt(s.substring(0, 1)) - 1]; lstrrev += "00";
} break;
case 2:
private static String parseMore(int i) { lstrrev += "0";
return NUMBER_MORE[i]; break;
} }
StringBuilder lm = new StringBuilder(); // 用来存放转换后的整数部分
// 两位 for (int i = 0; i < lstrrev.length() / 3; i++) {
private static String transTwo(String s) { a[i] = StrUtil.reverse(lstrrev.substring(3 * i, 3 * i + 3)); // 截取第一个三位
String value; if (false == "000".equals(a[i])) { // 用来避免这种情况：1000000 = one million
// 判断位数 // thousand only
if (s.length() > 2) { if (i != 0) {
s = s.substring(0, 2); lm.insert(0, transThree(a[i]) + " " + parseMore(i) + " "); // 加:
} else if (s.length() < 2) { // thousand、million、billion
s = "0" + s; } else {
} // 防止i=0时， 在多加两个空格.
lm = new StringBuilder(transThree(a[i]));
if (s.startsWith("0")) {// 07 - seven 是否小於10 }
value = parseFirst(s); } else {
} else if (s.startsWith("1")) {// 17 seventeen 是否在10和20之间 lm.append(transThree(a[i]));
value = parseTeen(s); }
} else if (s.endsWith("0")) {// 是否在10与100之间的能被10整除的数 }
value = parseTen(s);
} else { String xs = ""; // 用来存放转换后小数部分
value = parseTen(s) + " " + parseFirst(s); if (z > -1) {
} xs = "AND CENTS " + transTwo(rstr) + " "; // 小数部分存在时转换小数
return value; }
}
return lm.toString().trim() + " " + xs + "ONLY";
// 制作叁位的数 }
// s.length = 3
private static String transThree(String s) { private static String parseFirst(String s) {
String value; return NUMBER[Integer.parseInt(s.substring(s.length() - 1))];
if (s.startsWith("0")) {// 是否小於100 }
value = transTwo(s.substring(1));
} else if ("00".equals(s.substring(1))) {// 是否被100整除 private static String parseTeen(String s) {
value = parseFirst(s.substring(0, 1)) + " HUNDRED"; return NUMBER_TEEN[Integer.parseInt(s) - 10];
} else { }
value = parseFirst(s.substring(0, 1)) + " HUNDRED AND " + transTwo(s.substring(1));
} private static String parseTen(String s) {
return value; return NUMBER_TEN[Integer.parseInt(s.substring(0, 1)) - 1];
} }
private static String parseMore(int i) {
return NUMBER_MORE[i];
}
// 两位
private static String transTwo(String s) {
String value;
// 判断位数
if (s.length() > 2) {
s = s.substring(0, 2);
} else if (s.length() < 2) {
s = "0" + s;
}
if (s.startsWith("0")) {// 07 - seven 是否小於10
value = parseFirst(s);
} else if (s.startsWith("1")) {// 17 seventeen 是否在10和20之间
value = parseTeen(s);
} else if (s.endsWith("0")) {// 是否在10与100之间的能被10整除的数
value = parseTen(s);
} else {
value = parseTen(s) + " " + parseFirst(s);
}
return value;
}
// 制作叁位的数
// s.length = 3
private static String transThree(String s) {
String value;
if (s.startsWith("0")) {// 是否小於100
value = transTwo(s.substring(1));
} else if ("00".equals(s.substring(1))) {// 是否被100整除
value = parseFirst(s.substring(0, 1)) + " HUNDRED";
} else {
value = parseFirst(s.substring(0, 1)) + " HUNDRED AND " + transTwo(s.substring(1));
}
return value;
}
} }

41
hutool-core/src/test/java/cn/hutool/core/convert/NumberWordFormatTest.java
View File

@@ -1,16 +1,25 @@
package cn.hutool.core.convert; package cn.hutool.core.convert;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
public class NumberWordFormatTest { public class NumberWordFormatTest {
@Test @Test
public void formatTest() { public void formatTest() {
String format = NumberWordFormatter.format(100.23); String format = NumberWordFormatter.format(100.23);
Assert.assertEquals("ONE HUNDRED AND CENTS TWENTY THREE ONLY", format); Assert.assertEquals("ONE HUNDRED AND CENTS TWENTY THREE ONLY", format);
String format2 = NumberWordFormatter.format("2100.00"); String format2 = NumberWordFormatter.format("2100.00");
Assert.assertEquals("TWO THOUSAND ONE HUNDRED AND CENTS ONLY", format2); Assert.assertEquals("TWO THOUSAND ONE HUNDRED AND CENTS ONLY", format2);
}
} String format3 = NumberWordFormatter.formatValue(4384324, false);
Assert.assertEquals("4.38m", format3);
String format4 = NumberWordFormatter.formatValue(4384324);
Assert.assertEquals("438.43w", format4);
String format5 = NumberWordFormatter.formatValue(438);
Assert.assertEquals("438", format5);
}
}