存储单位转换工具类

已于 2022-07-21 15:52:03 修改
阅读量598 收藏
点赞数
分类专栏： 分享 文章标签： java util 工具类 自动转换 存储单位
于 2022-07-20 17:47:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java_glory/article/details/125897332
版权

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

package com.glory.myselfdemo.utils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author ***
 */
public class StorageUnitUtil {
    /**
     * bit、B、KB、MB、GB、TB、PB、EB、ZB、YB、BB、NB、DB、CB……
     */
    enum Unit{
        // 值必须由小到大递增
        bit,
        B,
        KB,
        MB,
        GB,
        TB,
        PB,
        EB,
        ZB,
        YB,
        BB,
        NB,
        DB,
        CB
    }

    /**
     * 换算基数:例: 1024;1000...
     */
    private final static int basic = 1024;

    /**
     * 自动转换:value>=basic,自动向大单位转换,否则返回value
     * @param value 转换前的值(不能为'0'且小于Double.MAX_VALUE）
     * @param currentUnit 转换前的单位
     * @return 返回转后的值和单位字符
     */
    public static String autoConvert(Number value, Unit currentUnit) {
        if (value.doubleValue() == 0 && value.doubleValue() < Double.MAX_VALUE) {
            throw new IllegalArgumentException("需要转换的值不能为0且小于Double.MAX_VALUE");
        }
        return autoToBig(value, currentUnit, null, null);
    }

    /**
     * 自动转换:value>=basic,自动向大单位转换,否则返回value;可定义分隔符或单位后缀
     * @param value 转换前的值(不能为'0'且小于Double.MAX_VALUE）
     * @param currentUnit 转换前的单位
     * @param separatorChar 值和单位中间的分隔符
     * @param unitSuffix 单位后面的后缀
     * @return 返回转后的值和(分隔符<若有>)单位(后缀<若有>)字符
     */
    public static String autoConvert(Number value, Unit currentUnit, String separatorChar, String unitSuffix) {
        if (value.doubleValue() == 0 && value.doubleValue() < Double.MAX_VALUE) {
            throw new IllegalArgumentException("需要转换的值不能为0且小于Double.MAX_VALUE");
        }
        return autoToBig(value, currentUnit, separatorChar, unitSuffix);
    }

    /**
     * 自动转换:valueUnit中的value>=basic,自动向大单位转换,否则返回value
     * @param valueUnit 转换前的值和单位字符
     * @return 返回转后的值和单位字符
     */
    public static String autoConvert(String valueUnit) {
        Map<String, String> map = extractArgument(valueUnit);
        if (map.isEmpty()) {
            throw new IllegalArgumentException("参数无法解析: " + valueUnit);
        } else {
            Number number = Double.valueOf(map.get("number"));
            if (number.doubleValue() == 0 && number.doubleValue() < Double.MAX_VALUE) {
                throw new IllegalArgumentException("需要转换的值不能为0");
            }
            Unit fromUnit = Unit.valueOf(map.get("unit"));
            return autoToBig(number, fromUnit, null, null);
        }
    }

    /**
     * 自动转换:valueUnit中的value>=basic,自动向大单位转换,否则返回value;可定义分隔符或单位后缀
     * @param valueUnit 转换前的值和单位字符
     * @param separatorChar 值和单位中间的分隔符
     * @param unitSuffix 单位后面的后缀
     * @return 返回转后的值和(分隔符<若有>)单位(后缀<若有>)字符
     */
    public static String autoConvert(String valueUnit, String separatorChar, String unitSuffix) {
        Map<String, String> map = extractArgument(valueUnit);
        if (map.isEmpty()) {
            throw new IllegalArgumentException("参数无法解析: " + valueUnit);
        } else {
            Number number = Double.valueOf(map.get("number"));
            if (number.doubleValue() == 0 && number.doubleValue() < Double.MAX_VALUE) {
                throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
            }
            Unit fromUnit = Unit.valueOf(map.get("unit"));
            return autoToBig(number, fromUnit, separatorChar, unitSuffix);
        }
    }

