Java中的数字工具类—–持续总结中

标题

  • java获取任意数字的个位，十位，百位，千位，万位…
  • JAVA实现数值跟人民币大写(中文简体、繁体)互转
  • Java实现数值金额指定分割符
  • java代码去除千分号
  • BigDecimal判空处理
  • BigDecimal类型的数字转化为百分之 (%)
  • DecimalFormat数字格式方法总结
  • 既然都提到了这里我就顺便普及一下DecimalFormat详解
  • java汉字数字转成阿拉伯数字工具
  • Java中BigDecimal常用方法
  • 阿拉伯数字罗马数字互转
  • JAVA中的随机数
  • Java判断奇数偶数质数合数最大公约数、最小公倍数
  • Math中的数字处理方法
  • 文件大小转换
  • 回文数
  • 算法题网址
  • BigDecimal计算不及Double等快
  • 判断当前年是否为闰年

关于下面这些方法，百度一大堆，但是很多都经不起推敲，大部分都没有好好测试写的方法能不能扛得住数字的校验。下面都是我测试了很多极端数字，挑选出的合格方法，当然可能也考虑的不全面，欢迎检验指正。同时希望大家分享一下好用的数值相关的工具类，让我总结其中，万分感谢。

java获取任意数字的个位，十位，百位，千位，万位…

    /*** * @param num 目标数字* @param locationNum 1表示获取个位，10表示获取十位，100表示获取百位 依次类推* @return*/public static int getLocationNum(int num, int locationNum) {return num / locationNum % 10;}

JAVA实现数值跟人民币大写(中文简体、繁体)互转

ChineseToNumber、NumberToChinese 这两个方法已经够用实现数值跟人民币的各种互化。
主要根据你的需求，把方法对应改改就能用 （可实现 数值、人民币简体、繁体之间的互转），

支持繁体、简体格式======》数值
在这里插入图片描述

