Java SizeToHuman 大小转换为mb kb tb等

最新推荐文章于 2024-04-19 18:02:05 发布
最新推荐文章于 2024-04-19 18:02:05 发布
阅读量3.6k 收藏
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/earbao/article/details/50037319
版权 

package com.jiepu.docbuildermanager.demo;

import com.jiepu.docbuildermanager.tool.ByteSizeUnit;
import com.jiepu.docbuildermanager.tool.ByteSizeValue;
import com.jiepu.docbuildermanager.tool.MyCommonTool;

public class TestSizeToHuman {
    
    public static void main(String[] args) {
        
        String str=MyCommonTool.readableFileSize(123456);
        System.out.println("str="+str);
        
        String line=org.apache.commons.io.FileUtils.byteCountToDisplaySize(123456);
        System.out.println("line="+line);
        
        ByteSizeValue byteSizeValue=new ByteSizeValue(123456, ByteSizeUnit.BYTES);
        System.out.println("byteSizeValue="+byteSizeValue.getKbFrac()+" KB");
        System.out.println("byteSizeValue="+byteSizeValue.getMbFrac()+" MB");
        
    }
      
}


package com.jiepu.docbuildermanager.tool;

import java.text.DecimalFormat;

public class MyCommonTool {

    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];
    }

}

package com.jiepu.docbuildermanager.tool;

import java.io.Serializable;
import java.util.Locale;

public class ByteSizeValue implements Serializable {

    private long size;

    private ByteSizeUnit sizeUnit;

    private ByteSizeValue() {

    }

    public ByteSizeValue(long bytes) {
        this(bytes, ByteSizeUnit.BYTES);
    }

    public ByteSizeValue(long size, ByteSizeUnit sizeUnit) {
        this.size = size;
        this.sizeUnit = sizeUnit;
    }

    public int bytesAsInt() throws Exception {
        long bytes = bytes();
        if (bytes > Integer.MAX_VALUE) {
            throw new Exception("size [" + toString() + "] is bigger than max int");
        }
        return (int) bytes;
    }

    public long bytes() {
        return sizeUnit.toBytes(size);
    }

    public long getBytes() {
        return bytes();
    }

    public long kb() {
        return sizeUnit.toKB(size);
    }

    public long getKb() {
        return kb();
    }

    public long mb() {
        return sizeUnit.toMB(size);
    }

    public long getMb() {
        return mb();
    }

    public long gb() {
        return sizeUnit.toGB(size);
    }

    public long getGb() {
        return gb();
    }

    public long tb() {
        return sizeUnit.toTB(size);
    }

    public long getTb() {
        return tb();
    }

    public long pb() {
        return sizeUnit.toPB(size);
    }

    public long getPb() {
        return pb();
    }

    public double kbFrac() {
        return ((double) bytes()) / ByteSizeUnit.C1;
    }

    public double getKbFrac() {
        return kbFrac();
    }

    public double mbFrac() {
        return ((double) bytes()) / ByteSizeUnit.C2;
    }

    public double getMbFrac() {
        return mbFrac();
    }

    public double gbFrac() {
        return ((double) bytes()) / ByteSizeUnit.C3;
    }

    public double getGbFrac() {
        return gbFrac();
    }

    public double tbFrac() {
        return ((double) bytes()) / ByteSizeUnit.C4;
    }

    public double getTbFrac() {
        return tbFrac();
    }

    public double pbFrac() {
        return ((double) bytes()) / ByteSizeUnit.C5;
    }