    /**
     * 指定转换:指定转换后的单位,valueUnit中的value向指定单位换算成对应的值
     * @param valueUnit 转换前的值和单位字符
     * @param toUnit 转换后的单位
     * @return 返回转后的值和单位字符
     */
    public static String customConvert(String valueUnit, Unit toUnit) {
        Map<String, String> map = extractArgument(valueUnit);
        String result;
        if (map.isEmpty()) {
            throw new IllegalArgumentException("参数无法解析: " + valueUnit);
        } else {
            Number number = Double.valueOf(map.get("number"));
            if (number.doubleValue() == 0 && number.doubleValue() < Double.MAX_VALUE) {
                throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
            }
            Unit fromUnit = Unit.valueOf(map.get("unit"));
            int fromOrdinal = fromUnit.ordinal();
            int toOrdinal = toUnit.ordinal();
            if (fromOrdinal == toOrdinal) {
                throw new IllegalArgumentException("当前单位和转换结果的目标单位不能相同");
            }
            // big to small
            if (fromOrdinal > toOrdinal) {
                result = customToSmall(number, fromUnit, toUnit, null, null);
            } else {
                result = autoToBig(number, fromUnit, null, null);
            }
        }
        return result;
    }

    /**
     * 指定转换:指定转换后的单位,valueUnit中的value向指定单位换算成对应的值;可定义分隔符或单位后缀
     * @param valueUnit 转换前的值和单位字符
     * @param toUnit    转换后的单位
     * @param separatorChar 值和单位中间的分隔符
     * @param unitSuffix 单位后面的后缀
     * @return 返回转后的值和(分隔符<若有>)单位(后缀<若有>)字符
     */
    public static String customConvert(String valueUnit, Unit toUnit, String separatorChar, String unitSuffix) {
        Map<String, String> map = extractArgument(valueUnit);
        String result;
        if (map.isEmpty()) {
            throw new IllegalArgumentException("参数无法解析: " + valueUnit);
        } else {
            Number number = Double.valueOf(map.get("number"));
            if (number.doubleValue() == 0 && number.doubleValue() < Double.MAX_VALUE) {
                throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
            }
            Unit fromUnit = Unit.valueOf(map.get("unit"));
            int fromOrdinal = fromUnit.ordinal();
            int toOrdinal = toUnit.ordinal();
            if (fromOrdinal == toOrdinal) {
                throw new IllegalArgumentException("当前单位和转换结果的目标单位不能相同");
            }
            // big to small
            if (fromOrdinal > toOrdinal) {
                result = customToSmall(number, fromUnit, toUnit, separatorChar, unitSuffix);
            } else {
                result = autoToBig(number, fromUnit, separatorChar, unitSuffix);
            }
        }
        return result;
    }

    /**
     * 指定转换:指定转换后的单位,value向指定单位换算成对应的值
     * @param value 转换前的值
     * @param currentUnit 转换前的单位
     * @param toUnit 转换后的单位
     * @return 返回转后的值和单位字符
     */
    public static String customConvert(Number value,Unit currentUnit, Unit toUnit) {
        String result;
        if (value.doubleValue() == 0 && value.doubleValue() < Double.MAX_VALUE) {
            throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
        }
        int fromOrdinal = currentUnit.ordinal();
        int toOrdinal = toUnit.ordinal();
        if (fromOrdinal == toOrdinal) {
            throw new IllegalArgumentException("当前单位和转换结果的目标单位不能相同");
        }
        // big to small
        if (fromOrdinal > toOrdinal) {
            result = customToSmall(value, currentUnit, toUnit, null, null);
        } else {
            result = autoToBig(value, currentUnit, null, null);
        }
        return result;
    }

    /**
     *
     * 指定转换:指定转换后的单位,value向指定单位换算成对应的值;可定义分隔符或单位后缀
     * @param value 转换前的值
     * @param currentUnit 转换前的单位
     * @param toUnit 转换后的单位
     * @param separatorChar 值和单位中间的分隔符
     * @param unitSuffix 单位后面的后缀
     * @return 返回转换后的值和(分隔符<若有>)单位(后缀<若有>)字符
     */
    public static String customConvert(Number value, Unit currentUnit, Unit toUnit, String separatorChar, String unitSuffix) {
        String result;
        if (value.doubleValue() == 0 && value.doubleValue() < Double.MAX_VALUE) {
            throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
        }
        int fromOrdinal = currentUnit.ordinal();
        int toOrdinal = toUnit.ordinal();
        if (fromOrdinal == toOrdinal) {
            throw new IllegalArgumentException("当前单位和转换结果的目标单位不能相同");
        }
        // big to small
        if (fromOrdinal > toOrdinal) {
            result = customToSmall(value, currentUnit, toUnit, separatorChar, unitSuffix);
        } else {
            result = autoToBig(value, currentUnit, separatorChar, unitSuffix);
        }
        return result;
    }

