[移动开发]自定义字节转换工具类

简介

实现需求时遇到了需要进行字节转换的情况，针对面临的一些问题以及思考拓展实现了一个工具类。

基本功能如下：

• 自定义转换的单位区间。比如转换结果的最小单位为KB，最大单位为GB。
• 自定义进制数。一般来说以1024为进制数，但有时也可能会用到1000。
• 转换结果再处理。支持对转换结果进行保留小数、向上取整、向下取整、四舍五入等操作。
• 转换结果带单位。支持为结果添加单位，例如10KB。
• 特殊处理“零”。当转换结果为0时，往往需要展示特殊的文案，如"无可清理内容"，可通过自定义接口的方式返回特殊的字符串，默认返回空字符串。
• 更多功能可自行阅读代码后拓展实现，或在网上下载研究其他转换工具类，相信各位能收获更多。

完整代码

public class ByteUtils {

    public static final String TAG = "ByteUtils";

    //进制转换数
    public static final float STANDARD_RADIX = 1024;
    public static final float SPECIAL_RADIX = 1000;

    //结果处理模式
    public static final int MODE_DEFAULT = 0;             //不做任何处理
    public static final int MODE_KEEP_ONE = 1;            //保留一位小数
    public static final int MODE_KEEP_TWO = 2;            //保留两位小数
    public static final int MODE_CEIL = 10;               //对结果向上取整，不保留小数
    public static final int MODE_FLOOR = 11;              //对结果向下取整，不保留小数
    public static final int MODE_FLOOR_NOT_ZERO = 12;     //对结果向下取整，不保留小数，若向下取整后结果为0，置1
    public static final int MODE_ROUND = 13;              //对结果四舍五入，不保留小数
    public static final int MODE_ROUND_NOT_ZERO = 14;     //对结果四舍五入，不保留小数，若四舍五入后结果为0，置1

    public static final zeroHandler DEFAULT_HANDLER = new zeroHandler() {
        @Override
        public String getString() {
            return "";
        }
    };

    //单位，顺序不可改变
    public enum Unit {
        BYTE(R.string.byteShort),
        KILOBYTE(R.string.kilobyteShort),
        MEGABYTE(R.string.megabyteShort),
        GIGABYTE(R.string.gigabyteShort),
        TERABYTE(R.string.terabyteShort),
        PETABYTE(R.string.petabyteShort);

        private final int resId;

        Unit(int resId) {
            this.resId = resId;
        }

        public int getResId() {
            return resId;
        }
    }

    /**
     * 字节自动转换
     *
     * @param size        字节大小
     * @param unit        字节单位
     * @param minimumUnit 最小单位。结果展示的最小单位，如设置为MB，输入1024B，则返回结果为0.001MB
     * @param maximumUnit 最大单位。结果展示的最大单位，如设置为MB，输入1GB，则返回结果为1024MB
     * @param radix       进制数。建议根据情况选择1000或1024
     * @param resultMode  结果处理模式。默认不对结果进行处理，可对结果进行保留小数、向上取整、向下取整、四舍五入等操作
     * @param needUnit    结果是否需要单位。为true时结果会带单位，如10KB
     * @param handler     输入size为0时的特殊处理，自定义实现zeroHandler接口的getString方法来返回特殊的字符串
     * @return 转换结果
     */
    public static String numberToByteString(double size, Unit unit, Unit minimumUnit, Unit maximumUnit, float radix, int resultMode, boolean needUnit, zeroHandler handler) {

        if (size < 0) {
            DefaultLogger.d(TAG, "the size must be greater than zero");
            return "";
        }

        if (handler != null && size == 0) {
            return handler.getString();
        }

        int init = unit.ordinal();
        int min = minimumUnit.ordinal();
        int max = maximumUnit.ordinal();

        if (min > max) {
            DefaultLogger.d(TAG, "min unit need be less than max unit");
            return "";
        }

        //start conversion
        double byteSize = size * Math.pow(radix, init);

        int finalUnit = 0;

        while (finalUnit < min) {
            byteSize = byteSize / radix;
            finalUnit++;
        }

        while (byteSize > radix) {
            if (finalUnit == max) break;
            byteSize = byteSize / radix;
            finalUnit++;
        }
        //end conversion

        //start handle result
        String resultSize = String.valueOf(byteSize);
        String resultUnit = "";

        if (resultMode != MODE_DEFAULT) {
            if (resultMode <= MODE_KEEP_TWO) {
                String format = "%." + resultMode + "f";
                resultSize = String.format(format, byteSize);
            } else {
                switch (resultMode) {
                    case MODE_CEIL:
                        byteSize = Math.ceil(byteSize);
                        break;
                    case MODE_FLOOR:
                        byteSize = Math.floor(byteSize);
                        break;
                    case MODE_FLOOR_NOT_ZERO:
                        double temp1 = Math.floor(byteSize);
                        byteSize = temp1 == 0 ? 1 : temp1;
                        break;
                    case MODE_ROUND:
                        byteSize = Math.round(byteSize);
                        break;
                    case MODE_ROUND_NOT_ZERO:
                        double temp2 = Math.round(byteSize);
                        byteSize = temp2 == 0 ? 1 : temp2;
                        break;
                    default:
                        break;
                }
                resultSize = String.valueOf((long) byteSize);
            }
        }

        if (needUnit) {
            resultUnit = ResourceUtils.getString(Unit.values()[finalUnit].getResId());
        }
        //end handle result

        return resultSize + resultUnit;
    }

    public interface zeroHandler {
        String getString();
    }

    /**
     * 转换Byte到目标单位
     *
     * @param size size of Byte
     * @param unit target Unit
     * @return size of target Unit
     */
    public static String numberToByteString(double size, Unit unit) {
        return numberToByteString(size, Unit.BYTE, unit, unit, STANDARD_RADIX, MODE_DEFAULT, false, null);
    }

    /**
     * 转换Byte到目标单位，默认进制1024，是否带单位
     *
     * @param size     size of Byte
     * @param unit     target Unit
     * @param needUnit add or not add unit
     * @return size of target Unit
     */
    public static String numberToByteString(double size, Unit unit, boolean needUnit) {
        return numberToByteString(size, Unit.BYTE, unit, unit, STANDARD_RADIX, MODE_DEFAULT, needUnit, null);
    }

    /**
     * 转换Byte到目标单位，默认进制1024，并对结果进行处理
     *
     * @param size size of Byte
     * @param unit target Unit
     * @param mode the mode of handler result
     * @return size of target Unit
     */
    public static String numberToByteString(double size, Unit unit, int mode) {
        return numberToByteString(size, Unit.BYTE, unit, unit, STANDARD_RADIX, mode, false, null);
    }

    /**
     * 转换Byte到目标单位，默认进制1024，并对结果进行处理，是否带单位
     *
     * @param size     size of Byte
     * @param unit     target Unit
     * @param mode     the mode of handler result
     * @param needUnit add or not add unit
     * @return size of target Unit
     */
    public static String numberToByteString(double size, Unit unit, int mode, boolean needUnit) {
        return numberToByteString(size, Unit.BYTE, unit, unit, STANDARD_RADIX, mode, needUnit, null);
    }

    /**
     * 转换Byte到目标单位，自定义进制
     *
     * @param size  size of Byte
     * @param unit  target Unit
     * @param radix select 1000 or 1024 as appropriate
     * @return size of target Unit
     */
    public static String numberToByteString(double size, Unit unit, float radix) {
        return numberToByteString(size, Unit.BYTE, unit, unit, radix, MODE_DEFAULT, false, null);
    }

    //add more...
}