/**
* 将int、long、double、float、String、Date等类型format成字符类型
*
* 一、数字format格式处理：
* 01）99.99的实现，小数位四舍五入不够位数补0，整数位超出位数补空格；
* 02）00.00的实现，小数位四舍五入不够位数补0，整数位超出位数补0；
* 03）9099.99的实现，小数位四舍五入不够位数补0，整数位超出位数的长度 - indexOf("0")的长度补0，剩余位数补空格；
* 04）FM99.99：去除整数位补位的空格和小数位补位的0
* 05）FM99099.99：去除整数位补位的空格和小数位补位的0
* 06）FM99099.99099：去除整数位补位的空格和从小数点最右边那个0之后的9补位的0
* 07）9G999或9G09G99G9G：分组处理（format带G不带小数），只要是带G的地方就替换为,号，在补0之后补空格之前处理。format从左往右出现第一个0之前的补空格中的G不做处理。固定位替换没有出现的位置不做替换和java中的DecimalFormat有所区别。G分组和,号分组不可同时出现。
* 08）9,999.99：分组（千）分隔符处理，和上面G分组处理一样，只是,号分组format可带小数部分，要做特殊处。G分组和,号分组不可同时出现。
* 09）999D999：小数点，按照正常.处理，但是含D不含.
* 10）999S或S999：带-或者+的处理，在出现在末尾就将-或者+放数字末尾，出现在首位负数不做处理，整数没有带+号的得带上。S只能出现在首尾位置且只能出现一次。
* 11）999MI：如果数字 < 0 将负号置于末尾位置，MI与S不能同时出现；
* 12）999PR：尖括号内负值，不能和S、MI同时存在，且只能出现在末尾位置，如果转换的数字为负数则去掉负号然后<>括起来；
* 13）L999：货币符号（使用本地化），在数字前面加上本地化的货币化符号，只能出现在首位位置；
* 14）RN：将阿拉伯数字转为罗马数字（输入在 1 和 3999 之间，否则返回：###############）;
* 15）99V999：移动n位小数，不能和D、.符号共存，最终可以将V换成.计算后再去掉.符号即为移动的位数;
*
* 二、日期format格式处理：
* 01）年份：
* Y,YYY：四位带逗号的年，如：2,018
* YYYY：四位的年，如：2018
* YYY：年的后三位，如：018
* YY：年的后两位，如：18
* Y：年的最后一位，如：8
* 02）月份（中文下取值都一样，都是：十一月）：
* month：全长小写月份名，如：november
* Month：全长混合大小写月份名，如：November
* MONTH：全长大写月份名，如：NOVEMBER
* mon：小写缩写月份名，如：nov
* Mon：缩写混合大小写月份名，如：Nov
* MON：大写缩写月份名，如：NOV
* MM：月份 (01-12) ，如：08、11
* 03）日：
* DDD：一年里的日子(001-366) ，如：311
* DD：一个月里的日子(01-31) ，如：07
* D：一周里的日子(1-7；SUN=1)，如：4
* 04）时：
* HH、HH12：一天的小时数 (01-12) 12小时制，如：02
* HH24：一天的小时数 (00-23) 24小时制，如：15
* 05）分：
* MI：分钟 (00-59)，如：50
* 06）秒
* SS：秒 (00-59)，如：12
* 07）星期（中文下都一样，取值都是：星期四）：
* DAY：全长大写日期名，如：THURSDAY
* Day：全长混合大小写日期名，如：Thursday
* day：全长小写日期名，如：thursday
* DY：缩写大写日期名，如：THU
* Dy：缩写混合大小写日期名，如：Thu
* dy：缩写小写日期名，如：thu
* 08）午夜00:00到当前时间的秒
* SSSSS：午夜后的秒 (0-86399)，如：55302
* 09）正午标识
* AM、A.M.、am、a.m.、PM、P.M.、pm、p.m.：如：中文显示：上午、下午；英文显示：给定值相同的格式和大小写，只是am、pm的区别
* 10）年标识
* BC、B.C.、bc、b.c.、AD、A.D.、ad、a.d.：如：中文显示：公元、公元前，英文显示：AD、BC
* 11）当月第几周
* W：如：1
* 12）当年第几周
* WW：如：45
* 13）世纪（2 位）
* CC：如：21
* 14）儒略日
* J：Julian 日期（自公元前4712年1月1日来的日期），如：2458430
* 15）季度
* Q：当前是第几季度，例如：4
* 16）罗马数字的月份
* RM：大写罗马月份，如：XI
* rm：小写罗马月份，如：xi
*
*
*
* @return 转换后的字符串
*/
public static <T> String to_char(T data, String format) {
if(data instanceof Date || data instanceof Instant || data instanceof LocalDateTime) {//日期格式化
LocalDateTime localDateTime;
if(data instanceof Date) {
localDateTime = LocalDateTime.ofInstant(((Date) data).toInstant(), ZoneId.systemDefault());
} else if(data instanceof Instant) {
localDateTime = LocalDateTime.ofInstant(((Instant) data), ZoneId.systemDefault());
} else {
localDateTime = (LocalDateTime) data;
}
Locale locale = Locale.UK;
//年
String year = String.valueOf(localDateTime.getYear());
//月，如：十一月 November
String month_full = localDateTime.getMonth().getDisplayName(TextStyle.FULL, locale);
//月，如：十一月 Nov
String month_short = localDateTime.getMonth().getDisplayName(TextStyle.SHORT, locale);
//月，如：11
String month_num = String.valueOf(localDateTime.getMonthValue() > 9 ? localDateTime.getMonthValue() : "0" + localDateTime.getMonthValue());
//当月第几天，如：8
String dayOfMonth = String.valueOf(localDateTime.getDayOfMonth() > 9 ? localDateTime.getDayOfMonth() : "0" + localDateTime.getDayOfMonth());
//当年第几天，如：312
String dayOfYear = String.valueOf(localDateTime.getDayOfYear());
//当周第几天，如：5（localdatetime获取的都是本地化的，老外的一周是从周日开始的，所以加一）
String dayOfWeek = String.valueOf(localDateTime.getDayOfWeek().getValue() + 1);
//小时HH24
String hour24 = String.valueOf(localDateTime.getHour() > 9 ? localDateTime.getHour() : "0" + localDateTime.getHour());
//小时12
int hour12_temp = localDateTime.getHour();
if(localDateTime.getHour() > 12) {
hour12_temp -= 12;
}
String hour12 = String.valueOf(hour12_temp > 9 ? hour12_temp : "0" + hour12_temp);
//分
String minute = String.valueOf(localDateTime.getMinute() > 9 ? localDateTime.getMinute() : "0" + localDateTime.getMinute());
//秒
String second = String.valueOf(localDateTime.getSecond() > 9 ? localDateTime.getSecond() : "0" + localDateTime.getSecond());
//星期
String week_short = localDateTime.getDayOfWeek().getDisplayName(TextStyle.SHORT, locale);
String week_full = localDateTime.getDayOfWeek().getDisplayName(TextStyle.FULL, locale);
//午夜0点到现在的秒数
String mid_second = String.valueOf(ChronoUnit.SECONDS.between(LocalDateTime.of(localDateTime.getYear(), localDateTime.getMonthValue(), localDateTime.getDayOfMonth(), 0, 0, 0), localDateTime));
//正午标识AM or PM
String high_noon_symbol = localDateTime.format(DateTimeFormatter.ofPattern("a", locale));
String ampm_dot = high_noon_symbol;
if(locale.getLanguage().equals("en")) {
ampm_dot = (new StringBuilder(ampm_dot).insert(1, ".").insert(3, ".")).toString();
}
//世纪标识 AD or BC
String century_symbol = localDateTime.format(DateTimeFormatter.ofPattern("G", locale));
String adbc_dot = century_symbol;
if(locale.getLanguage().equals("en")) {
adbc_dot = (new StringBuilder(adbc_dot).insert(1, ".").insert(3, ".")).toString();
}
//当月第几周
String weekOfMonth = localDateTime.format(DateTimeFormatter.ofPattern("W", locale));
//当年第几周
String weekOfYear = localDateTime.format(DateTimeFormatter.ofPattern("w", locale));
//获取给定的时间是第几世纪
String century = String.valueOf((int) Math.ceil(localDateTime.getYear() / 100.0));
//儒略日
int a = (14 - localDateTime.getMonthValue()) / 12;
int y = localDateTime.getYear() + 4800 - a;
int m = localDateTime.getMonthValue() + 12 * a - 3;
String julian = String.valueOf(localDateTime.getDayOfMonth() + (153 * m + 2) / 5 + 365 * y + y / 4 - y / 100 + y / 400 - 32045);
//季度
String quarterOfYear = localDateTime.format(DateTimeFormatter.ofPattern("Q", locale));
//罗马数字的月份
String rm_month = to_char(localDateTime.getMonthValue(), "RN");
String date_format = format.replaceAll("((?i)Y),(?i)YYY", new StringBuilder(year).insert(1, ",").toString())//处理年：y,yyy 带逗号的年（4 和更多位）
.replaceAll("(?i)YYYY", year)//处理年：yyyy 年（4和更多位）
.replaceAll("(?i)YYY", year.substring(1))//处理年：yyy 年的后三位
.replaceAll("(?i)YY", year.substring(2))//处理年：yy 年的后两位
.replaceAll("(?<!DA|Da|da|D|d)(?i)Y", year.substring(3))//处理年：y 年的最后一位
.replaceAll("(?i)J", julian)//Julian日（自公元前4712年1月1日来的日期）
.replaceAll("MONTH", month_full.toUpperCase())//处理月份：MONTH 全长大写月份名（9字符）
.replaceAll("Month", month_full)//处理月份：Month 全长混合大小写月份名（9字符）
.replaceAll("month", month_full.toLowerCase())//处理月份：month 全长小写月份名（9字符）
.replaceAll("MON", month_short.toUpperCase())//处理月份：MON 大写缩写月份名（3字符）
.replaceAll("Mon", month_short)//处理月份：Mon 缩写混合大小写月份名（3字符）
.replaceAll("mon", month_short.toLowerCase())//处理月份：mon 小写缩写月份名（3字符）
.replaceAll("(?i)MM", month_num)//处理月：MM 月份 (01-12)
.replaceAll("(?i)DDD", dayOfYear)//处理日：DDD 一年里的日子(001-366)
.replaceAll("(?i)DD", dayOfMonth)//处理日：DD 一个月里的日子(01-31)
.replaceAll("(?<!a|A)(?i)D(?!ay|y|\\.|ecember)", dayOfWeek)//处理日：D 一周里的日子(1-7；SUN=1)
.replaceAll("(?i)HH24", hour24)//小时处理：HH24 一天的小时数 (00-23)
.replaceAll("(?i)HH12", hour12)//小时处理：HH12 一天的小时数 (01-12)
.replaceAll("(?i)HH", hour12)//小时处理：HH 一天的小时数 (01-12)
.replaceAll("(?i)MI", minute)//分钟处理：MI 分钟 (00-59)
.replaceAll("(?i)SSSSS", mid_second)//处理午夜后的秒：SSSSS (0-86399)
.replaceAll("(?i)SS", second)//秒处理：SS 秒 (00-59)
.replaceAll("WW", weekOfYear)//当年第几周
.replaceAll("W", weekOfMonth)//当月第几周
.replaceAll("DAY", week_full.toUpperCase())//处理星期：DAY 全长大写日期名（9字符）
.replaceAll("day", week_full.toLowerCase())//处理星期：day 全长小写日期名（9字符）
.replaceAll("Day", week_full)//处理星期：Day 全长混合大小写日期名（9字符）
.replaceAll("DY", week_short.toUpperCase())//处理星期：DY 缩写大写日期名（3字符）
.replaceAll("Dy", week_short)//处理星期：Dy 缩写混合大小写日期名（3字符）
.replaceAll("dy", week_short.toLowerCase())//处理星期：dy 缩写小写日期名（3字符）
.replaceAll("AM", high_noon_symbol)//正午标识：AM
.replaceAll("A.M.", ampm_dot)//正午标识：A.M.
.replaceAll("am", high_noon_symbol.toLowerCase())//正午标识：am
.replaceAll("a.m.", ampm_dot.toLowerCase())//正午标识：a.m.
.replaceAll("PM", high_noon_symbol)//正午标识：PM
.replaceAll("P.M.", ampm_dot)//正午标识：P.M.
.replaceAll("pm", high_noon_symbol.toLowerCase())//正午标识：pm
.replaceAll("p.m.", ampm_dot.toLowerCase())//正午标识：p.m.
.replaceAll("AM", high_noon_symbol)//正午标识：AM
.replaceAll("BC", century_symbol)//世纪标识：BC
.replaceAll("bc", century_symbol.toLowerCase())//世纪标识：bc
.replaceAll("B.C.", adbc_dot)//世纪标识：B.C.
.replaceAll("b.c.", adbc_dot.toLowerCase())//世纪标识：b.c.
.replaceAll("AD", century_symbol)//世纪标识：AD
.replaceAll("A.D.", adbc_dot)//世纪标识：A.D.
.replaceAll("ad", century_symbol.toLowerCase())//世纪标识：ad
.replaceAll("a.d.", adbc_dot.toLowerCase())//世纪标识：a.d.
.replaceAll("(?i)CC", century)//世纪：CC
.replaceAll("(?i)Q", quarterOfYear)//当前是第几季度：Q
.replaceAll("RM", rm_month)//大写罗马月份：RM
.replaceAll("rm", rm_month.toLowerCase())//小写罗马月份：rm
;
return date_format;
} else {//数字格式化
try {
format = format.toUpperCase();
//format合法性判断：FM只能出现在首位位置、G不能出现在首位位置
if(!format.matches("^[FM]*[0|9|.|,|PR|S|L|D|G|MI|RN|V]*")) {
throw new IllegalArgumentException("无效的数字格式模型");
}
//判断是否含G（分组）处理，含G不含小数位，且和,不能同时存在
if(format.contains("G") && (format.contains(".") || format.contains(",") || format.startsWith("G"))) {
throw new IllegalArgumentException("无效的数字格式模型");
}
//判断D和.不能同时存在，且只能出现一次
if(format.contains("D") && (CommonUtil.count(format, "D") > 1 || format.contains("."))) {
throw new IllegalArgumentException("无效的数字格式模型");
}
//判断S只能出现在首位位置且只能出现一次
if(format.contains("S") && (CommonUtil.count(format, "S") > 1 || (!format.startsWith("S") && !format.endsWith("S")))) {
throw new IllegalArgumentException("无效的数字格式模型");
}
//判断MI和S不能同时出现，且只能出现在末尾位置
if(format.contains("MI") && (CommonUtil.count(format, "MI") > 1 || format.contains("S") || !format.endsWith("MI"))) {
throw new IllegalArgumentException("无效的数字格式模型");
}
//判断PR和S、MI不能同时存在，且只能出现在末尾位置
if(format.contains("PR") && (CommonUtil.count(format, "PR") > 1 || format.contains("S") || format.contains("MI") || !format.endsWith("PR"))) {
throw new IllegalArgumentException("无效的数字格式模型");
}
//判断L货币符号，只能出现在首位位置
if(format.contains("L") && !format.startsWith("L")) {
throw new IllegalArgumentException("无效的数字格式模型");
}
//判断V，不能和D、.符号共存，且只能出现一次
if(format.contains("V") && (CommonUtil.count(format, "V") > 1 || format.contains("D") || format.contains("."))) {
throw new IllegalArgumentException("无效的数字格式模型");
}
//处理D，换成.运算
format = format.replace("D", ".");
//处理V，换成.运算
boolean v_symbol = false;
if(format.contains("V")) {
v_symbol = true;
format = format.replace("V", ".");
}
String data_str = to_char(data);
//处理RN，转换为罗马数字
if (format.equals("RN")) {
int[] numArray = new int[]{1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
String[] romaArray = new String[]{"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
StringBuffer stringBuffer = new StringBuffer();
int num = (int) Math.round(Double.valueOf(data_str));
if (num < 0 || num > 3999) {
return "###############";
}
for (int i = 0; i < numArray.length; i++) {
int temp = num / numArray[i];
while (temp > 0) {
stringBuffer.append(romaArray[i]);
temp--;
}
num = num % numArray[i];
}
return stringBuffer.toString();
}
//按照plsql执行结果，当format整数部分位数不够data整数部分位数的时候返回format整数位数+1位的# + format小数位+1的#
String[] format_num = format.replaceAll("[A-Za-z,]", "").split("\\.");
String[] data_num = data_str.replace("-", "").replace("+", "").split("\\.");
if(format_num[0].length() < data_num[0].length()) {
String result = format_num[0].replaceAll("[9|0]", "#") + "#";
if(format_num.length == 2) {
result += format_num[1].replaceAll("[9|0]", "#") + "#";
}
return result;
}
//将9处理成#和0让DecimalFormat可以识别
BigDecimal bigDecimal = new BigDecimal(data_str);
String pattern = format_num[0].replace("9", "#").replace("0", "#");//#是不参与补位的
if(format_num.length == 2) {
if (format.startsWith("FM")) {
//去除小数点后除0补位的0之后由9补位的0
pattern += "." + format_num[1].substring(0, format_num[1].lastIndexOf("0") + 1).replace("9", "0");
pattern += format_num[1].substring(format_num[1].lastIndexOf("0") + 1).replace("9", "#");
} else {
pattern += "." + format_num[1].replace("9", "0");//小数点右边转换成0好补位
}
}
DecimalFormat decimalFormat = new DecimalFormat(pattern);
decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
String result = decimalFormat.format(bigDecimal);
//处理整数部位多余的9补空格、0补0
int beyond_length = format_num[0].length() - data_num[0].length();//整数位格式化超出位数6 format=909909000000.00 data=123456.123456
String sub_format = format_num[0].substring(0, beyond_length);//获取超出位数的格式字符0-6 sub_format=909909
int zero_pos = sub_format.indexOf("0");//从左到右第一次出现0的位置 zero_pos=1
int zero_patch_len = 0, blank_patch_len = 0;
if (zero_pos > -1) {
zero_patch_len = sub_format.length() - zero_pos;//计算补0的个数 6 - 1 = 5
}
blank_patch_len = beyond_length - zero_patch_len;//计算补空格个数 6 - 5 = 1
//整数位补0
while (zero_patch_len > 0) {
if (result.contains("+")) {
result = result.replace("+", "+0");
} else if (result.contains("-")) {
result = result.replace("-", "-0");
} else {
result = "0" + result;
}
zero_patch_len -= 1;
}
//处理带G和,的分组
int sub_index = 0, total_index = 0;
//通过原始format中整数数字的位数和最终格式化后数字的整数位数对比获取真实的format的作用长度，也就是将format中的G对应到结果数字中的位置，并替换成,
String integer_format = format.indexOf(".") == -1 ? format : format.substring(0, format.indexOf("."));//防止,号分组会出现小数位的问题
for (int i = integer_format.toCharArray().length - 1; i >= 0 ; i--) {
if(Character.isDigit(integer_format.charAt(i))) {
sub_index += 1;
}
total_index += 1;
if(sub_index == result.replace("-", "").replace("+", "").split("\\.")[0].length()) {
break;
}
}
String format_temp = integer_format.substring((integer_format.length() - total_index));
//将,号分组处理换成G分组一起处理
format_temp = format_temp.replace(",", "G");
int g_index = format_temp.indexOf("G");//G第一个出现的索引位置
StringBuilder sb = new StringBuilder(result);
while (g_index != -1) {
int insert_index = g_index;
if(sb.indexOf("-") != -1 || sb.indexOf("+") != -1) {
insert_index += 1;
}
sb.insert(insert_index, ",");
g_index = format_temp.indexOf("G", g_index + 1);//*从这个索引往后开始第一个出现的位置
}
result = sb.toString();
System.out.println("format=" + format);
//处理S，断定只出现首位位置
if(format.startsWith("S")) {
if(!result.startsWith("+") && !result.startsWith("-")) {
result = "+" + result;
}
} else if(format.endsWith("S")) {
if(!result.startsWith("+") && !result.startsWith("-")) {
result += "+";
} else if(result.startsWith("+")) {
result = result.replace("+", "");
result += "+";
} else if(result.startsWith("-")) {
result = result.replace("-", "");
result += "-";
}
}
//处理MI，断定只出现末尾位置，且为负数的时候才处理
if(format.endsWith("MI") && result.startsWith("-")) {
result = result.replace("-", "");
result += "-";
}
//处理PR，断定只出现在末尾位置，且为负数的时候才做处理
if(format.endsWith("PR") && result.startsWith("-")) {
result = result.replace("-", "");
result = "<" + result + ">";
}
//处理L，断定只出现在首位位置
if(format.startsWith("L")) {
//获取本地货币符号
String currency_format = DecimalFormat.getCurrencyInstance(Locale.getDefault()).format(1);
String currency_symbol = currency_format.substring(0, 1);
if(result.startsWith("-")) {
result = result.replace("-", "-" + currency_symbol);
} else {
result = currency_symbol + result;
}
}
//处理V，上面是作为小数点处理的，只需要去掉小数点就相当于移动的小数
if(v_symbol) {
result = result.replace(".", "");
}
//FM处理，判断是否去空格
if (!format.startsWith("FM")) {
//最左边补空格
while (blank_patch_len > 0) {
result = " " + result;
blank_patch_len -= 1;
}
}
return result;
} catch (NumberFormatException nfe) {
throw new IllegalArgumentException("无效的数字");
}
}
}
