Java SizeToHuman 大小转换为mb kb tb等

最新推荐文章于 2024-03-15 17:49:47 发布
最新推荐文章于 2024-03-15 17:49:47 发布
阅读量351 收藏 1
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tomhat/article/details/84907311
版权 

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");            
    }          
} 


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


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


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


转自：[url]http://blog.csdn.net/earbao/article/details/50037319[/url]
tomhat
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java实现字节数B转化为KB、MB、GB的方法示例【测试可用】
08-29
Java是一种广泛使用的编程语言，在文件处理系统中，经常需要将字节数B转化为KB、MB、GB等单位，以便更好地呈现给用户。下面将详细介绍Java实现字节数B转化为KB、MB、GB的方法。 1. 字节数B转化为KB 在文件处理系统...
JAVA将字节大小转换成(B,KB,MB,GB,TB)单位
涛哥是个大帅比
06-13 3613
项目中需要判断一个文件是否超过指定大小，如果超过了，需要将文件大小转换为最大满足单位。
KB、MB、GB java转换工具类
tang_sy的博客
01-17 712
【代码】KB、MB、GB 项目转换工具类。
Java文件大小转换的两种方式
最新发布
qq_43108153的博客
03-15 1081
文件字节转换
Java 获取文件大小
热门推荐
neweastsun的专栏
03-30 1万+
Java 获取文件大小 本文介绍几种方法获取文件大小，分别是java io 和 nio 以及第三方库实现。 标准的java io 首先开始一个简单实例计算文件大小，使用File.lenght()方法： private long getFileSize(File file) { long length = file.length(); return length; } 需要注意的是...
java计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换)
05-27
java计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换) java 硬盘大小转换 数据转换 内存转换 存储大小转换
PHP实现字节数Byte转换为KB、MB、GB、TB的方法 <font color=red>原创</font>
10-19
主要介绍了PHP实现字节数Byte转换为KB、MB、GB、TB的方法,结合实例形式分析了php针对字节数Byte的换算操作具体实现方法,涉及php数学运算相关函数的使用,需要的朋友可以参考下
易语言-文件大小转换源码 字节转换成KB/MB/GB
06-25
这段代码展示了如何根据文件的字节数，通过条件判断和数学运算，将文件大小转换为KB、MB或GB，并用易语言的内置函数打印出来。这样的程序对于处理文件操作、文件系统交互或任何需要展示文件大小信息的应用场景都十分...
PHP实现字节数Byte转换为KB、MB、GB、TB的方法 原创
01-20
前面介绍了java实现字节数Byte转换为KB、MB、GB、TB的方法 ，这里改用PHP实现这一功能。代码非常简单： <?php function getFilesize($num){ $p = 0; $format='bytes'; if($num>0 && $num<1024 xss=removed>=...
java 返回文件大小（带单位）
zhanghaotao的专栏
10-06 1869
print sizes in human readable format (e.g., 1K 234M 2G)   java File.java类中的length()方法返回的文件长度是长以字节为单位，下面的方法是根据字节数格式化相应的其他单位(KB、MB、GB等)。   public static String getFormatSize(double size) { doub...
JAVA 获取文件字节大小转换成 kb、M、G 等单元 工具类
JavaNotes的博客
11-06 1万+
https://www.jianshu.com/p/4610944ee9be public static String readableFileSize(long size) { if (size &lt;= 0) return "0"; final String[] units = new String[]{"B", "KB", "MB", "GB", "TB"}; int d
java计算文件的大小_关于java中如何计算文件及文件夹大小？
weixin_42511098的博客
02-12 2437
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 1736
java
java上传文件大小转换（字节转kb/mb/gb）
weixin_34160277的博客
02-16 1281
/** * 字节转kb/mb/gb * @param size * @return */ public String getPrintSize(long size) { //如果字节数少于1024，则直接以B为单位，否则先除于1024，后3位因太少无意义 if (size &lt...
java 获得文件大小并转换为MB
renermm的博客
10-25 4218
//不能直接进行运算，会损失精度,因此先取得大小 double fileSize = file.length(); //运算转换单位（保留2位小数） double fileSizeMB = new BigDecimal(fileSize/1024/1024).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(); //转换单位为MB ...
Java中 字节转 KB/MB/GB
m0_57119230的博客
05-07 5301
字节转 KB/MB/GB 保留两位小数四舍五入 public static String getFileSize(String size) { double length = Double.parseDouble(size); //如果字节数少于1024，则直接以B为单位，否则先除于1024，后3位因太少无意义 if (length < 1024) { return length + "B"; } else
java kb mb gb 转换,java – 动态地将KB转换为MB,GB,TB
weixin_39967405的博客
03-10 1139
public String size(int size){String hrSize = "";int k = size;double m = size/1024;double g = size/1048576;double t = size/1073741824;DecimalFormat dec = new DecimalFormat("0.00");if (k>0){hrSize = ...
Java实现字节转换，可以自动转换为B、KB、MB、GB、TB
一不小心做了程序员的博客
09-19 3143
Java实现字节转换，可以自动转换为B、KB、MB、GB、TB
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 / ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值