    /**
     * 指定转换:指定转换后的单位,value向指定单位换算成对应的值并返回
     * @param value 转换前的值
     * @param currentUnit 转换前的单位
     * @param toUnit 转换后的单位
     * @return 返回转换后的值 java.lang.Number
     */
    public static Number getNumberConvert(Number value,Unit currentUnit, Unit toUnit) {
        Number number;
        if (value.doubleValue() == 0 && value.doubleValue() < Double.MAX_VALUE) {
            throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
        }
        int fromOrdinal = currentUnit.ordinal();
        int toOrdinal = toUnit.ordinal();
        if (fromOrdinal == toOrdinal) {
            throw new IllegalArgumentException("当前单位和转换结果的目标单位不能相同");
        }
        // big to small
        if (fromOrdinal > toOrdinal) {
            number = customToSmall(value, currentUnit, toUnit);
        } else {
            number = autoToBig(value, currentUnit);
        }
        return number;
    }

    /**
     * 指定转换:指定转换后的单位,valueUnit中的value向指定单位换算成对应的值并返回
     * @param valueUnit 转换前的值和单位字符
     * @param toUnit 转换后的单位
     * @return 返回转换后的值 java.lang.Number
     */
    public static Number getNumberConvert(String valueUnit, Unit toUnit) {
        Map<String, String> map = extractArgument(valueUnit);
        Number number;
        if (map.isEmpty()) {
            throw new IllegalArgumentException("参数无法解析: " + valueUnit);
        } else {
            number = Double.valueOf(map.get("number"));
            if (number.doubleValue() == 0 && number.doubleValue() < Double.MAX_VALUE) {
                throw new IllegalArgumentException("需要转换的值不能为0或超出计算范围");
            }
            Unit fromUnit = Unit.valueOf(map.get("unit"));
            int fromOrdinal = fromUnit.ordinal();
            int toOrdinal = toUnit.ordinal();
            if (fromOrdinal == toOrdinal) {
                throw new IllegalArgumentException("当前单位和转换结果的目标单位不能相同");
            }
            // big to small
            if (fromOrdinal > toOrdinal) {
                number = customToSmall(number, fromUnit, toUnit);
            } else {
                number = autoToBig(number, fromUnit);
            }
        }
        return number;
    }

    private static Number customToSmall(Number number, Unit fromUnit, Unit toUnit){
        final int enumIdx = 0;
        final int special = 8;
        final int resultScale = 2;
        int fromOrdinal = fromUnit.ordinal();
        int toOrdinal = toUnit.ordinal();
        int level = fromOrdinal - toOrdinal;
        BigDecimal value = BigDecimal.valueOf(number.doubleValue());
        BigDecimal basicDec = BigDecimal.valueOf(basic);
        BigDecimal specialDec = BigDecimal.valueOf(special);
        if (toOrdinal == enumIdx) {
            level -= 1;
            value = value.multiply(specialDec);
        }
        for (int i = 1; i <= level; i++) {
            value = value.multiply(basicDec);
        }
        value = value.setScale(resultScale, RoundingMode.HALF_UP);
        return formatToLong(value);
    }

