数据存储单位格式转换

1、写出存储单位的枚举类

public enum memoryUnitEnum {
    B("B","1",0),
    KB("KB","1024",1),
    MB("MB","1048576",2),
    GB("GB","1073741824",3),
    TB("TB","1099511627776",4),
    PB("PB","1125899906842624",5),
    EB("EB","1152921504606846976",6),
    ZB("ZB","1180591620717411303424",7),
    YB("YB","1208925819614629174706176",8),
    UNIT_TOO_LARGE("Trust me, you can't use such a big unit.","1237940039285380274899124224",9);

    /**
     * 存储单位
     */
    private String unit;

    /**
     * 当前单位与B的换算值
     */
    private String num;

    /**
     * 该单位位置
     */
    private Integer index;

    /**
     * 根据单位的位置获取对应的换算值
     * @param size 该单位位置
     * @return 单位换算值
     */
    public static String getNumByIndex(Integer size){
        memoryUnitEnum[] memoryUnitEnums = values();
        for (memoryUnitEnum enums: memoryUnitEnums) {
            if(enums.getIndex().equals(size)){
                return enums.getNum();
            }
        }
        return null;
    }

    /**
     * 根据单位的位置获取对应单位
     * @param size 该单位位置
     * @return 单位
     */
    public static String getUnitByIndex(Integer size){
        memoryUnitEnum[] memoryUnitEnums = values();
        for (memoryUnitEnum enums: memoryUnitEnums) {
            if(enums.getIndex().equals(size)){
                return enums.getUnit();
            }
        }
        return null;
    }

    memoryUnitEnum(String unit, String num, Integer index) {
        this.unit = unit;
        this.num = num;
        this.index = index;
    }

    public Integer getIndex() {
        return index;
    }

    public void setIndex(Integer index) {
        this.index = index;
    }

    memoryUnitEnum(){}

    public String getUnit() {
        return unit;
    }

    public void setUnit(String unit) {
        this.unit = unit;
    }

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }
}

2、写出转换存储单位的工具类

public class UnitConversionUtils {
    //默认除法运算精度
    private static final int DEF_DIV_SCALE = 2;

    /**
     * 根据输入要转换的存储数值 获取对应要转换的单位存储数值
     * @param dividend 被除数
     * @return 执行结果
     */
    public static String unitConversion(String dividend){
        //获取单位和除数
        String[] UnitAndDivisor = getUnitAndDivisor(dividend);
        return unitConversion(dividend,UnitAndDivisor[1],UnitAndDivisor[0]);
    }

    /**
     * 获取对应要转换的单位存储数值
     * @param dividend 被除数
     * @param divisor 除数
     * @param unit 单位
     * @return 执行结果
     */
    public static String unitConversion(String dividend,String divisor,String unit){
        //执行
        return div(dividend,divisor)+unit;
    }

    /**
     * 根据被除数获取单位和除数
     * @param dividend 被除数
     * @return 单位和除数
     */
    public static String[] getUnitAndDivisor(String dividend){
        //将被除数转换成double类型
        double parseDouble = Double.parseDouble(dividend);
        //对被除数和1024(2的10次方)的模进行运算 获取index下标
        double index = Math.floor(Math.log(parseDouble))/Math.log(1024);
        //对index向下取整转换成int类型 并通过调用枚举类的方法 获取单位、除数
        String unit = memoryUnitEnum.getUnitByIndex((int)index);
        String divisor = memoryUnitEnum.getNumByIndex((int)index);
        return new String[]{unit, divisor};
    }

    /**
     *
     * @param dividend 被除数
     * @param divisor 除数
     * @return 商
     */
    public static String div(String dividend, String divisor) {
        return div(dividend, divisor, DEF_DIV_SCALE);
    }

    /**
     *
     * @param dividend 被除数
     * @param divisor 除数
     * @param scale 默认除法运算精度
     * @return 商
     */
    public static String div(String dividend, String divisor, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal decDividend = new BigDecimal(dividend);
        BigDecimal decDivisor = new BigDecimal(divisor);
        return decDividend.divide(decDivisor, scale, RoundingMode.HALF_UP).toString();
    }
}

3、测试运行

public class UnitConversionTest {

    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        ArrayList<userVO> user1 = new ArrayList<>();
        ArrayList<userVO> user2 = new ArrayList<>();
        //测试：装入Map
        for (int i = 0; i < 10; i++) {
            hashMap.put(i, memoryUnitEnum.getNumByIndex(i));
        }

        //1、根据存储大小 转换成对应的单位（根据数值大小进行不同单位的转换）
        //循环获取Map中数据 并根据存储大小 转换成对应的单位
        for (int i = 9; i > -1; i--) {
            userVO user = new userVO();
            //格式转换
            String noUnit = UnitConversionUtils.unitConversion(hashMap.get(i));
            user.setNum(noUnit);
            user.setId(String.valueOf(i));
            user1.add(user);
        }
        //2、根据最大存储单元的大小 转换成对应的单位（后续单位统一为当前最大存储单元的单位并进行最大单位的换算值进行转换）
        String[] unitAndDivisor = UnitConversionUtils.getUnitAndDivisor(memoryUnitEnum.MB.getNum());
        System.out.println("统一的转换单位和换算数值为:=="+ Arrays.toString(unitAndDivisor));
        for (int i = 9; i > -1 ; i--) {
            userVO user = new userVO();
            //格式转换 单位统一为：unitAndDivisor[0]
           String Unit = UnitConversionUtils.unitConversion(hashMap.get(i), unitAndDivisor[1], unitAndDivisor[0]);
            user.setNum(Unit);
            user.setId(String.valueOf(i));
            user2.add(user);
        }

        HashMap<String, ArrayList<userVO>> map = new HashMap<>();
        map.put("directConvert",user1);
        map.put("togetherConvert",user2);
        String jsonString = JSONObject.toJSONString(map);
        System.out.println(jsonString);
    }
}

4、测试结果

map对象输出json：

 {
  "directConvert": [
    {
      "id": "9",
      "num": "1024.00YB"
    },
    {
      "id": "8",
      "num": "1024.00ZB"
    },
    {
      "id": "7",
      "num": "1024.00EB"
    },
    {
      "id": "6",
      "num": "1024.00PB"
    },
    {
      "id": "5",
      "num": "1024.00TB"
    },
    {
      "id": "4",
      "num": "1024.00GB"
    },
    {
      "id": "3",
      "num": "1024.00MB"
    },
    {
      "id": "2",
      "num": "1024.00KB"
    },
    {
      "id": "1",
      "num": "1024.00B"
    },
    {
      "id": "0",
      "num": "1.00B"
    }
  ],
  "togetherConvert": [
    {
      "id": "9",
      "num": "1208925819614629174706176.00KB"
    },
    {
      "id": "8",
      "num": "1180591620717411303424.00KB"
    },
    {
      "id": "7",
      "num": "1152921504606846976.00KB"
    },
    {
      "id": "6",
      "num": "1125899906842624.00KB"
    },
    {
      "id": "5",
      "num": "1099511627776.00KB"
    },
    {
      "id": "4",
      "num": "1073741824.00KB"
    },
    {
      "id": "3",
      "num": "1048576.00KB"
    },
    {
      "id": "2",
      "num": "1024.00KB"
    },
    {
      "id": "1",
      "num": "1.00KB"
    },
    {
      "id": "0",
      "num": "0.00KB"
    }
  ]
}