ZhouXY108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-05-09 23:51:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

add formatSimple

Browse Source
This commit is contained in:
Looly 2021-02-20 10:35:01 +08:00
parent c5530facdf
commit ef3e3f55b5
4 changed files with 329 additions and 302 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -11,6 +11,7 @@
* 【core 】 StrUtil增加endWithAnyIgnoreCase（issue#I37I0B@Gitee） * 【core 】 StrUtil增加endWithAnyIgnoreCase（issue#I37I0B@Gitee）
* 【crypto 】 Sm2增加getD和getQ方法（issue#I37Z4C@Gitee） * 【crypto 】 Sm2增加getD和getQ方法（issue#I37Z4C@Gitee）
* 【cache 】 AbstractCache增加keySet方法（issue#I37Z4C@Gitee） * 【cache 】 AbstractCache增加keySet方法（issue#I37Z4C@Gitee）
* 【core 】 NumberWordFormatter增加formatSimple方法（pr#1436@Github）
### Bug修复 ### Bug修复
* 【json 】 JSONUtil.isJson方法改变trim策略，解决特殊空白符导致判断失败问题 * 【json 】 JSONUtil.isJson方法改变trim策略，解决特殊空白符导致判断失败问题

15
hutool-core/src/main/java/cn/hutool/core/convert/Convert.java
View File

@ -963,6 +963,21 @@ public class Convert {
return NumberWordFormatter.format(number); return NumberWordFormatter.format(number);
} }
/**
* 将阿拉伯数字转为精简表示形式，例如:
*
* <pre>
* 1200 -> 1.2k
* </pre>
*
* @param number {@link Number}对象
* @return 英文表达式
* @since 5.5.9
*/
public static String numberToSimple(Number number) {
return NumberWordFormatter.formatSimple(number.longValue());
}
/** /**
* 将阿拉伯数字转为中文表达方式 * 将阿拉伯数字转为中文表达方式
* *

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

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

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

@ -12,14 +12,23 @@ public class NumberWordFormatTest {
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); @Test
Assert.assertEquals("4.38m", format3); public void formatSimpleTest() {
String format1 = NumberWordFormatter.formatSimple(1200, false);
Assert.assertEquals("1.2k", format1);
String format4 = NumberWordFormatter.formatValue(4384324); String format2 = NumberWordFormatter.formatSimple(4384324, false);
Assert.assertEquals("4.38m", format2);
String format3 = NumberWordFormatter.formatSimple(4384324, true);
Assert.assertEquals("438.43w", format3);
String format4 = NumberWordFormatter.formatSimple(4384324);
Assert.assertEquals("438.43w", format4); Assert.assertEquals("438.43w", format4);
String format5 = NumberWordFormatter.formatValue(438); String format5 = NumberWordFormatter.formatSimple(438);
Assert.assertEquals("438", format5); Assert.assertEquals("438", format5);
} }
} }