    private static String customToSmall(Number number, Unit fromUnit, Unit toUnit, String separatorChar, String unitSuffix) {
        final int enumIdx = 0;
        final int special = 8;
        final int resultScale = 2;
        int fromOrdinal = fromUnit.ordinal();
        int toOrdinal = toUnit.ordinal();
        int level = fromOrdinal - toOrdinal;
        BigDecimal value = BigDecimal.valueOf(number.doubleValue());
        BigDecimal basicDec = BigDecimal.valueOf(basic);
        BigDecimal specialDec = BigDecimal.valueOf(special);
        if (toOrdinal == enumIdx) {
            level -= 1;
            value = value.multiply(specialDec);
        }
        for (int i = 1; i <= level; i++) {
            value = value.multiply(basicDec);
        }
        value = value.setScale(resultScale, RoundingMode.HALF_UP);
        Number resultVal = formatToLong(value);
        String result = String.valueOf(resultVal);
        if (separatorChar != null && !"".equals(separatorChar) && separatorChar.length() > 0) {
            result = result.concat(separatorChar);
        }
        result = result.concat(toUnit.name());
        if (unitSuffix != null && !"".equals(unitSuffix) && unitSuffix.length() > 0) {
            result = result.concat(unitSuffix);
        }
        return result;
    }

    private static Map<String, String> extractArgument(String valUnit) {
        Map<String, String> map = new HashMap<>();
        Unit[] units = Unit.values();
//        String unitsStr = Arrays.stream(units).map(Enum::name).collect(Collectors.joining("|"));
        StringBuilder builder = new StringBuilder();
        for (Unit unit : units) {
            String name = unit.name();
            builder.append(name);
            if (unit.ordinal() < (units.length - 1)) {
                builder.append("|");
            }
        }
        final String regex = "^(\\d+[.]?\\d*)\\s*(" + builder + ")$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(valUnit);
        while (matcher.find()) {
            map.put("number", matcher.group(1));
            map.put("unit", matcher.group(2));
        }
        return map;
    }

    private static Unit getUnitByOrdinal(int ordinal) {
        Unit[] units = Unit.values();
        for (Unit unit : units) {
            if (unit.ordinal() == ordinal) {
                return unit;
            }
        }
        throw new IllegalArgumentException("未录入该存储单位");
    }

    private static Number autoToBig(Number val, Unit fromUnit) {
        final int enumIdx = 0;
        int fromOrdinal = fromUnit.ordinal();
        if (enumIdx == fromOrdinal) {
            val = bitToByte(val);
            fromOrdinal += 1;
        }
        // 计算时尽量保持精确度 保留10位小数s
        final int scale = 10;
        // 返回时保留2位小数
        final int resultScale = 2;
        BigDecimal smallVal = BigDecimal.valueOf(val.doubleValue());
        BigDecimal basicVal = BigDecimal.valueOf(basic);
        while (smallVal.compareTo(basicVal) >= 0 && (fromOrdinal < Unit.values().length - 1)) {
            smallVal = smallVal.divide(basicVal, scale, RoundingMode.HALF_UP);
            fromOrdinal += 1;
        }
        smallVal = smallVal.setScale(resultScale, RoundingMode.HALF_UP);
        return formatToLong(smallVal);
    }

    private static String autoToBig(Number val, Unit fromUnit, String separatorChar, String unitSuffix) {
        final int enumIdx = 0;
        int fromOrdinal = fromUnit.ordinal();
        if (enumIdx == fromOrdinal) {
            val = bitToByte(val);
            fromOrdinal += 1;
        }
        // 计算时尽量保持精确度 保留10位小数s
        final int scale = 10;
        // 返回时保留2位小数
        final int resultScale = 2;
        BigDecimal smallVal = BigDecimal.valueOf(val.doubleValue());
        BigDecimal basicVal = BigDecimal.valueOf(basic);
        while (smallVal.compareTo(basicVal) >= 0 && (fromOrdinal < Unit.values().length - 1)) {
            smallVal = smallVal.divide(basicVal, scale, RoundingMode.HALF_UP);
            fromOrdinal += 1;
        }
        Unit toUnit = getUnitByOrdinal(fromOrdinal);
        smallVal = smallVal.setScale(resultScale, RoundingMode.HALF_UP);
        Number number = formatToLong(smallVal);
        String result = String.valueOf(number);
        if (separatorChar != null && !"".equals(separatorChar) && separatorChar.length() > 0) {
            result = result.concat(separatorChar);
        }
        result = result.concat(toUnit.name());
        if (unitSuffix != null && !"".equals(unitSuffix) && unitSuffix.length() > 0) {
            result = result.concat(unitSuffix);
        }
        return result;
    }