import java.math.BigDecimal;public class ChineseToNumber {/*** 中文简体*/public static final String[] RMB_NUMBERS = new String[]{"一", "二", "三", "四", "五", "六", "七", "八", "九", "零"};/*** 中文繁体*/public static final String[] BIG_RMB_NUMBERS = new String[]{"壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖", "零"};/*** 与汉字相应的转化的数字*/public static final Long[] TO_ARABIC_NUMBERS = new Long[]{1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 0L};/*** 人民币单位关键词  简写（大写数字倍数，一定要由大到小）*/public static final String[] RMB_UNIT = new String[]{"亿", "万", "千", "百", "十", "元", "角", "分", "厘"};/*** 繁体*/public static final String[] BIG_RMB_UNIT = new String[]{"億", "萬", "仟", "佰", "拾", "圆", "角", "分", "厘"};/*** 与人民币单位关键词对应的基数*/public static final BigDecimal[] TO_CARDINAL_NUMBERS = new BigDecimal[]{new BigDecimal(100000000L), new BigDecimal(10000L), new BigDecimal(1000L),new BigDecimal(100L), BigDecimal.TEN, BigDecimal.ONE, new BigDecimal("0.1"),new BigDecimal("0.01"), new BigDecimal("0.001")};/*** todo  已亲测试好用  支持繁体、简体格式* 大写转化为小写数值的过程操作  支持到小数点后3位* 壹仟零壹拾壹亿零壹仟零捌元伍分====>101100001008.05* 一千零一十一亿零一千零八元五分====>101100001008.05* 没有用number而使用了BigDecimal，是由于number可能导致精度丢失。* 该工具类处理最多能处理小数点前14位的数字金额，一般网站的转化大多也是如此。*/public static BigDecimal ChineseToNumber(String money) {BigDecimal number = getDigitalNum(money);//return Double.parseDouble(number.toString());//return number.toString();return new BigDecimal(number.toString());}/*** 辅助类，处理中文数字转换成阿拉伯数字，利用递归算法** @param money* @return*/public static BigDecimal getDigitalNum(String money) {BigDecimal result = BigDecimal.ZERO;if ((money == null || money.trim().length() <= 0)) {return result;}//匹配大写金额的单位for (int i = 0; i < RMB_UNIT.length; i++) {//查找字符中的简繁单位int index = money.lastIndexOf(RMB_UNIT[i]) == -1 ? money.lastIndexOf(BIG_RMB_UNIT[i]): money.lastIndexOf(RMB_UNIT[i]);if (index >= 0) {String pre_money = money.substring(0, index);//截取当前单位前面的中文字符串money = money.substring(index + 1);//截取当前单位后面的字符串，进行下一次迭代比较if ((pre_money == null || pre_money.length() <= 0) && TO_CARDINAL_NUMBERS[i].intValue() == 10) {//处理拾开头的特殊字符例如拾、十result = result.add(TO_CARDINAL_NUMBERS[i]);} else {//对当前单位截取的前面的字符递归处理result = result.add(getDigitalNum(pre_money).multiply(TO_CARDINAL_NUMBERS[i]));}}}//如果不带单位直接阿拉伯数字匹配替换if (money != null && money.length() > 0) {result = result.add(getArabicNumByBig(money));}return result;}/*** 辅助类中文数字转为对应阿拉伯数字** @param big* @return*/public static BigDecimal getArabicNumByBig(String big) {BigDecimal result = BigDecimal.ZERO;for (int j = 0; j < RMB_NUMBERS.length; j++) {big = big.replaceAll(RMB_NUMBERS[j], TO_ARABIC_NUMBERS[j].toString());//中文小写替换big = big.replaceAll(BIG_RMB_NUMBERS[j], TO_ARABIC_NUMBERS[j].toString());//中文大写替换}try {result = new BigDecimal(big);} catch (Exception e) {result = BigDecimal.ZERO;}return result;}public static void main(String[] args) {System.out.println(ChineseToNumber("一千零一十一亿零一千零八元一分"));System.out.println(ChineseToNumber("一千零一十一亿零一千零八元五分"));System.out.println(ChineseToNumber("壹仟零壹拾壹亿零壹仟零捌元伍分"));}}

数值======》支持繁体、简体格式
在这里插入图片描述


/*** 金额数字大小写转化*/
public class NumberToChinese {/*** 大写数字*/private static final String[] NUMBERS = {"零", "壹", "贰", "叁", "肆", "伍","陆", "柒", "捌", "玖"};
//中文小写汉字形式
//    private static final String[] NUMBERS = {"零", "一", "二", "三", "四", "五",
//            "六", "七", "八", "九"};/*** 整数部分的单位*/private static final String[] IUNIT = {"元", "拾", "佰", "仟", "万", "拾", "佰","仟", "亿", "拾", "佰", "仟", "万", "拾", "佰", "仟"};//    private static final String[] IUNIT = {"元", "十", "百", "千", "万", "十", "百",
//            "千", "亿", "十", "百", "千", "万", "十", "百", "千"};/*** 小数部分的单位*/private static final String[] DUNIT = {"角", "分", "厘"};/*** todo  已亲测试好用  支持数值转大、小写 并支持到小数点后3位* 101100001008.0509 ====> 壹仟零壹拾壹亿零壹仟零捌元伍分* 101100001008.01 ====> 一千零一十一亿零一千零八元五分*/public static String toChinese(String str) {str = str.replaceAll(",", "");// 去掉","String integerStr;// 整数部分数字String decimalStr;// 小数部分数字// 初始化：分离整数部分和小数部分if (str.indexOf(".") > 0) {integerStr = str.substring(0, str.indexOf("."));decimalStr = str.substring(str.indexOf(".") + 1);} else if (str.indexOf(".") == 0) {integerStr = "";decimalStr = str.substring(1);} else {integerStr = str;decimalStr = "";}// integerStr去掉首0，不必去掉decimalStr的尾0(超出部分舍去)if (!integerStr.equals("")) {integerStr = Long.toString(Long.parseLong(integerStr));if (integerStr.equals("0")) {integerStr = "";}}// overflow超出处理能力，直接返回if (integerStr.length() > IUNIT.length) {System.out.println(str + ":超出处理能力");return str;}int[] integers = toArray(integerStr);// 整数部分数字boolean isMust5 = isMust5(integerStr);// 设置万单位int[] decimals = toArray(decimalStr);// 小数部分数字return getChineseInteger(integers, isMust5)+ getChineseDecimal(decimals);}/*** 整数部分和小数部分转换为数组，从高位至低位*/private static int[] toArray(String number) {int[] array = new int[number.length()];for (int i = 0; i < number.length(); i++) {array[i] = Integer.parseInt(number.substring(i, i + 1));}return array;}/*** 得到中文金额的整数部分。*/private static String getChineseInteger(int[] integers, boolean isMust5) {StringBuffer chineseInteger = new StringBuffer("");int length = integers.length;for (int i = 0; i < length; i++) {// 0出现在关键位置：1234(万)5678(亿)9012(万)3456(元)// 特殊情况：10(拾元、壹拾元、壹拾万元、拾万元)String key = "";if (integers[i] == 0) {if ((length - i) == 13)// 万(亿)(必填)key = IUNIT[4];else if ((length - i) == 9)// 亿(必填)key = IUNIT[8];else if ((length - i) == 5 && isMust5)// 万(不必填)key = IUNIT[4];else if ((length - i) == 1)// 元(必填)key = IUNIT[0];// 0遇非0时补零，不包含最后一位if ((length - i) > 1 && integers[i + 1] != 0)key += NUMBERS[0];}chineseInteger.append(integers[i] == 0 ? key: (NUMBERS[integers[i]] + IUNIT[length - i - 1]));}return chineseInteger.toString();}/*** 得到中文金额的小数部分。*/private static String getChineseDecimal(int[] decimals) {StringBuffer chineseDecimal = new StringBuffer("");for (int i = 0; i < decimals.length; i++) {// 舍去3位小数之后的if (i == 3)break;chineseDecimal.append(decimals[i] == 0 ? "": (NUMBERS[decimals[i]] + DUNIT[i]));}return chineseDecimal.toString();}/*** 判断第5位数字的单位"万"是否应加。*/private static boolean isMust5(String integerStr) {int length = integerStr.length();if (length > 4) {String subInteger = "";if (length > 8) {// 取得从低位数，第5到第8位的字串subInteger = integerStr.substring(length - 8, length - 4);} else {subInteger = integerStr.substring(0, length - 4);}return Integer.parseInt(subInteger) > 0;} else {return false;}}public static String toChineseByNumber(String number) {String numberChinese = toChinese(number);if (numberChinese != null && numberChinese.indexOf("元") > 0) {numberChinese = numberChinese.replaceAll("元", "");}return numberChinese;}public static void main(String[] args) {String num1 = "101100001008.01";//壹仟零壹拾壹亿零壹仟零捌元壹分String num2 = "101100001008.0509";//壹仟零壹拾壹亿零壹仟零捌元伍分System.out.println(num1 + " " + toChinese(num1));System.out.println(num2 + " " + toChinese(num2));String number = "1.23";System.out.println(number + " " + toChinese(number));number = "1501000002658.123";//壹万伍仟零壹拾亿零贰仟陆佰伍拾捌元壹角贰分叁厘System.out.println(number + " " + toChinese(number));number = "1234567890123456.123";System.out.println(number + " " + toChinese(number));number = "0.0798";System.out.println(number + " " + toChinese(number));number = "10,001,000.09";System.out.println(number + " " + toChinese(number));number = "01.107700";System.out.println(number + " " + toChinese(number));number = "342534.23";System.out.println(number + " " + toChinese(number));number = "90029.35";System.out.println(number + " " + toChinese(number));number = "夺";try {System.out.println(number + " " + toChineseByNumber(number));} catch (Exception e) {// TODO: handle exception}System.out.println("======================");}}

这个跟 NumberToChinese 效果一致(放这里多一个方法，使用时用上面的即可)
在这里插入图片描述


public class TestAmount {public static void main(String[] args) {
//		String num = "101,100,001,008.013";//壹仟零壹拾壹亿零壹仟零捌元壹分String num = "101,100,001,008.0509";//壹仟零壹拾壹亿零壹仟零捌元伍分System.out.println(numberToWord(num));//}/*** 这个跟 NumberToChinese 效果一致 只不过参数是有分割符，去掉分割符就能用 NumberToChinese，多一个思想方法吧* 这个目前支持到小数点后两位，要是想继续往后，可打开我下面注释1、注释2(是可以继续扩展的)* "101,100,001,008.0509" ===> 壹仟零壹拾壹亿零壹仟零捌元伍分* 已亲测验证可用** @param num* @return*/public static String numberToWord(String num) {String integer;String small = "";boolean zeroFlag = false;boolean omitFlag = false;//省略标志，比如100万后面的0boolean hasSmall = false;//是否有小数String[] unit = {"元", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾", "佰", "仟"};String[] numberWord = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};String[] smallUnit = {"角", "分"};
//		String[] smallUnit = {"角", "分", "厘","毫"};// todo 注释1StringBuilder result = new StringBuilder();StringBuilder tmpSb = new StringBuilder();String number;char tmpChar;if (num.indexOf(",") > 0) {for (int i = 0; i < num.length(); i++) {tmpChar = num.charAt(i);if (tmpChar != ',') {tmpSb.append(tmpChar);}}number = tmpSb.toString();} else {number = num;}if (number.indexOf(".") > 0) {String[] twoParts = number.split("\\.");integer = twoParts[0];small = twoParts[1];} else {integer = number;small = "";}String tmp;int tmpInt;int integerLengh = integer.length() > unit.length ? unit.length : integer.length();for (int i = 0; i < integerLengh; i++) {tmp = String.valueOf(integer.charAt(i));tmpInt = Integer.valueOf(tmp).intValue();if (tmpInt == 0) {if (integerLengh - 1 - i == 4 || integerLengh - 1 - i == 8) {//如果这位是万、亿时if (omitFlag) {
//						System.out.println("if:"+unit[integerLengh-1-i]);continue;} else {System.out.println("else:" + unit[integerLengh - 1 - i]);omitFlag = true;result.append(unit[integerLengh - 1 - i]);}} else if (integerLengh - 1 - i == 0) {//这位是元，拼单位result.append(unit[integerLengh - 1 - i]);} else {//其他位，遇到0，更改标志，继续zeroFlag = true;continue;}} else {//非0，并且之前是0if (zeroFlag) {//如果这位是亿、万、元时，先填零，再拼数字result.append(numberWord[0]);} else {//之前也不是0，正常//如果是亿位if (integerLengh - 1 - i == 8) {omitFlag = true;}}zeroFlag = false;result.append(numberWord[tmpInt]).append(unit[integerLengh - 1 - i]);}}if (!("".equals(small) || null == small)) {for (int i = 0; i < smallUnit.length; i++) {
//			for(int i=0; i < small.length(); i++){// todo 注释2tmp = String.valueOf(small.charAt(i));tmpInt = Integer.valueOf(tmp).intValue();if (tmpInt == 0) {continue;}result.append(numberWord[tmpInt]).append(smallUnit[i]);hasSmall = true;}} else {//没有小数}if (!hasSmall) {//没有小数或者小数都是0result.append("整");}return result.toString();}
}

Java实现数值金额指定分割符

在这里插入图片描述

package all.canshu.keshan.first.demo1.del;import java.math.BigDecimal;
import java.text.DecimalFormat;public class Test {/*** 转换方法  默认3位分割，并且四舍五入保留3位小数* 如果说我不要四舍五入呢，BigDecimal类有7种保留策略功能选择*/public static String parseMoney(String pattern, BigDecimal bd) {DecimalFormat df;if ("".equals(pattern) || null == pattern) {// DecimalFormat的用法 #,###是三位分割一下 .00是小数点后保留两位 四舍五入df = new DecimalFormat("#,###.00");} else {df = new DecimalFormat(pattern);}return df.format(bd);}public static void main(String[] args) {System.out.println(parseMoney(",###,##0.00", new BigDecimal("1234567890.48596"))); //1,234,567,890.49System.out.println(parseMoney(",###,##0.0000", new BigDecimal("1234567890.48596"))); //1,234,567,890.4860System.out.println(parseMoney(",####,###0.0000", new BigDecimal("1234567890.48596"))); //12,3456,7890.4860}
}

关于格式化写法误区,下面3中写法结果都一样，也就是真正生效的只是,###
至于.00 那是你不够2位小数我就给你补0 .##则是 不够2位我就直接保留不给你补0。
为了更好理解我下面普及一下DecimalFormat详解里面有#跟0这块知识(参考下个一级标题内容)


//    df = new DecimalFormat(",###.00");
//    df = new DecimalFormat("###,###.00");
//    df = new DecimalFormat(",######,##,###.00");

继续深入理解
在这里插入图片描述


public static void main(String[] args) {System.out.println(numberFormart("###,##0.## ",new BigDecimal("0.0000052")));//0System.out.println(numberFormart("###,##0.## ",new BigDecimal("0.0251052")));//0.03System.out.println(numberFormart("###,##0.## ",new BigDecimal("12000.5200")));//12,000.52System.out.println(numberFormart("###,##0.## ",new BigDecimal("12000.52120")));//12,000.52System.out.println(numberFormart("###,###.## ",new BigDecimal("12000.52120")));//12,000.52System.out.println(numberFormart("###,000.## ",new BigDecimal("12000.52120")));//12,000.52System.out.println(numberFormart("###,000.## ",new BigDecimal("10.52120")));//010.52System.out.println(numberFormart("###,#00.## ",new BigDecimal("10.52120")));//10.52System.out.println(numberFormart("###,##0.## ",new BigDecimal("10.52120")));//10.52System.out.println(numberFormart("###,0.## ",new BigDecimal("10.52120")));//1,0.52}/*** 将数字转换成带逗号的字符串（"###,##0.## "）* @param reg 格式化串* @param number 需要转换的数字* @return*/public static String numberFormart(String reg,BigDecimal number){DecimalFormat bf = new DecimalFormat(reg);return bf.format(number);}

如果我要指定分割符该怎么做
最简单的做法就是使用replace来替换即可达到目标。
这块我记得是可以设置分割符的，由于没有找到先空着，找到了在补充

//就是设置个参数，反正不是下面这个，不过没事研究一下下面几个参数的含义
//待整理
DecimalFormat df = new DecimalFormat();df.setMinimumFractionDigits(3);df.setMaximumFractionDigits(3);df.setMinimumIntegerDigits(1);df.setMaximumIntegerDigits(3);df.setGroupingSize(20);df.setRoundingMode(RoundingMode.HALF_UP);df.setGroupingUsed(true);

java代码去除千分号

上面加了千分号后我想去除怎么办，你依旧可以使用replace

    /*** 会丢失小数点后无用的0*/public static BigDecimal parseMoney(String moneyBefter) {BigDecimal money = BigDecimal.ZERO;try {//将一个string类型的去除千分位符号,并转换为double类型double doubleValue = new DecimalFormat().parse(moneyBefter).doubleValue();money = new BigDecimal(Double.toString(doubleValue));} catch (ParseException e) {e.printStackTrace();}return money;}/*** 这个就完美保留原数值*/public static BigDecimal parseMoney1(String moneyBefter) {String replace = moneyBefter.replace(",", "");return new BigDecimal(replace);}

BigDecimal判空处理

 /*** 仅针对 BigDecimal为空则赋值为0* @param bigDecimalValue* @return*/public static BigDecimal getDecimalIsNullRetrunZero(BigDecimal bigDecimalValue){return bigDecimalValue == null ? BigDecimal.ZERO :bigDecimalValue;}/*** 在上面基础上增加了保留位数及舍入策略* @param bigDecimalValue* @param newScale* @param roundingMode    如 BigDecimal.ROUND_HALF_UP* @return*/public static BigDecimal getDecimalIsNullRetrunZero(BigDecimal bigDecimalValue, int newScale, RoundingMode roundingMode){return bigDecimalValue == null ? BigDecimal.ZERO :bigDecimalValue.setScale(newScale,roundingMode);}/*** 在上面基础上增加了格式化* @param bigDecimalValue* @param newScale* @param roundingMode    如 BigDecimal.ROUND_HALF_UP* @param format    如果格式化字段为空，默认是保留两位小数并且按照逗号按照3位来进行分隔* @return*/public static String getDecimalIsNullRetrunZero(BigDecimal bigDecimalValue, int newScale, RoundingMode roundingMode, String format){if (StringUtils.isBlank(format)) {format = "###,##0.00";}DecimalFormat decimalFormat = new DecimalFormat(format);//这块为空是要补0还是空串根据业务实时更换即可return bigDecimalValue == null ? decimalFormat.format(BigDecimal.ZERO) :decimalFormat.format(bigDecimalValue.setScale(newScale,roundingMode));}

BigDecimal类型的数字转化为百分之 (%)

根据需求设置保留格式

 /*** BigDecimal类型的数字转化为百分之 * 注意这个会自己乘100*/public static String BigDecimalPercent(BigDecimal doubleNum) {DecimalFormat df = new DecimalFormat("##.00%");if (doubleNum.stripTrailingZeros().compareTo(BigDecimal.ZERO)==0){
//            return "0%";return "0"+df.format(doubleNum);}String format = df.format(doubleNum);if (format.indexOf(".")==0){return "0"+format;}return format;}public static void main(String[] args) {System.out.println(BigDecimalPercent(new BigDecimal("0.1020")));//10.20%System.out.println(BigDecimalPercent(new BigDecimal("0.0000")));//0.00%//下面这两种情况比较尴尬，加个判断 format.indexOf(".")==0 给前面加个0就正常了System.out.println(BigDecimalPercent(new BigDecimal("0.0050")));//.50%==>0.50%System.out.println(BigDecimalPercent(new BigDecimal("0.00050")));//.05%==>0.05%System.out.println(BigDecimalPercent(new BigDecimal("0.050")));//5.00%System.out.println(BigDecimalPercent(new BigDecimal("10.20")));//1020.00%System.out.println(BigDecimalPercent(new BigDecimal("150.016")));//15001.60%System.out.println(BigDecimalPercent(new BigDecimal("360.36906")));//36036.91%System.out.println(BigDecimalPercent(new BigDecimal("1")));//100.00%}

DecimalFormat数字格式方法总结

/*** 这一块我本来想抽个方法出来直接传参即可，但是可设置的参数太多了，也不想做成可变参数，故给出每个参数的含义* 读者可根据需要抽取成对应方法即可* @param format       格式化格式，不传摸默认保留两位小数，不足补0  注意此参数非常灵活，#跟0的含义自己领悟,还可以自定义任意字符串，很强大* @param roundingMode 舍入模式 不传默认情况下，它使用RoundingMode.HALF_EVEN* @param num* @return*/public static String getDecimalFormatResult(String format, RoundingMode roundingMode, double num) {DecimalFormat df = new DecimalFormat("#.00");if (null != format && !"".equals(format)) {df.applyPattern(format);}if (null != roundingMode) {//指定RoundingMode舍入策略df.setRoundingMode(roundingMode);}DecimalFormatSymbols symbols = new DecimalFormatSymbols();//设置默认的，小数点为自定义字符symbols.setDecimalSeparator('.');//设置默认的,分割符为任意自定义的分割符symbols.setGroupingSeparator(',');df.setDecimalFormatSymbols(symbols);//是否使用分组df.setGroupingUsed(true);//默认是隔3位分组的，你可以自定义隔几位分割df.setGroupingSize(3);// 设置国家货币符号 参数为ISO 4217标准，如果构造参数添加‘¤’符号，   "CNY"   "INR"  "USD"df.setCurrency(Currency.getInstance(Locale.CHINA));//这个目前没用过 以后明白了在补充// 设置最多保留几位df.setMaximumFractionDigits(6);//最少保留几位, 可以是0 就是 取整数df.setMinimumFractionDigits(2);// 设置正数前缀,df.setPositivePrefix("+");// 设置正数后缀 但是替换掉 已有字符 参考--> 5211314@df.setPositiveSuffix("+");//设置负数前缀,只对负数有效df.setNegativePrefix("-$");// 设置负数后缀    只对负数有效df.setNegativeSuffix("-￥");return df.format(num);}

既然都提到了这里我就顺便普及一下DecimalFormat详解

在这里插入图片描述

如果注释没看懂，看懂例子基本也理解了
注意点：我例子都用的 BigDecimal它采用的是：四舍六入五考虑，而double 直接四舍五入. 根据你的需求灵活应用（如果你是BigDecimal想四舍五入可以使用new BigDecimal(double)或者直接使用double类型数据进行format），(且负数时候它的舍入策略可能不是这两种情况，反正也不用太担心舍入策略这个问题，根据具体需求来设置策略即可)当然了正规的做法是通过设置 RoundingMode属性
df.setRoundingMode(RoundingMode.DOWN);来设置你想要的舍入模式。

Java中BigDecimal类常用方法，舍入策略参考我这篇文章
纯0模式 new DecimalFormat("0000.000")
自动补零法
整数部分补零策略简单，注意小数部分补零可能涉及舍入策略

        // 0  一个数字，如果此位置有数字，则保持，没有数字则用0补齐。DecimalFormat df1 = new DecimalFormat("0000.000");//来好好看看这个补0是怎么补的，分两部分 整数部分，小数部分//整数部分，比如我们这里四个0表示整数部分必须>=4位,不够往前插入0到长度够4位，那整数够4位及以上直接全部输出即可//小数部分，比如我们这里三个0表示小数部分必须>=3位,不够往后插入0到长度够3位，那小数够3位及以上//这个时候分：如果刚好3位直接输出即可，如果4位那么就会采取Java中BigDecimal类 舍入策略之ROUND_HALF_EVEN(银行家算法)//四舍六入五考虑，五后非零就进一，五后为零看奇偶，五前为偶应舍去，五前为奇要进一System.out.println(df1.format(new BigDecimal("0")));//0000.000System.out.println(df1.format(new BigDecimal("1")));//0001.000System.out.println(df1.format(new BigDecimal("12.25")));//0012.250System.out.println(df1.format(new BigDecimal("12.2606")));//0012.261System.out.println(df1.format(new BigDecimal("12.2625")));//0012.262System.out.println(df1.format(new BigDecimal("12.2615")));//0012.262System.out.println(df1.format(new BigDecimal("12.26051")));//0012.261System.out.println(df1.format(new BigDecimal("12345678.26041")));//12345678.260double pi = 3.1415927;// 圆周率// 取整数部分  四舍五入System.out.println(new DecimalFormat("0").format(pi)); // 3System.out.println(new DecimalFormat("0").format(3.54)); // 4System.out.println(new DecimalFormat("0").format(13.54)); // 14System.out.println(new DecimalFormat("0").format(112333.54)); // 112334// 取所有整数部分 四舍五入System.out.println(new DecimalFormat("#").format(pi)); // 3System.out.println(new DecimalFormat("#").format(3335.565)); // 3

纯#模式 new DecimalFormat("####.###")
自动去零法

   // # 表示一个数字，但是不包括头尾的0， 即四舍六入五考虑，如果头尾包含0， 将去除掉，// 小数点前保留所有为，小数点后最多保留模式位。DecimalFormat df1 = new DecimalFormat("####.###");//上面这个不管小数点前有几个#，它们的结果都一样，作用都是去除整数部分0开头到非0之间的那些0//小数点后的#的多少代表着小数点最多保留位数，并且舍入策略是 四舍六入五考虑，五后非零就进一，// 五后为零看奇偶，五前为偶应舍去，五前为奇要进一，但是你要注意我是超过3位时只让你留3位//不够3位的直接输出可不会补零System.out.println(df1.format(new BigDecimal("0.5")));//0.5System.out.println(df1.format(new BigDecimal("0000.5")));//0.5System.out.println(df1.format(new BigDecimal("0000")));//0System.out.println(df1.format(new BigDecimal("0")));//0System.out.println(df1.format(new BigDecimal("1")));//1System.out.println(df1.format(new BigDecimal("0001")));//1System.out.println(df1.format(new BigDecimal("00010000")));//10000System.out.println(df1.format(new BigDecimal("12.25")));//12.25System.out.println(df1.format(new BigDecimal("00012.25")));//12.25System.out.println(df1.format(new BigDecimal("00012000.25")));//12000.25System.out.println(df1.format(new BigDecimal("12.2606")));//12.261System.out.println(df1.format(new BigDecimal("12.2625")));//12.262System.out.println(df1.format(new BigDecimal("12.2615")));//12.262System.out.println(df1.format(new BigDecimal("12.26051")));//12.261//这种 如果头尾包含0， 将去除掉System.out.println(df1.format(new BigDecimal("12345678.26041")));//12345678.26System.out.println(df1.format(new BigDecimal("12345678.260")));//12345678.26System.out.println(df1.format(new BigDecimal("12345678.261")));//12345678.26

这块我更正一下保留策略的问题，我例子都用的BigDecimal它采用的是：四舍六入五考虑，而double 直接四舍五入

double b;b=100.45;BigDecimal bigDecimal = new BigDecimal("100.45");//保留一位小数,四舍五入还是四舍六入五考虑DecimalFormat df1 = new DecimalFormat("####.#");System.out.println(df1.format(bigDecimal));  //100.4System.out.println(new DecimalFormat("0.0").format(bigDecimal));  //100.4System.out.println(df1.format(b));  //100.5System.out.println(new DecimalFormat("0.0").format(b));  //100.5System.out.println(new DecimalFormat("0.0").format(new BigDecimal(b)));  //100.5

那问题来了，我想要自己定义舍入模式怎么办
在单词上比BigDecimal少个ROUND_
在这里插入图片描述
Java中BigDecimal类常用方法，舍入策略参考我这篇文章

UP(BigDecimal.ROUND_UP),
DOWN(BigDecimal.ROUND_DOWN),
CEILING(BigDecimal.ROUND_CEILING),
FLOOR(BigDecimal.ROUND_FLOOR),
HALF_UP(BigDecimal.ROUND_HALF_UP),
HALF_DOWN(BigDecimal.ROUND_HALF_DOWN),
HALF_EVEN(BigDecimal.ROUND_HALF_EVEN),
UNNECESSARY(BigDecimal.ROUND_UNNECESSARY);

通过设置setRoundingMode()属性即可得到我们想要的舍入模式

        double num = 11.256;DecimalFormat df = new DecimalFormat("#.##");//指定RoundingModedf.setRoundingMode(RoundingMode.DOWN);String str = df.format(num);double formatNum = Double.parseDouble(str);System.out.println(formatNum);

而且他还可以设置默认输出的值
至于这个效果我总结不出来，反正就是可以给整数位及小数位拼接一些默认值。有知道具体规律的朋友欢迎留言告知。

       System.out.println( new DecimalFormat("056.00").format(12.2134));//12.2156System.out.println( new DecimalFormat("1663056.0056").format(12.2134));//166312.215656System.out.println( new DecimalFormat("16063056.0049").format(12.2134));//1612.21635649System.out.println( new DecimalFormat("106063056.0049").format(12.2134));//1012.216635649System.out.println( new DecimalFormat("1106063056.0049").format(12.2134));//11012.216635649System.out.println( new DecimalFormat("1106063056.0049").format(12.2134));//11012.216635649System.out.println( new DecimalFormat("116063056.0049").format(12.2134));//11612.21635649System.out.println( new DecimalFormat("1010606030506.0049").format(12.2134));//1000012.2116635649System.out.println( new DecimalFormat("11061068039057062.0049").format(12.2134));//1100012.21616839576249

看完上面这些代码，已经有了对0跟#的基本认知，那如何具体应用，及搭配呢？
看实践应用在搭配我上面具体案例应该很好理解
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

再补充几个知识点

关于这块的科学计数法
在这里插入图片描述

        long c = 299792458;// 光速// 显示为科学计数法，并取二、三、五、六、位小数//我给剖析一个，其他都是这么回事 299792458=2.99792458*10^8//.后面几个#就是保留几位，负数，及负次方都一样System.out.println(new DecimalFormat("#.##E0").format(c)); // 3E8System.out.println(new DecimalFormat("#.###E0").format(c)); // 2.998E8System.out.println(new DecimalFormat("#.#####E0").format(c)); // 2.99792E8System.out.println(new DecimalFormat("#.######E0").format(c)); // 2.997925E8System.out.println(new DecimalFormat("#.##E0").format(154826.855)); // 1.55E5System.out.println(new DecimalFormat("#.######E0").format(154826.855)); // 1.548269E5System.out.println(new DecimalFormat("#.########E0").format(154826.855)); // 1.54826855E5System.out.println(new DecimalFormat("#.##########E0").format(154826.855)); // 1.54826855E5System.out.println(new DecimalFormat("#.##E0").format(0.855485)); // 8.55E-1System.out.println(new DecimalFormat("#.##########E0").format(0.855485)); // 8.55485E-1System.out.println(new DecimalFormat("#.##########E0").format(0.0000855485)); //8.55485E-5

以百分比方式计数，并取指定位数小数

        System.out.println(new DecimalFormat("#.##%").format(1)); // 100%System.out.println(new DecimalFormat("#.##%").format(1.0)); // 100%System.out.println(new DecimalFormat("#.##%").format(0)); // 0%System.out.println(new DecimalFormat("#.##%").format(0.0)); // 0%System.out.println(new DecimalFormat("#.##%").format(0.0789)); // 7.89%System.out.println(new DecimalFormat("#.##%").format(0.07899)); // 7.9%System.out.println(new DecimalFormat("#.###%").format(0.07899)); // 7.899%

数值分割
如果使用具有多个分组字符的模式，则最后一个分隔符和整数结尾之间的间隔才是使用的分组大小。
所以 "#,##,###,####" "######,####" "##,####,####"本质都是,####的效果

        // 每三位以逗号进行分隔。System.out.println(new DecimalFormat(",###").format(1234567890123L)); // 1,234,567,890,123System.out.println(new DecimalFormat(",###").format(1234567890123.234567)); // 1,234,567,890,123System.out.println(new DecimalFormat(",###.##").format(1234567890123.234567)); // 1,234,567,890,123.23System.out.println(new DecimalFormat(",###.###").format(1234567890123.234567)); // 1,234,567,890,123.235// 每四位以逗号进行分隔。System.out.println(new DecimalFormat(",####.###").format(1234567890123.234567)); // 1,2345,6789,0123.235

将格式嵌入文本

        //光速大小为每秒1,234,567,890,123米。System.out.println(new DecimalFormat("光速大小为每秒,###米。").format(1234567890123.234567));//光速大小为每秒1,2345,6789,0123.235米。System.out.println(new DecimalFormat("光速大小为每秒,####.###米。").format(1234567890123.234567));//将所有数字加上负号输出,保留两位小数System.out.println(new DecimalFormat("-#.##").format(123.455)); //-123.45System.out.println(new DecimalFormat("-#.##").format(-123.456)); //--123.46System.out.println(new DecimalFormat("-#.##").format(123.466)); //-123.47System.out.println(new DecimalFormat("-#.##").format(-123.466)); //--123.47

特殊值
在这里插入图片描述

java汉字数字转成阿拉伯数字工具

在这里插入图片描述


import java.util.HashMap;
import java.util.Stack;public class ChineseToArabicNumerals {public static void main(String[] args) {//一千零一十一亿零一千零八元五分====>101100001008.05System.out.println(transChineseNum("一九八七"));//1987   这种类似年份的数字System.out.println(transChineseNum("一万一"));// 10001System.out.println(transChineseNum("一万一千"));//11000System.out.println(transChineseNum("一千零一十一亿零一千零八"));//101100001008}private static final HashMap<Character, Long> numMap = new HashMap<>();static {numMap.put('零', 0L);numMap.put('一', 1L);numMap.put('二', 2L);numMap.put('三', 3L);numMap.put('四', 4L);numMap.put('五', 5L);numMap.put('六', 6L);numMap.put('七', 7L);numMap.put('八', 8L);numMap.put('九', 9L);numMap.put('十', 10L);numMap.put('廿', 20L);numMap.put('卅', 30L);numMap.put('百', 100L);numMap.put('千', 1000L);numMap.put('万', 10_000L);numMap.put('亿', 100_000_000L);}public ChineseToArabicNumerals() {}/*** @descibe 汉字数字转成阿拉伯数字 todo 只认识汉字 零到十 单位十到亿 即 numMap 里面的汉字* 针对年份，及简单金额(人民币简体) 转成对应数字 不支持到小数(不认识点、元， 只认识汉字 零到十)* java汉字数字转成阿拉伯数字工具* "一九八七"=====>1987   这种类似年份的数字* 一千零一十一亿零一千零八====>101100001008*/public static long transChineseNum(String num) {if (num == null || num.length() == 0)return 0L;// 特殊情况 ：例如 二零一二 一九八七 这种类似年份的数字long result = 0;if ((result = transChineseNumYears(num)) != -1) {return result;}result = 0;Stack<Long> s = new Stack<>();for (int i = 0; i < num.length(); i++) {long curNum = numMap.get(num.charAt(i));if (s.isEmpty() || curNum < s.peek()) {s.push(curNum);} else {int temp = 0;while (!s.isEmpty() && s.peek() < curNum) {temp += s.pop();}temp = (temp == 0 ? 1 : temp);s.push(temp * curNum);}}while (!s.isEmpty()) {result += s.pop();}return result;}private static long transChineseNumYears(String num) {for (char c : num.toCharArray()) {if (numMap.get(c) >= 10L) {return -1;}}long result = 0;long unit = 1;for (int i = num.length() - 1; i >= 0; i--) {result += numMap.get(num.charAt(i)) * unit;unit *= 10;}return result;}
}

Java中BigDecimal常用方法

包括常规类型互转、加减乘除、取模、取商、等等

阿拉伯数字罗马数字互转

在这里插入图片描述
在这里插入图片描述

关于这块方法请参看

JAVA中的随机数

实现生成指定范围指定数据类型的随机数，及随机数的常用用法，注意点
请参考我这篇文章

Java判断奇数偶数质数合数最大公约数、最小公倍数

在这里插入图片描述

“整数中,能被2整除的数是偶数,不能被2整除的数是奇数
0是一个特殊的偶数。它既是正偶数与负偶数的分界线，又是正奇数与负奇数的分水岭。
在这里插入图片描述

   public static String BigIntegerIsProbablePrime(int number) {//判断是奇数还是偶数String s = "";if (number % 2 == 0) {s = "偶数";} else {s = "奇数";}return s;}

质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数，这样的数称为质数。
在这里插入图片描述

  public static String probableP(int num) {boolean isPrime = true;String string = "";if (num<=1){return "输入有误";}if (num > 1) {int k = (int) Math.sqrt(num);//k为num的正平方根，取整数for (int i = 2; i <= k; i++) {if (num % i == 0) {isPrime = false;//不是素数break;}}}if (isPrime) {string = "素数";} else {string = "合数";}return string;}//下面这个没太看懂public static String zhishu(int n) {//判断是质数还是合数String s = "非素合数";int i = 2;for(;i<n;i++){if (n % i == 0) {s ="合数";break;} else {}}if(n==i){s ="质数";}return s;}

java 求最大公约数的几种方式

    /*** 最大公约数，* @return*/public static BigInteger bigIntegerGcd(BigInteger bigInteger1, BigInteger bigInteger2) {return bigInteger1.gcd(bigInteger2);}//欧几里得算法求最大公约数public static int gcd1(int num1, int num2) {int temp = num1 % num2;while (temp != 0) {num1 = num2;num2 = temp;temp = num1 % num2;}return num2;}//使用递归的方式public static int gcd4(int a, int b) {if (a % b == 0)return b;return gcd4(b, a % b);}

java 求最小公倍数详解

//求最小公倍数，最简单粗暴的一种方式就是一个个试public static int lcm(int x, int y) {for (int i = 1; i < x * y; i++) {if (i % x == 0 && i % y == 0)return i;}return x * y;}
//前面我们讲过求最大公约数，求出最大公约数之后，那么最小公倍数就容易多了,直接一行代码搞定public static int lcm2(int x, int y) {return x * y / gcd1(x, y);}
//如果x，和y比较大的话，还有可能导致溢出，我们可以换种写法public static int lcm3(int x, int y) {int gcd = gcd1(x, y);return (x / gcd) * (y / gcd) * gcd;}

Math中的数字处理方法

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
这块只需要关心小数位数跟正负数的情况，结论不难得出
在这里插入图片描述
在这里插入图片描述
演示几个有意思的

		//返回第一个参数的量值和第二个参数的符号  0跟负0都是正号System.out.println(Math.copySign(1.23, -12.3));        //-1.23System.out.println(Math.copySign(-12.3, 1.23));        //12.3System.out.println(Math.copySign(-12.3, -1));        //-12.3//Math.signum(x); 如果x大于0则返回1.0，小于0则返回-1.0，等于0则返回0System.out.println(Math.signum(12.3));                //1.0System.out.println(Math.signum(-12.3));                //-1.0System.out.println(Math.signum(0));                    //0.0System.out.println(Math.signum(0.0));                //0.0//指数// Math.exp(x);//e的x次幂System.out.println(Math.exp(2));//7.38905609893065System.out.println(Math.exp(1));//2.718281828459045System.out.println(Math.exp(0));//1.0// Math.expm1(x);//e的x次幂 - 1System.out.println(Math.expm1(2));//6.38905609893065System.out.println(Math.expm1(1));//1.718281828459045System.out.println(Math.expm1(0));//0.0// Math.scalb(x, y);//x*(2的y次幂）Math.scalb(12.3, 3);			//12.3*2³System.out.println(Math.scalb(2,3));//16.0System.out.println(Math.scalb(2,0));//2.0System.out.println(Math.scalb(2,1));//4.0//x和y平方和的二次方根 Math.hypot(x, y); √（x²+y²）System.out.println(Math.hypot(0, 3));//3.0System.out.println(Math.hypot(2, 3));//√13=3.605551275463989
//        //返回概述的二次方根  Math.sqrt(x);	 √(x) x的二次方根System.out.println(Math.sqrt(9));//3.0System.out.println(Math.sqrt(13));//3.605551275463989//返回该数的立方根System.out.println(Math.cbrt(27.0)); //3System.out.println(Math.cbrt(-125.0));   //-5System.out.println(Math.cbrt(-126.0));   //-5.0132979349645845//对数函数  Math.log(e)//1 以e为底的对数System.out.println(Math.log10(100));//2.0   10 以10为底的对数
//        Math.log1p(x);	//Ln（x+ 1）//        //返回较大值和较小值
//        Math.max(x, y);返回x、y中较大的那个数
//         Math.min(x, y);//返回x、y中较小的那个数System.out.println(Math.max(100, 105.5));//105.5System.out.println(Math.min(100, 105.5));//100.0System.out.println(Math.min(100, 105));//100  都为int 返回int
//        //返回 x的y次幂 Math.pow(x, y);System.out.println(Math.pow(2, 3));//8.0	//即2³ 即返回：8 double类型//        //随机返回[0,1)之间的无符号double值   Math.random();System.out.println(Math.random());//0.8207788445593349
//        //返回最接近这个数的整数,如果刚好居中，则取偶数System.out.println(Math.rint(12.3));				//12.0System.out.println(Math.rint(-12.3));				//-12.0System.out.println(Math.rint(78.9));				//79.0System.out.println(Math.rint(-78.9));				//-79.0//遇5 前偶舍去，奇进1 如果5后还有大于0的数直接进1System.out.println(Math.rint(34.5));				//34.0System.out.println(Math.rint(34.51));				//35.0System.out.println(Math.rint(35.5));				//36.0
//由于时间关系下面我没亲测//        //三角函数
//        System.out.println( Math.sin(α);					//sin（α）的值
//        System.out.println( Math.cos(α);					//cos（α）的值
//        Math.tan(α);					//tan（α）的值
//
//        //求角
//        Math.asin(x/z);					//返回角度值[-π/2，π/2]  arc sin（x/z）
//        Math.acos(y/z);					//返回角度值[0~π]   arc cos（y/z）
//        Math.atan(y/x);					//返回角度值[-π/2，π/2]
//        Math.atan2(y-y0, x-x0); 		//同上，返回经过点（x，y）与原点的的直线和经过点（x0，y0）与原点的直线之间所成的夹角
//
//        Math.sinh(x);					//双曲正弦函数sinh(x)=(exp(x) - exp(-x)) / 2.0;
//        Math.cosh(x);					//双曲余弦函数cosh(x)=(exp(x) + exp(-x)) / 2.0;
//        Math.tanh(x);					//tanh(x) = sinh(x) / cosh(x);//角度弧度互换(可能搞反了)
//        Math.toDegrees(angrad);			//角度转换成弧度，返回：angrad * 180d / PI
//        Math.toRadians(angdeg);			//弧度转换成角度，返回：angdeg / 180d * PI

文件大小转换

转换关系须知：
在这里插入图片描述
在这里插入图片描述

获取指定文件的字节大小

    /*** 获取文件的大小(Byte) 下面这个是直接获取Byte(字节大小)* @param file 文件* @return 文件的大小 若文件不存在或者不是文件就返回null*/public static Long getByteSize(File file) {if (file.exists() && file.isFile()) {return file.length();}return null;}

根据文件字节大小单位转换

  /*** 文件大小单位转换* @param size* @return*/public static String getRemain(double size) {if (size == 0){return "0 Bytes";};String[] sizeNames = {" B", " KB", " MB", " GB", " TB", " PB", " EB", " ZB", " YB"};int i = (int) Math.floor(Math.log(size) / Math.log(1024));return new Double(divide1(size, Math.pow(1024, Math.floor(i)), 2)).toString() + sizeNames[i];}/*** 提供（相对）精确的除法运算. 由scale参数指定精度，以后的数字四舍五入.* @param v1    被除数* @param v2      除数* @param scale   表示表示需要精确到小数点以后几位*/public static double divide1(double v1, double v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b1 = new BigDecimal(v1);BigDecimal b2 = new BigDecimal(v2);return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();}//方法二：public static String formetFileSize(Long fileLength) {String fileSizeString = "";if (fileLength == null) {return fileSizeString;}DecimalFormat df = new DecimalFormat("#.00");if (fileLength < 1024) {fileSizeString = df.format((double) fileLength) + "B";} else if (fileLength < 1048576) {fileSizeString = df.format((double) fileLength/ 1024) + "K";} else if (fileLength < 1073741824) {fileSizeString = df.format((double) fileLength / 1048576) + "M";} else {fileSizeString = df.format((double) fileLength / 1073741824) + "G";}return fileSizeString;}//方法三/*** java上传文件大小转换（字节转kb/mb/gb）* 字节转 KB/MB/GB 保留两位小数四舍五入* @param size 字节长度* @return*/public static String getFileSizeString(Long size) {double length = Double.valueOf(String.valueOf(size));//如果字节数少于1024，则直接以B为单位，否则先除于1024，后3位因太少无意义if (length < 1024) {return length + "B";} else {length = length / 1024.0;}//如果原字节数除于1024之后，少于1024，则可以直接以KB作为单位//因为还没有到达要使用另一个单位的时候//接下去以此类推if (length < 1024) {return Math.round(length * 100) / 100.0 + "KB";} else {length = length / 1024.0;}if (length < 1024) {//因为如果以MB为单位的话，要保留最后1位小数，//因此，把此数乘以100之后再取余return Math.round(length * 100) / 100.0 + "MB";} else {//否则如果要以GB为单位的，先除于1024再作同样的处理return Math.round(length / 1024 * 100) / 100.0 + "GB";}}// 方法4/*** 获取文件的大小(Byte) 下面这个是直接获取Byte(字节大小)* @param file 文件* @return 文件的大小 若文件不存在或者不是文件就返回null*/public static Long getByteSize(File file) {if (file.exists() && file.isFile()) {return file.length();}return null;}/*** 获取文件的大小(返回到达的最高单位)* 比如：1024Byte就不再用Byte 直接返回1KB* 返回值精确到小数点后3位* @param file 文件* @return 文件的大小 若文件不存在或者不是文件就返回null*/public static String getSize(File file) {long size = getByteSize(file);double s = (double) size;String unit;if (size != -1L) {int l;if (size < 1024L) {l = 0;} else if (size < 1024L * 1024L) {l = 1;s = (double) size / 1024L;} else {for (l = 2; size >= 1024L * 1024L; l++) {size = size / 1024L;if ((size / 1024L) < 1024L) {s = (double) size / 1024L;break;}}}switch (l) {case 0:unit = "Byte";break;case 1:unit = "KB";break;case 2:unit = "MB";break;case 3:unit = "GB";break;case 4:
//不可能也不该达到的值unit = "TB";break;default:
//ER代表错误unit = "ER";}String format = String.format("%.3f", s);return format + unit;}return null;}//方法五public static String readableFileSize(long size) {if (size <= 0){return "0";}final String[] units = new String[]{"B", "kB", "MB", "GB", "TB"};int digitGroups = (int) (Math.log10(size) / Math.log10(1024));return new DecimalFormat("#,##0.##").format(size / Math.pow(1024, digitGroups))+ " " + units[digitGroups];}

回文数

判单一个数是不是回文数

打印某个范围内的回文数

算法题网址

https://baijiahao.baidu.com/s?id=1699646151958934746&wfr=spider&for=pc

BigDecimal计算不及Double等快

我们知道对精度有要求我们才会采用BigDecimal，但是如果我不超过精度范围的话就没必要用
针对这种情况总结方法如下：

判断当前年是否为闰年

/*** 判断当前年是否为闰年* @param year* @return*/public static boolean leapYear(int year) {if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {return true;}return false;}

Published by

风君子

独自遨游何稽首 揭天掀地慰生平