`

Java SizeToHuman 大小转换为mb kb tb等

    博客分类：
  • java
java 
阅读更多 
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);  
}


转自：http://blog.csdn.net/earbao/article/details/50037319
分享到：
| 管理github、gitlab ssh key
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换)

    java计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换) java 硬盘大小转换 数据转换 内存转换 存储大小转换

    Java实现字节数B转化为KB、MB、GB的方法示例【测试可用】

    Java是一种广泛使用的编程语言，在文件处理系统中，经常需要将字节数B转化为KB、MB、GB等单位，以便更好地呈现给用户。下面将详细介绍Java实现字节数B转化为KB、MB、GB的方法。 1. 字节数B转化为KB 在文件处理系统...

    易语言-文件大小转换源码 字节转换成KB/MB/GB

    这段代码展示了如何根据文件的字节数，通过条件判断和数学运算，将文件大小转换为KB、MB或GB，并用易语言的内置函数打印出来。这样的程序对于处理文件操作、文件系统交互或任何需要展示文件大小信息的应用场景都十分...

    PHP实现字节数Byte转换为KB、MB、GB、TB的方法 原创

    前面介绍了java实现字节数Byte转换为KB、MB、GB、TB的方法 ，这里改用PHP实现这一功能。代码非常简单： &lt;?php function getFilesize($num){ $p = 0; $format='bytes'; if($num&gt;0 && $num&lt;1024 xss=removed&gt;=...

    文件大小字节转换成KB/MB/GB-易语言

    在IT领域，我们经常需要处理各种文件，而文件的大小通常用字节（Byte）来衡量，但在实际操作中，为了方便理解和展示，我们会将字节转换为更易读的单位，如千字节（KB）、兆字节（MB）或吉字节（GB）。在易语言中，...

    数据单位KB、MB、GB、TB等简介

    数据单位KB、MB、GB、TB等简介

    如何将B转换成GB、MB和KB

    本篇文章将详细介绍如何将B（字节）转换为GB（吉字节）、MB（兆字节）和KB（千字节），并提供一个程序示例供参考。 首先，了解它们之间的关系是基础。1个字节(B)等于8位(bit)，而更大的单位则基于1024的倍数关系： ...

    计算机存储信息的大小 TB、GB、MB、KB.doc

    以下是关于TB、GB、MB、KB等存储单位的详细解释： 1. 字节（Byte）：字节是最基本的存储单位，通常一个英文字符占用1个字节，而一个汉字通常占用2个字节。字节由8位二进制位（bit）组成。 2. 千字节（KB，Kilobyte...

    jquery_bytes:转换为字节（TB、GB、MB 和字节）

    本篇文章将深入探讨JavaScript中的数据大小单位转换，特别是如何利用jQuery扩展库`jquery_bytes`来实现从TB（太字节）、GB（吉字节）、MB（兆字节）到字节以及反向转换的功能。 `jQuery`是一个广泛使用的JavaScript...

    C#将B转换成GB、MB和KB（字节转换）

    在编程领域，尤其是在处理文件大小或内存占用时，经常需要进行单位转换，例如将字节(B)转换为千字节(KB)，兆字节(MB)或者吉字节(GB)。C#作为.NET框架的主要编程语言，提供了丰富的数学运算支持，使得这种转换变得...

    Java获取磁盘大小

    可以编写一个辅助函数，将字节数转换为更易读的MB、GB或TB。 ```java public static String convertBytesToHumanReadable(long bytes) { final int BYTES_IN_KB = 1024; final int BYTES_IN_MB = BYTES_IN_KB * ...

    计算机容量单位的转换算法

    例如，假设我们需要将一个文件的大小从 MB 转换为 KB，我们可以按照以下公式进行计算： 1 MB = 1024 KB 那么，如果我们需要将一个文件的大小从 GB 转换为 MB，我们可以按照以下公式进行计算： 1 GB = 1024 MB 在...

    进制数转换二进制八进制十进制十六进制之间转换方法PPT学习教案.pptx

    一个字节（byte）等于8个位，1KB等于1024B，1MB等于1024KB，1GB等于1024MB，1TB等于1024GB。 二、进制数的表示法 进制数有四种基本表示法：二进制、八进制、十进制、十六进制。每种进制数都有其特定的表示法和规则...

    PHP实现字节数Byte转换为KB、MB、GB、TB的方法 <font color=red>原创</font>

    主要介绍了PHP实现字节数Byte转换为KB、MB、GB、TB的方法,结合实例形式分析了php针对字节数Byte的换算操作具体实现方法,涉及php数学运算相关函数的使用,需要的朋友可以参考下

    KB,MB,GB,TB,PB,EB,ZB,YB.pdf

    KB,MB,GB,TB,PB,EB,ZB,YB.pdf

    一道java面试题 行列转换

    ### Java面试题：行列转换详解 #### 一、问题背景 在进行数据分析或者报表处理时，经常需要将数据从一种格式转换成另一种格式以便更好地展示或分析。其中一种常见的转换需求是从行转列（即行列转换）。本篇文章将...

    计算机容量转换小例子

    这些单位包括千字节(KB)、兆字节(MB)、吉字节(GB)，甚至可能扩展到更大如太字节(TB)、拍字节(PB)等。了解和掌握这种转换对于理解计算机存储系统以及优化资源使用至关重要。 首先，我们从基础单位开始。1字节(Byte)...

    pretty-bytes-将字节转换为一个人类可读的字符串:1337→1.34kB

    在IT行业中，尤其是在软件开发领域，我们经常需要处理各种数据大小，这可能涉及到字节、KB、MB、GB等单位的转换。`pretty-bytes`是一个非常实用的工具，它能够将字节值转换为更易于人类理解的字符串格式，如在标题中...

    Java上传视频和转码的编程思路

    - 在Java中调用FFmpeg进行转码，需要使用命令行接口或者Java的FFmpeg库（如JAVE、Xuggler等）来执行转换操作，将上传的视频转码为FLV格式，因为Flash播放器支持此格式。 4. **视频关键帧抽图**： - 从视频中抽取...

    二进制与十进制转换PPT学习教案.pptx

    二进制与十进制转换PPT学习教案 一、十进制系统 十进制系统是一种基于10的...本PPT学习教案总结了十进制与二进制的概念、进制转换的方法、数据存储单位等基础知识，为学习计算机科学的学生提供了有价值的参考资料。

Magicbox
Global site tag (gtag.js) - Google Analytics