    private static Number bitToByte(Number bitSize) {
        final int basic = 8;
        final int scale = 10;
        double bitDouble = bitSize.doubleValue();
        if (bitDouble == 0) {
            return bitSize;
        }
        BigDecimal bitDec = BigDecimal.valueOf(bitDouble);
        BigDecimal basicDec = BigDecimal.valueOf(basic);
        BigDecimal byteDec = bitDec.divide(basicDec, scale, RoundingMode.HALF_UP);
        return formatToLong(byteDec);
    }

    private static Number formatToLong(Number val) {
        double d = val.doubleValue();
        long l = val.longValue();
        if (d == l) {
            return l;
        }
        return val;
    }

    public static void main(String[] args) {

        String s1 = autoConvert(10240, Unit.KB);
        System.out.println("s1 = " + s1);
        //s1 = 10MB

        String s2 = autoConvert(8192, Unit.KB, " ", "/s");
        System.out.println("s2 = " + s2);
        //s2 = 8 MB/s

        String s3 = autoConvert("10240TB");
        System.out.println("s3 = " + s3);
        //s3 = 10PB

        String s4 = autoConvert("1023GB", " ", "/每天");
        System.out.println("s4 = " + s4);
        //s4 = 1023 GB/每天

        String s5 = customConvert("1TB", Unit.bit);
        System.out.println("s5 = " + s5);
        //s5 = 8796093022208bit

        String s6 = customConvert(1, Unit.TB, Unit.bit);
        System.out.println("s6 = " + s6);
        //s6 = 8796093022208bit

        String s7 = customConvert("1CB", Unit.YB);
        System.out.println("s7 = " + s7);
        //s7 = 1099511627776YB

        String s8 = autoConvert(9.8938489077261e+27,Unit.bit);
        System.out.println("s8 = " + s8);
        //s8 = 1023YB

        String s9 = customConvert(1024, Unit.B, Unit.bit, " ", null);
        System.out.println("s9 = " + s9);
        //s9 = 8192 bit

        String s10 = customConvert("1024KB", Unit.MB, " ", "/s");
        System.out.println("s10 = " + s10);
        //s10 = 1 MB/s

        Number n1 = getNumberConvert("1024GB", Unit.MB);
        System.out.println("n1 = " + n1);
        //n1 = 1048576

        Number n2 = getNumberConvert(1024, Unit.KB, Unit.MB);
        System.out.println("n2 = " + n2);
        //n2 = 1
    }


}