    public double getPbFrac() {
        return pbFrac();
    }
 /**
     * Format the double value with a single decimal points, trimming trailing '.0'.
     */
    public static String format1Decimals(double value, String suffix) {
        String p = String.valueOf(value);
        int ix = p.indexOf('.') + 1;
        int ex = p.indexOf('E');
        char fraction = p.charAt(ix);
        if (fraction == '0') {
            if (ex != -1) {
                return p.substring(0, ix - 1) + p.substring(ex) + suffix;
            } else {
                return p.substring(0, ix - 1) + suffix;
            }
        } else {
            if (ex != -1) {
                return p.substring(0, ix) + fraction + p.substring(ex) + suffix;
            } else {
                return p.substring(0, ix) + fraction + suffix;
            }
        }
    }

    
    @Override
    public String toString() {
        long bytes = bytes();
        double value = bytes;
        String suffix = "b";
        if (bytes >= ByteSizeUnit.C5) {
            value = pbFrac();
            suffix = "pb";
        } else if (bytes >= ByteSizeUnit.C4) {
            value = tbFrac();
            suffix = "tb";
        } else if (bytes >= ByteSizeUnit.C3) {
            value = gbFrac();
            suffix = "gb";
        } else if (bytes >= ByteSizeUnit.C2) {
            value = mbFrac();
            suffix = "mb";
        } else if (bytes >= ByteSizeUnit.C1) {
            value = kbFrac();
            suffix = "kb";
        }
        return format1Decimals(value, suffix);
    }

    public static ByteSizeValue parseBytesSizeValue(String sValue) throws Exception {
        return parseBytesSizeValue(sValue, null);
    }

    public static ByteSizeValue parseBytesSizeValue(String sValue, ByteSizeValue defaultValue) throws Exception {
        if (sValue == null) {
            return defaultValue;
        }
        long bytes;
        try {
            String lastTwoChars = sValue.substring(sValue.length() - Math.min(2, sValue.length())).toLowerCase(Locale.ROOT);
            if (lastTwoChars.endsWith("k")) {
                bytes = (long) (Double.parseDouble(sValue.substring(0, sValue.length() - 1)) * ByteSizeUnit.C1);
            } else if (lastTwoChars.endsWith("kb")) {
                bytes = (long) (Double.parseDouble(sValue.substring(0, sValue.length() - 2)) * ByteSizeUnit.C1);
            } else if (lastTwoChars.endsWith("m")) {
                bytes = (long) (Double.parseDouble(sValue.substring(0, sValue.length() - 1)) * ByteSizeUnit.C2);
            } else if (lastTwoChars.endsWith("mb")) {
                bytes = (long) (Double.parseDouble(sValue.substring(0, sValue.length() - 2)) * ByteSizeUnit.C2);
            } else if (lastTwoChars.endsWith("g")) {
                bytes = (long) (Double.parseDouble(sValue.substring(0, sValue.length() - 1)) * ByteSizeUnit.C3);
            } else if (lastTwoChars.endsWith("gb")) {
                bytes = (long) (Double.parseDouble(sValue.substring(0, sValue.length() - 2)) * ByteSizeUnit.C3);
            } else if (lastTwoChars.endsWith("t")) {
                bytes = (long) (Double.parseDouble(sValue.substring(0, sValue.length() - 1)) * ByteSizeUnit.C4);
            } else if (lastTwoChars.endsWith("tb")) {
                bytes = (long) (Double.parseDouble(sValue.substring(0, sValue.length() - 2)) * ByteSizeUnit.C4);
            } else if (lastTwoChars.endsWith("p")) {
                bytes = (long) (Double.parseDouble(sValue.substring(0, sValue.length() - 1)) * ByteSizeUnit.C5);
            } else if (lastTwoChars.endsWith("pb")) {
                bytes = (long) (Double.parseDouble(sValue.substring(0, sValue.length() - 2)) * ByteSizeUnit.C5);
            } else if (lastTwoChars.endsWith("b")) {
                bytes = Long.parseLong(sValue.substring(0, sValue.length() - 1));
            } else {
                bytes = Long.parseLong(sValue);
            }
        } catch (NumberFormatException e) {
            throw new Exception("Failed to parse [" + sValue + "]", e);
        }
        return new ByteSizeValue(bytes, ByteSizeUnit.BYTES);
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        ByteSizeValue sizeValue = (ByteSizeValue) o;

        if (size != sizeValue.size) return false;
        if (sizeUnit != sizeValue.sizeUnit) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = (int) (size ^ (size >>> 32));
        result = 31 * result + (sizeUnit != null ? sizeUnit.hashCode() : 0);
        return result;
    }
}
</pre><pre name="code" class="java">
package com.jiepu.docbuildermanager.tool;

