• 存储单位转换工具类

    网上找了好久没找到合适的存储单位转换工具类,自己手写了一个转换工具类(大佬勿喷),分享出来,main是使用案例,可做参考!

    1. package com.glory.myselfdemo.utils;
    2.  
    3. import java.math.BigDecimal;
    4. import java.math.RoundingMode;
    5. import java.util.HashMap;
    6. import java.util.Map;
    7. import java.util.regex.Matcher;
    8. import java.util.regex.Pattern;
    9.  
    10. /**
    11.  * @author ***
    12.  */
    13. public class StorageUnitUtil {
    14.     /**
    15.      * bit、B、KB、MB、GB、TB、PB、EB、ZB、YB、BB、NB、DB、CB……
    16.      */
    17.     enum Unit{
    18.         // 值必须由小到大递增
    19.         bit,
    20.         B,
    21.         KB,
    22.         MB,
    23.         GB,
    24.         TB,
    25.         PB,
    26.         EB,
    27.         ZB,
    28.         YB,
    29.         BB,
    30.         NB,
    31.         DB,
    32.         CB
    33.     }
    34.  
    35.     /**
    36.      * 换算基数:例: 1024;1000...
    37.      */
    38.     private final static int basic = 1024;
    39.  
    40.     /**
    41.      * 自动转换:value>=basic,自动向大单位转换,否则返回value
    42.      * @param value 转换前的值(不能为'0'且小于Double.MAX_VALUE）
    43.      * @param currentUnit 转换前的单位
    44.      * @return 返回转后的值和单位字符
    45.      */
    46.     public static String autoConvert(Number value, Unit currentUnit) {
    47.         if (value.doubleValue() == 0 && value.doubleValue() < Double.MAX_VALUE) {
    48.             throw new IllegalArgumentException("需要转换的值不能为0且小于Double.MAX_VALUE");
    49.         }
    50.         return autoToBig(value, currentUnit, null, null);
    51.     }
    52.  
    53.     /**
    54.      * 自动转换:value>=basic,自动向大单位转换,否则返回value;可定义分隔符或单位后缀
    55.      * @param value 转换前的值(不能为'0'且小于Double.MAX_VALUE）
    56.      * @param currentUnit 转换前的单位
    57.      * @param separatorChar 值和单位中间的分隔符
    58.      * @param unitSuffix 单位后面的后缀
    59.      * @return 返回转后的值和(分隔符<若有>)单位(后缀<若有>)字符
    60.      */
    61.     public static String autoConvert(Number value, Unit currentUnit, String separatorChar, String unitSuffix) {
    62.         if (value.doubleValue() == 0 && value.doubleValue() < Double.MAX_VALUE) {
    63.             throw new IllegalArgumentException("需要转换的值不能为0且小于Double.MAX_VALUE");
    64.         }
    65.         return autoToBig(value, currentUnit, separatorChar, unitSuffix);
    66.     }
    67.  
    68.     /**
    69.      * 自动转换:valueUnit中的value>=basic,自动向大单位转换,否则返回value
    70.      * @param valueUnit 转换前的值和单位字符
    71.      * @return 返回转后的值和单位字符
    72.      */
    73.     public static String autoConvert(String valueUnit) {
    74.         Map map = extractArgument(valueUnit);
    75.         if (map.isEmpty()) {
    76.             throw new IllegalArgumentException("参数无法解析: " + valueUnit);
    77.         } else {
    78.             Number number = Double.valueOf(map.get("number"));
    79.             if (number.doubleValue() == 0 && number.doubleValue() < Double.MAX_VALUE) {
    80.                 throw new IllegalArgumentException("需要转换的值不能为0");
    81.             }
    82.             Unit fromUnit = Unit.valueOf(map.get("unit"));
    83.             return autoToBig(number, fromUnit, null, null);
    84.         }
    85.     }
    86.  
    87.     /**
    88.      * 自动转换:valueUnit中的value>=basic,自动向大单位转换,否则返回value;可定义分隔符或单位后缀
    89.      * @param valueUnit 转换前的值和单位字符
    90.      * @param separatorChar 值和单位中间的分隔符
    91.      * @param unitSuffix 单位后面的后缀
    92.      * @return 返回转后的值和(分隔符<若有>)单位(后缀<若有>)字符
    93.      */
    94.     public static String autoConvert(String valueUnit, String separatorChar, String unitSuffix) {
    95.         Map map = extractArgument(valueUnit);
    96.         if (map.isEmpty()) {
    97.             throw new IllegalArgumentException("参数无法解析: " + valueUnit);
    98.         } else {
    99.             Number number = Double.valueOf(map.get("number"));
    100.             if (number.doubleValue() == 0 && number.doubleValue() < Double.MAX_VALUE) {
    101.                 throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
    102.             }
    103.             Unit fromUnit = Unit.valueOf(map.get("unit"));
    104.             return autoToBig(number, fromUnit, separatorChar, unitSuffix);
    105.         }
    106.     }
    107.  
    108.     /**
    109.      * 指定转换:指定转换后的单位,valueUnit中的value向指定单位换算成对应的值
    110.      * @param valueUnit 转换前的值和单位字符
    111.      * @param toUnit 转换后的单位
    112.      * @return 返回转后的值和单位字符
    113.      */
    114.     public static String customConvert(String valueUnit, Unit toUnit) {
    115.         Map map = extractArgument(valueUnit);
    116.         String result;
    117.         if (map.isEmpty()) {
    118.             throw new IllegalArgumentException("参数无法解析: " + valueUnit);
    119.         } else {
    120.             Number number = Double.valueOf(map.get("number"));
    121.             if (number.doubleValue() == 0 && number.doubleValue() < Double.MAX_VALUE) {
    122.                 throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
    123.             }
    124.             Unit fromUnit = Unit.valueOf(map.get("unit"));
    125.             int fromOrdinal = fromUnit.ordinal();
    126.             int toOrdinal = toUnit.ordinal();
    127.             if (fromOrdinal == toOrdinal) {
    128.                 throw new IllegalArgumentException("当前单位和转换结果的目标单位不能相同");
    129.             }
    130.             // big to small
    131.             if (fromOrdinal > toOrdinal) {
    132.                 result = customToSmall(number, fromUnit, toUnit, null, null);
    133.             } else {
    134.                 result = autoToBig(number, fromUnit, null, null);
    135.             }
    136.         }
    137.         return result;
    138.     }
    139.  
    140.     /**
    141.      * 指定转换:指定转换后的单位,valueUnit中的value向指定单位换算成对应的值;可定义分隔符或单位后缀
    142.      * @param valueUnit 转换前的值和单位字符
    143.      * @param toUnit    转换后的单位
    144.      * @param separatorChar 值和单位中间的分隔符
    145.      * @param unitSuffix 单位后面的后缀
    146.      * @return 返回转后的值和(分隔符<若有>)单位(后缀<若有>)字符
    147.      */
    148.     public static String customConvert(String valueUnit, Unit toUnit, String separatorChar, String unitSuffix) {
    149.         Map map = extractArgument(valueUnit);
    150.         String result;
    151.         if (map.isEmpty()) {
    152.             throw new IllegalArgumentException("参数无法解析: " + valueUnit);
    153.         } else {
    154.             Number number = Double.valueOf(map.get("number"));
    155.             if (number.doubleValue() == 0 && number.doubleValue() < Double.MAX_VALUE) {
    156.                 throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
    157.             }
    158.             Unit fromUnit = Unit.valueOf(map.get("unit"));
    159.             int fromOrdinal = fromUnit.ordinal();
    160.             int toOrdinal = toUnit.ordinal();
    161.             if (fromOrdinal == toOrdinal) {
    162.                 throw new IllegalArgumentException("当前单位和转换结果的目标单位不能相同");
    163.             }
    164.             // big to small
    165.             if (fromOrdinal > toOrdinal) {
    166.                 result = customToSmall(number, fromUnit, toUnit, separatorChar, unitSuffix);
    167.             } else {
    168.                 result = autoToBig(number, fromUnit, separatorChar, unitSuffix);
    169.             }
    170.         }
    171.         return result;
    172.     }
    173.  
    174.     /**
    175.      * 指定转换:指定转换后的单位,value向指定单位换算成对应的值
    176.      * @param value 转换前的值
    177.      * @param currentUnit 转换前的单位
    178.      * @param toUnit 转换后的单位
    179.      * @return 返回转后的值和单位字符
    180.      */
    181.     public static String customConvert(Number value,Unit currentUnit, Unit toUnit) {
    182.         String result;
    183.         if (value.doubleValue() == 0 && value.doubleValue() < Double.MAX_VALUE) {
    184.             throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
    185.         }
    186.         int fromOrdinal = currentUnit.ordinal();
    187.         int toOrdinal = toUnit.ordinal();
    188.         if (fromOrdinal == toOrdinal) {
    189.             throw new IllegalArgumentException("当前单位和转换结果的目标单位不能相同");
    190.         }
    191.         // big to small
    192.         if (fromOrdinal > toOrdinal) {
    193.             result = customToSmall(value, currentUnit, toUnit, null, null);
    194.         } else {
    195.             result = autoToBig(value, currentUnit, null, null);
    196.         }
    197.         return result;
    198.     }
    199.  
    200.     /**
    201.      *
    202.      * 指定转换:指定转换后的单位,value向指定单位换算成对应的值;可定义分隔符或单位后缀
    203.      * @param value 转换前的值
    204.      * @param currentUnit 转换前的单位
    205.      * @param toUnit 转换后的单位
    206.      * @param separatorChar 值和单位中间的分隔符
    207.      * @param unitSuffix 单位后面的后缀
    208.      * @return 返回转换后的值和(分隔符<若有>)单位(后缀<若有>)字符
    209.      */
    210.     public static String customConvert(Number value, Unit currentUnit, Unit toUnit, String separatorChar, String unitSuffix) {
    211.         String result;
    212.         if (value.doubleValue() == 0 && value.doubleValue() < Double.MAX_VALUE) {
    213.             throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
    214.         }
    215.         int fromOrdinal = currentUnit.ordinal();
    216.         int toOrdinal = toUnit.ordinal();
    217.         if (fromOrdinal == toOrdinal) {
    218.             throw new IllegalArgumentException("当前单位和转换结果的目标单位不能相同");
    219.         }
    220.         // big to small
    221.         if (fromOrdinal > toOrdinal) {
    222.             result = customToSmall(value, currentUnit, toUnit, separatorChar, unitSuffix);
    223.         } else {
    224.             result = autoToBig(value, currentUnit, separatorChar, unitSuffix);
    225.         }
    226.         return result;
    227.     }
    228.  
    229.     /**
    230.      * 指定转换:指定转换后的单位,value向指定单位换算成对应的值并返回
    231.      * @param value 转换前的值
    232.      * @param currentUnit 转换前的单位
    233.      * @param toUnit 转换后的单位
    234.      * @return 返回转换后的值 java.lang.Number
    235.      */
    236.     public static Number getNumberConvert(Number value,Unit currentUnit, Unit toUnit) {
    237.         Number number;
    238.         if (value.doubleValue() == 0 && value.doubleValue() < Double.MAX_VALUE) {
    239.             throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
    240.         }
    241.         int fromOrdinal = currentUnit.ordinal();
    242.         int toOrdinal = toUnit.ordinal();
    243.         if (fromOrdinal == toOrdinal) {
    244.             throw new IllegalArgumentException("当前单位和转换结果的目标单位不能相同");
    245.         }
    246.         // big to small
    247.         if (fromOrdinal > toOrdinal) {
    248.             number = customToSmall(value, currentUnit, toUnit);
    249.         } else {
    250.             number = autoToBig(value, currentUnit);
    251.         }
    252.         return number;
    253.     }
    254.  
    255.     /**
    256.      * 指定转换:指定转换后的单位,valueUnit中的value向指定单位换算成对应的值并返回
    257.      * @param valueUnit 转换前的值和单位字符
    258.      * @param toUnit 转换后的单位
    259.      * @return 返回转换后的值 java.lang.Number
    260.      */
    261.     public static Number getNumberConvert(String valueUnit, Unit toUnit) {
    262.         Map map = extractArgument(valueUnit);
    263.         Number number;
    264.         if (map.isEmpty()) {
    265.             throw new IllegalArgumentException("参数无法解析: " + valueUnit);
    266.         } else {
    267.             number = Double.valueOf(map.get("number"));
    268.             if (number.doubleValue() == 0 && number.doubleValue() < Double.MAX_VALUE) {
    269.                 throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
    270.             }
    271.             Unit fromUnit = Unit.valueOf(map.get("unit"));
    272.             int fromOrdinal = fromUnit.ordinal();
    273.             int toOrdinal = toUnit.ordinal();
    274.             if (fromOrdinal == toOrdinal) {
    275.                 throw new IllegalArgumentException("当前单位和转换结果的目标单位不能相同");
    276.             }
    277.             // big to small
    278.             if (fromOrdinal > toOrdinal) {
    279.                 number = customToSmall(number, fromUnit, toUnit);
    280.             } else {
    281.                 number = autoToBig(number, fromUnit);
    282.             }
    283.         }
    284.         return number;
    285.     }
    286.  
    287.     private static Number customToSmall(Number number, Unit fromUnit, Unit toUnit){
    288.         final int enumIdx = 0;
    289.         final int special = 8;
    290.         final int resultScale = 2;
    291.         int fromOrdinal = fromUnit.ordinal();
    292.         int toOrdinal = toUnit.ordinal();
    293.         int level = fromOrdinal - toOrdinal;
    294.         BigDecimal value = BigDecimal.valueOf(number.doubleValue());
    295.         BigDecimal basicDec = BigDecimal.valueOf(basic);
    296.         BigDecimal specialDec = BigDecimal.valueOf(special);
    297.         if (toOrdinal == enumIdx) {
    298.             level -= 1;
    299.             value = value.multiply(specialDec);
    300.         }
    301.         for (int i = 1; i <= level; i++) {
    302.             value = value.multiply(basicDec);
    303.         }
    304.         value = value.setScale(resultScale, RoundingMode.HALF_UP);
    305.         return formatToLong(value);
    306.     }
    307.  
    308.     private static String customToSmall(Number number, Unit fromUnit, Unit toUnit, String separatorChar, String unitSuffix) {
    309.         final int enumIdx = 0;
    310.         final int special = 8;
    311.         final int resultScale = 2;
    312.         int fromOrdinal = fromUnit.ordinal();
    313.         int toOrdinal = toUnit.ordinal();
    314.         int level = fromOrdinal - toOrdinal;
    315.         BigDecimal value = BigDecimal.valueOf(number.doubleValue());
    316.         BigDecimal basicDec = BigDecimal.valueOf(basic);
    317.         BigDecimal specialDec = BigDecimal.valueOf(special);
    318.         if (toOrdinal == enumIdx) {
    319.             level -= 1;
    320.             value = value.multiply(specialDec);
    321.         }
    322.         for (int i = 1; i <= level; i++) {
    323.             value = value.multiply(basicDec);
    324.         }
    325.         value = value.setScale(resultScale, RoundingMode.HALF_UP);
    326.         Number resultVal = formatToLong(value);
    327.         String result = String.valueOf(resultVal);
    328.         if (separatorChar != null && !"".equals(separatorChar) && separatorChar.length() > 0) {
    329.             result = result.concat(separatorChar);
    330.         }
    331.         result = result.concat(toUnit.name());
    332.         if (unitSuffix != null && !"".equals(unitSuffix) && unitSuffix.length() > 0) {
    333.             result = result.concat(unitSuffix);
    334.         }
    335.         return result;
    336.     }
    337.  
    338.     private static Map extractArgument(String valUnit) {
    339.         Map map = new HashMap<>();
    340.         Unit[] units = Unit.values();
    341. //        String unitsStr = Arrays.stream(units).map(Enum::name).collect(Collectors.joining("|"));
    342.         StringBuilder builder = new StringBuilder();
    343.         for (Unit unit : units) {
    344.             String name = unit.name();
    345.             builder.append(name);
    346.             if (unit.ordinal() < (units.length - 1)) {
    347.                 builder.append("|");
    348.             }
    349.         }
    350.         final String regex = "^(\\d+[.]?\\d*)\\s*(" + builder + ")$";
    351.         Pattern pattern = Pattern.compile(regex);
    352.         Matcher matcher = pattern.matcher(valUnit);
    353.         while (matcher.find()) {
    354.             map.put("number", matcher.group(1));
    355.             map.put("unit", matcher.group(2));
    356.         }
    357.         return map;
    358.     }
    359.  
    360.     private static Unit getUnitByOrdinal(int ordinal) {
    361.         Unit[] units = Unit.values();
    362.         for (Unit unit : units) {
    363.             if (unit.ordinal() == ordinal) {
    364.                 return unit;
    365.             }
    366.         }
    367.         throw new IllegalArgumentException("未录入该存储单位");
    368.     }
    369.  
    370.     private static Number autoToBig(Number val, Unit fromUnit) {
    371.         final int enumIdx = 0;
    372.         int fromOrdinal = fromUnit.ordinal();
    373.         if (enumIdx == fromOrdinal) {
    374.             val = bitToByte(val);
    375.             fromOrdinal += 1;
    376.         }
    377.         // 计算时尽量保持精确度 保留10位小数s
    378.         final int scale = 10;
    379.         // 返回时保留2位小数
    380.         final int resultScale = 2;
    381.         BigDecimal smallVal = BigDecimal.valueOf(val.doubleValue());
    382.         BigDecimal basicVal = BigDecimal.valueOf(basic);
    383.         while (smallVal.compareTo(basicVal) >= 0 && (fromOrdinal < Unit.values().length - 1)) {
    384.             smallVal = smallVal.divide(basicVal, scale, RoundingMode.HALF_UP);
    385.             fromOrdinal += 1;
    386.         }
    387.         smallVal = smallVal.setScale(resultScale, RoundingMode.HALF_UP);
    388.         return formatToLong(smallVal);
    389.     }
    390.  
    391.     private static String autoToBig(Number val, Unit fromUnit, String separatorChar, String unitSuffix) {
    392.         final int enumIdx = 0;
    393.         int fromOrdinal = fromUnit.ordinal();
    394.         if (enumIdx == fromOrdinal) {
    395.             val = bitToByte(val);
    396.             fromOrdinal += 1;
    397.         }
    398.         // 计算时尽量保持精确度 保留10位小数s
    399.         final int scale = 10;
    400.         // 返回时保留2位小数
    401.         final int resultScale = 2;
    402.         BigDecimal smallVal = BigDecimal.valueOf(val.doubleValue());
    403.         BigDecimal basicVal = BigDecimal.valueOf(basic);
    404.         while (smallVal.compareTo(basicVal) >= 0 && (fromOrdinal < Unit.values().length - 1)) {
    405.             smallVal = smallVal.divide(basicVal, scale, RoundingMode.HALF_UP);
    406.             fromOrdinal += 1;
    407.         }
    408.         Unit toUnit = getUnitByOrdinal(fromOrdinal);
    409.         smallVal = smallVal.setScale(resultScale, RoundingMode.HALF_UP);
    410.         Number number = formatToLong(smallVal);
    411.         String result = String.valueOf(number);
    412.         if (separatorChar != null && !"".equals(separatorChar) && separatorChar.length() > 0) {
    413.             result = result.concat(separatorChar);
    414.         }
    415.         result = result.concat(toUnit.name());
    416.         if (unitSuffix != null && !"".equals(unitSuffix) && unitSuffix.length() > 0) {
    417.             result = result.concat(unitSuffix);
    418.         }
    419.         return result;
    420.     }
    421.  
    422.     private static Number bitToByte(Number bitSize) {
    423.         final int basic = 8;
    424.         final int scale = 10;
    425.         double bitDouble = bitSize.doubleValue();
    426.         if (bitDouble == 0) {
    427.             return bitSize;
    428.         }
    429.         BigDecimal bitDec = BigDecimal.valueOf(bitDouble);
    430.         BigDecimal basicDec = BigDecimal.valueOf(basic);
    431.         BigDecimal byteDec = bitDec.divide(basicDec, scale, RoundingMode.HALF_UP);
    432.         return formatToLong(byteDec);
    433.     }
    434.  
    435.     private static Number formatToLong(Number val) {
    436.         double d = val.doubleValue();
    437.         long l = val.longValue();
    438.         if (d == l) {
    439.             return l;
    440.         }
    441.         return val;
    442.     }
    443.  
    444.     public static void main(String[] args) {
    445.  
    446.         String s1 = autoConvert(10240, Unit.KB);
    447.         System.out.println("s1 = " + s1);
    448.  
    449.         String s2 = autoConvert(8192, Unit.KB, " ", "/s");
    450.         System.out.println("s2 = " + s2);
    451.  
    452.         String s3 = autoConvert("10240TB");
    453.         System.out.println("s3 = " + s3);
    454.  
    455.         String s4 = autoConvert("1023GB", " ", "/每天");
    456.         System.out.println("s4 = " + s4);
    457.  
    458.         String s5 = customConvert("1TB", Unit.bit);
    459.         System.out.println("s5 = " + s5);
    460.  
    461.         String s6 = customConvert(1, Unit.TB, Unit.bit);
    462.         System.out.println("s6 = " + s6);
    463.  
    464.         String s7 = customConvert("1CB", Unit.YB);
    465.         System.out.println("s7 = " + s7);
    466.  
    467.         String s8 = autoConvert(9.8938489077261e+27,Unit.bit);
    468.         System.out.println("s8 = " + s8);
    469.  
    470.         String s9 = customConvert(1024, Unit.B, Unit.bit, " ", null);
    471.         System.out.println("s9 = " + s9);
    472.  
    473.         String s10 = customConvert("1024KB", Unit.MB, " ", "/s");
    474.         System.out.println("s10 = " + s10);
    475.  
    476.         Number n1 = getNumberConvert("1024GB", Unit.MB);
    477.         System.out.println("n1 = " + n1);
    478.  
    479.         Number n2 = getNumberConvert(1024, Unit.KB, Unit.MB);
    480.         System.out.println("n2 = " + n2);
    481.     }
    482.  
    483.  
    484. }

  • 相关阅读:
    WPF中获取TreeView以及ListView获取其本身滚动条进行滚动
    【DS基础】栈与队列
    数据结构：AVL树的旋转（高度平衡树）
    【VIO】练习1 IMU标定
    【操作系统 | Linux】 文件管理四件套（切换,创建删除，复制移动）
    五.实战软件部署 4-5MYSQL 5.7版本在ubuntu(WSL环境)安装&MYSQL 8.0版本在ubuntu(WSL环境)安装
    产品化的GPT，能否为“百模大战”照亮未来？
    一、CC2530开发环境搭建
    UE5 C++报错：is not currently enabled for Live Coding
    Servlet
  • 原文地址：https://blog.csdn.net/Java_Glory/article/details/125897332