Java_Glory
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java编写的简单的单位换算工具
12-05
java编写的简单的单位换算工具 小应用程序，源代码及可执行程序，网页程序
数据存储单位转换，b、byte、KB、MB、GB、TB转换工具类
today_liqiu的博客
07-11 902
数据存储单位转换，b、byte、KB、MB、GB、TB转换工具类
java工具类 单位转化
weixin_38503935的博客
11-15 943
一、金额转换 public static String changeF2Y(String amount) throws Exception { if (!amount.matches("\\-?[0-9]+")) { throw new Exception("分转元"); } return BigDecimal.valueO...
1261: 单位转换（Java）
weixin_30323631的博客
04-12 230
WUSTOJ 1261: 单位转换 参考资料 数字字符串拆分——百度知道 Description BobLee最近在复习考研，在复习计算机组成原理的时候，遇到了一个问题。就是在计算机存储里面的单位转换。我们都知道1MB=1024KB，1...
SizeUtils-单位转换工具类
qq_40447795的博客
12-13 361
public class SizeUtils { public static int dip2px(Context context, float dpValue) { float scale = context.getResources().getDisplayMetrics().density; return (int) (dpValue * scale + 0.5f); } }
单位转换工具
11-01
在IT领域，单位转换工具是不可或缺的实用软件，尤其对于工程师、科研人员和学生来说，它们可以帮助用户在不同测量单位间轻松转换数据。"终极单位换算器3.4.exe"是一个这样的应用，可能提供了全面且精准的单位转换...
easyconversiontools:简易转换工具单位转换网站
07-12
总的来说，"easyconversiontools"是一个利用JavaScript技术构建的实用单位转换工具，它的源代码"easyconversiontools-master"为开发者提供了学习和定制单位转换功能的宝贵资源。通过研究这个项目，我们可以深入了解...
长度、重量单位转换工具源码
09-03
【标题】"长度、重量单位转换工具源码"所涉及的知识点主要集中在程序设计和数据库管理两个领域。这个工具是用来帮助用户在不同的长度和重量单位之间进行转换的，因此源码中必然包含了处理这种转换的算法。源码的编写...
通信行业常用的分贝毫瓦转换工具
11-07
只需双击运行PowerConvert.exe文件，即可启动工具，快速进行功率单位的转换。 在实际操作中，用户可能需要将接收机的灵敏度、信号强度或者发射机的功率输出等参数从dBm转换成mW，或者反过来，以便于理解和比较。这...
java 简单的长度单位转换类
06-21
在Java编程语言中，开发一个简单的长度单位转换类是一个常见的任务，这有助于处理不同单位间的数值转换，如米（m）、厘米（cm）、毫米（mm）等。下面我们将详细探讨如何构建这样的类，并理解其中涉及的关键概念。 ...
单位转换器
11-21
用Java开发的单位转换器，包含时间,货币,长度,质量,密度,温度,面积,体积,速度,功率,力,压强,功,热导率,气油比,数据存储中常用单位的转换，包含公制，英制，及中国传统单位的换算
java计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换)
05-27
java计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换) java 硬盘大小转换 数据转换 内存转换 存储大小转换
常用 单位换算器 Java 源代码
11-18
实现了常用 长度、时间、温度单位的换算, 关于面积、体积、压强、角度等可根据换算公式再代码相应位置中添加。
计量单位转换工具＋＋
12-27
计量单位转换工具＋＋，很多中单位之间的快速转换。
Java封装了一个自适应的单位转换工具类
最新发布
Javaの甘乃迪的博客
01-12 1049
Java封装了一个自适应的单位转换工具类
我的Android进阶之旅------>Java文件大小转换工具类 (B,KB,MB,GB,TB,PB之间的大小转换)
字节卷动
02-22 8228
Java文件大小转换工具类 (B,KB,MB,GB,TB,PB之间的大小转换) 有时候要做出如下所示的展示文件大小的效果时候，需要对文件大小进行转换，然后再进行相关的代码逻辑编写。下面是一个Java文件大小转换工具类 ，可以进行B,KB,MB,GB,TB,PB之间的大小转换。该工具类来源于博客：(http://blog.csdn.net/xmtblog/article/details/27194
优雅的实现计算机容量Bit Byte KB等互相转换-Java工具类
Java Developer Blog
05-28 1026
日常工作中, 偶尔会遇到计算机容量之间的相互转换. 众所周知计算机的基本存储单位有Bit, Byte, KB, MB, GB, TB等. 这里参考 TimeUnit 实现一套优雅的计算机容量互相转换工具, 并提供一个支持自动升级容量单位的方法. 工具类源码 https://gitee.com/zture/spring-test/blob/master/demo/src/main/java/cn/diswares/blog/demo/util/StoreUnit.java 实现思路 创建枚举类 Stor
单位转换工具类
chizhu5318的博客
04-11 244
packagecom.yaphis.util.unith; importjava.math.BigDecimal; importjava.text.DecimalFormat; importjava.text.NumberFormat; /** *单位转换工具类 * *...
Java计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换)
weixin_34208185的博客
05-30 371
程序员都很懒，你懂的！ java程序员在实际的开发中会遇到很多的单位换算问题。今天我给大家带来的是关于计算机硬盘大小的换算。多数情况下，一般要求 b,kb,mb,gb,tb,pb之间的大小转换，我们都知道他们之间的换算是乘以1024或者除以1024。但是具体怎么用java代码来实现呢？请看 下面的代码： 1 package com.herman.utils; 2 ...
Java实现金额单位转换工具类
"Java代码实现金额单位转换，包括将金额从分转换为元，并进行格式化处理。" 在Java开发中，特别是在财务系统或者电商应用中，经常需要处理金额的单位转换，例如将金额从分转换为元，同时进行千分位的逗号分隔以提高...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值