public enum ByteSizeUnit {
    BYTES {
        @Override
        public long toBytes(long size) {
            return size;
        }

        @Override
        public long toKB(long size) {
            return size / (C1 / C0);
        }

        @Override
        public long toMB(long size) {
            return size / (C2 / C0);
        }

        @Override
        public long toGB(long size) {
            return size / (C3 / C0);
        }

        @Override
        public long toTB(long size) {
            return size / (C4 / C0);
        }

        @Override
        public long toPB(long size) {
            return size / (C5 / C0);
        }
    },
    KB {
        @Override
        public long toBytes(long size) {
            return x(size, C1 / C0, MAX / (C1 / C0));
        }

        @Override
        public long toKB(long size) {
            return size;
        }

        @Override
        public long toMB(long size) {
            return size / (C2 / C1);
        }

        @Override
        public long toGB(long size) {
            return size / (C3 / C1);
        }

        @Override
        public long toTB(long size) {
            return size / (C4 / C1);
        }

        @Override
        public long toPB(long size) {
            return size / (C5 / C1);
        }
    },
    MB {
        @Override
        public long toBytes(long size) {
            return x(size, C2 / C0, MAX / (C2 / C0));
        }

        @Override
        public long toKB(long size) {
            return x(size, C2 / C1, MAX / (C2 / C1));
        }

        @Override
        public long toMB(long size) {
            return size;
        }

        @Override
        public long toGB(long size) {
            return size / (C3 / C2);
        }

        @Override
        public long toTB(long size) {
            return size / (C4 / C2);
        }

        @Override
        public long toPB(long size) {
            return size / (C5 / C2);
        }
    },
    GB {
        @Override
        public long toBytes(long size) {
            return x(size, C3 / C0, MAX / (C3 / C0));
        }

        @Override
        public long toKB(long size) {
            return x(size, C3 / C1, MAX / (C3 / C1));
        }

        @Override
        public long toMB(long size) {
            return x(size, C3 / C2, MAX / (C3 / C2));
        }

        @Override
        public long toGB(long size) {
            return size;
        }

        @Override
        public long toTB(long size) {
            return size / (C4 / C3);
        }

        @Override
        public long toPB(long size) {
            return size / (C5 / C3);
        }
    },
    TB {
        @Override
        public long toBytes(long size) {
            return x(size, C4 / C0, MAX / (C4 / C0));
        }

        @Override
        public long toKB(long size) {
            return x(size, C4 / C1, MAX / (C4 / C1));
        }

        @Override
        public long toMB(long size) {
            return x(size, C4 / C2, MAX / (C4 / C2));
        }

        @Override
        public long toGB(long size) {
            return x(size, C4 / C3, MAX / (C4 / C3));
        }

        @Override
        public long toTB(long size) {
            return size;
        }

        @Override
        public long toPB(long size) {
            return size / (C5 / C4);
        }
    },
    PB {
        @Override
        public long toBytes(long size) {
            return x(size, C5 / C0, MAX / (C5 / C0));
        }

        @Override
        public long toKB(long size) {
            return x(size, C5 / C1, MAX / (C5 / C1));
        }

        @Override
        public long toMB(long size) {
            return x(size, C5 / C2, MAX / (C5 / C2));
        }

        @Override
        public long toGB(long size) {
            return x(size, C5 / C3, MAX / (C5 / C3));
        }

        @Override
        public long toTB(long size) {
            return x(size, C5 / C4, MAX / (C5 / C4));
        }

        @Override
        public long toPB(long size) {
            return size;
        }
    };

    static final long C0 = 1L;
    static final long C1 = C0 * 1024L;
    static final long C2 = C1 * 1024L;
    static final long C3 = C2 * 1024L;
    static final long C4 = C3 * 1024L;
    static final long C5 = C4 * 1024L;

    static final long MAX = Long.MAX_VALUE;

    /**
     * Scale d by m, checking for overflow.
     * This has a short name to make above code more readable.
     */
    static long x(long d, long m, long over) {
        if (d > over) return Long.MAX_VALUE;
        if (d < -over) return Long.MIN_VALUE;
        return d * m;
    }


    public abstract long toBytes(long size);

    public abstract long toKB(long size);

    public abstract long toMB(long size);

    public abstract long toGB(long size);

    public abstract long toTB(long size);

    public abstract long toPB(long size);
}




yunshouhu
关注
专栏目录
java计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换)
05-27
java计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换) java 硬盘大小转换 数据转换 内存转换 存储大小转换
java工具类 MB GB TB PB和Mbps之间的转换及编程实现
q_913246828的博客
10-16 349
在计算机网络和通信中，Mbps (兆比特每秒)和MB/s (兆字节每秒)是常用的单位,用于示数据传输速度或带宽。虽然它们都表示每秒传输的数据量，但Mbps和MB/s使用的是不同的计量单位，因此在进行转换时需要注意。首先，我们来了解Mbps和MB/s之间的换算关系。1 Mbps等于1兆比特每秒，而1字节等于8比特。因此，要将Mbps转换为MB/s, 需要将Mbps除以8。换句话说，1 MB/s等于8 Mbps。下面是java代码实现工具类。
【Java】文件大小转换工具类（B，KB，MB，G，TB，PB）
最新发布
openallzzz
04-19 777
根据字节大小生成不同的的自适应结果（例如：4.1KB）。可以留意在浏览器上下载的文件，会根据问价大小展示不同的单位（如下图），本工具类也可以实现。扩展：可以自己控制需要保留的位数。
Java对象的字节大小计算
热门推荐
博学而笃志，切问而近思
05-06 2万+
计算Java对象的字节大小 Java基本类型长度及对应对象的字节长度 基本类型 长度 the size of an object Int 4 16 Short 2 16 Long 8 24 Byte 1 16 Character 1 16 Float 4 16 Dou...
Elasticsearch java API (10)批量处理 API
u012116196的专栏
06-24 1万+
使用批量处理器编辑 的 BulkProcessor类提供了一个简单接口自动冲洗批量操作基于请求的数量或大小,或者在给定的时期。 使用它,首先创建一个 BulkProcessor实例:import org.elasticsearch.action.bulk.BackoffPolicy; import org.elasticsearch.action.bulk.BulkProc
Java实现字节数B转化为KB、MB、GB的方法示例【测试可用】
08-29
Java是一种广泛使用的编程语言，在文件处理系统中，经常需要将字节数B转化为KB、MB、GB等单位，以便更好地呈现给用户。下面将详细介绍Java实现字节数B转化为KB、MB、GB的方法。 1. 字节数B转化为KB 在文件处理系统...
java mb单位转换_Java计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换)
weixin_28678151的博客
02-16 1388
程序员都很懒，你懂的！java程序员在实际的开发中会遇到很多的单位换算问题。今天我给大家带来的是关于计算机硬盘大小的换算。多数情况下，一般要求 b,kb,mb,gb,tb,pb之间的大小转换，我们都知道他们之间的换算是乘以1024或者除以1024。但是具体怎么用java代码来实现呢？请看 下面的代码：package com.herman.utils;/**** @see 存储大小(单位)转换器.*...
用Java实现，把Byte,相应的转换为KB,MB，GB，TB
kang315
09-20 3753
  算法：先从文件中一行一行的读，把需要的转换的字节截取出来，然后用BigInteger类实现转换，为了方便计算，我们用10三次方，替代1024计算。   package com.Capacity; import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; imp...
易语言-文件大小转换源码 字节转换成KB/MB/GB
06-25
这段代码展示了如何根据文件的字节数，通过条件判断和数学运算，将文件大小转换为KB、MB或GB，并用易语言的内置函数打印出来。这样的程序对于处理文件操作、文件系统交互或任何需要展示文件大小信息的应用场景都十分...
java计算文件的大小_关于java中如何计算文件及文件夹大小？
weixin_42511098的博客
02-12 2445
1.文件大小在File类中，通过length()方法返回文件大小，方法定义如下：publiclonglength(){...}可用通过该方法判断文件返回字节数大小，判断文件是否为空，如下：Filef=newFile("c:/test.txt");@b@if(f.exists()&&f.length()==0){@b@System.out.println("...
Java 实现读取出来的文件大小变成KB,MB,TB,PB大小，或者将大单位变成KB
一天不写代码难受的博客
02-15 1752
java
Java实现字节转换，可以自动转换为B、KB、MB、GB、TB
一不小心做了程序员的博客
09-19 3170
Java实现字节转换，可以自动转换为B、KB、MB、GB、TB
将java字节自动转为"B", "KB", "MB", "GB", "TB"等
weixin_30772261的博客
12-24 438
//字节转换 public static String readableFileSize(long size) { if (size <= 0) return "0"; final String[] units = new String[]{"B", "KB", "MB", "GB", "TB"}; int digitGroups = (int) (...
java size 方法_Java CharArrayWriter size()方法
weixin_34691461的博客
02-16 1010
Java CharArrayWriter size()方法java.io.CharArrayWriter.size() 方法用于获取缓冲区的当前大小。1 语法public int size()2 参数无3 返回值该方法返回一个整数值，该整数值表示缓冲区的当前大小。4 示例package com.yiidian;/*** 一点教程网： http://www.yiidian.com*//*** jav...
java byte(字节)根据长度转成kb(千字节)和mb(兆字节)
机智W_en的博客
05-25 4352
读取二进制文件长度，将其转换为kb或者mb /** * byte(字节)根据长度转成kb(千字节)和mb(兆字节) * * @param bytes * @return */ public static int bytes2kb(int bytes) { BigDecimal filesize = new BigDecimal(bytes); BigDecimal megabyte = new BigDecima
我的Android进阶之旅------>Java文件大小转换工具类 (B,KB,MB,GB,TB,PB之间的大小转换)
字节卷动
02-22 8233
Java文件大小转换工具类 (B,KB,MB,GB,TB,PB之间的大小转换) 有时候要做出如下所示的展示文件大小的效果时候，需要对文件大小进行转换，然后再进行相关的代码逻辑编写。下面是一个Java文件大小转换工具类 ，可以进行B,KB,MB,GB,TB,PB之间的大小转换。该工具类来源于博客：(http://blog.csdn.net/xmtblog/article/details/27194
java GB MB K B 相互转换
xiaochongwu的专栏
01-23 5266
/**      * 转换文件大小      *       * @param fileS      * @return      */      public String formetFileSize(long fileS) {          DecimalFormat df = new DecimalFormat("#.00");          String file
Java计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换)
weixin_34208185的博客
05-30 375
程序员都很懒，你懂的！ java程序员在实际的开发中会遇到很多的单位换算问题。今天我给大家带来的是关于计算机硬盘大小的换算。多数情况下，一般要求 b,kb,mb,gb,tb,pb之间的大小转换，我们都知道他们之间的换算是乘以1024或者除以1024。但是具体怎么用java代码来实现呢？请看 下面的代码： 1 package com.herman.utils; 2 ...
C语言实现将B转换为KB、MB等的代码
05-26
以下是将字节数B转换为KB、MB、GB和TB的C语言代码： ```c #include int main() { long int bytes; printf("Enter the number of bytes: "); scanf("%ld", &bytes); double kilobytes = (double) bytes / ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值