精华内容
下载资源
问答
  • java计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换) java 硬盘大小转换 数据转换 内存转换 存储大小转换
  • 计算机硬盘大小转换(B,KB,MB,GB,TB,PB之间的大小转换)

    万次阅读 多人点赞 2014-05-27 13:38:18
    多数情况下,一般要求b,kb,mb,gb,tb,pb之间的大小转换,我们都知道他们之间的换算是乘以1024或者除以1024。但是具体怎么用java代码来实现呢?请看下面的代码: package com.herman.utils; /*** * @see 存储...

    程序员都很懒,你懂的!

    java程序员在实际的开发中会遇到很多的单位换算问题。今天我给大家带来的是关于计算机硬盘大小的换算。多数情况下,一般要求b,kb,mb,gb,tb,pb之间的大小转换,我们都知道他们之间的换算是乘以1024或者除以1024。但是具体怎么用java代码来实现呢?请看下面的代码:

    package com.herman.utils;
    
    /***
     * @see 存储大小(单位)转换器.
     * @author Herman.Xiong
     * @date 2014年5月27日 13:27:40
     * @version V1.0
     */
    public enum SizeConverter {
        /** 转换任意单位的大小, 返回结果会包含两位小数但不包含单位. */
        Arbitrary {
            @Override
            public String convert(float size) {
                while (size > 1024) {
                    size /= 1024;
                }
                return String.format(FORMAT_F, size);
            }
        },
        
        // -----------------------------------------------------------------------
        // 有单位
        /** 转换单位为B的大小, 返回结果会包含两位小数以及单位. 如: 1024B->1KB, (1024*1024)B->1MB */
        B {
            @Override
            public String convert(float B) {
                return converter(0, B);
            }
        },
        /** 转换单位为B的大小, 返回结果会包含两位小数以及单位. */
        KB {
            @Override
            public String convert(float KB) {
                return converter(1, KB);
            }
        },
        /** 转换单位为MB的大小, 返回结果会包含两位小数以及单位. */
        MB {
            @Override
            public String convert(float MB) {
                return converter(2, MB);
            }
        },
        /** 转换单位为GB的大小, 返回结果会包含两位小数以及单位. */
        GB {
            @Override
            public String convert(float GB) {
                return converter(3, GB);
            }
        },
        /** 转换单位为TB的大小, 返回结果会包含两位小数以及单位. */
        TB {
            @Override
            public String convert(float TB) {
                return converter(4, TB);
            }
        },
        
        // -----------------------------------------------------------------------
        // trim没单位
        /** 转换任意单位的大小, 返回结果小数部分为0时将去除两位小数, 不包含单位. */
        ArbitraryTrim {
            @Override
            public String convert(float size) {
                while (size > 1024) {
                    size /= 1024;
                }
    
                int sizeInt = (int) size;
                boolean isfloat = size - sizeInt > 0.0F;
                if (isfloat) {
                    return String.format(FORMAT_F, size);
                }
                return String.format(FORMAT_D, sizeInt);
            }
        },
        
        // -----------------------------------------------------------------------
        // trim有单位
        /** 转换单位为B的大小, 返回结果小数部分为0时将去除两位小数, 会包含单位. */
        BTrim {
            @Override
            public String convert(float B) {
                return trimConverter(0, B);
            }
        },
        /** 转换单位为KB的大小, 返回结果小数部分为0时将去除两位小数, 会包含单位. */
        KBTrim {
            @Override
            public String convert(float KB) {
                return trimConverter(1, KB);
            }
        },
        /** 转换单位为MB的大小, 返回结果小数部分为0时将去除两位小数, 会包含单位. */
        MBTrim {
            @Override
            public String convert(float MB) {
                return trimConverter(2, MB);
            }
        },
        /** 转换单位为GB的大小, 返回结果小数部分为0时将去除两位小数, 会包含单位. */
        GBTrim {
            @Override
            public String convert(float GB) {
                return trimConverter(3, GB);
            }
        },
        /** 转换单位为TB的大小, 返回结果小数部分为0时将去除两位小数, 会包含单位. */
        TBTrim {
            @Override
            public String convert(float TB) {
                return trimConverter(4, TB);
            }
        };
        /***
         * <p> 将指定的大小转换到1024范围内的大小. 注意该方法的最大单位为PB, 最小单位为B, 
         * 任何超出该范围的单位最终会显示为**. </p>
         * 
         * @param size 要转换的大小, 注意是浮点数, 不要以整形的方式传入, 容易造成溢出.
         *         (如: 1024*1024*1024*1024*1024会溢出, 使结果为0, 因为它先将结果以int相乘后再转换为float; 
         *         而1024.0F*1024.0F*1024.0F*1024.0F*1024.0F就不会溢出)
         * @return
         */
        abstract public String convert(float size);
        
        // -----------------------------------------------------------------------
        // 单位转换
        
        private static final String[] UNITS = new String[] {
            "B", "KB", "MB", "GB", "TB", "PB", "**"
        };
        
        private static final int LAST_IDX = UNITS.length-1;
        
        private static final String FORMAT_F = "%1$-1.2f";
        private static final String FORMAT_F_UNIT = "%1$-1.2f%2$s";
        
        private static final String FORMAT_D = "%1$-1d";
        private static final String FORMAT_D_UNIT = "%1$-1d%2$s";
        
        // -----------------------------------------------------------------------
        private static String converter(int unit, float size) {
            int unitIdx = unit;
            while (size > 1024) {
                unitIdx++;
                size /= 1024;
            }
            int idx = unitIdx < LAST_IDX ? unitIdx : LAST_IDX;
            return String.format(FORMAT_F_UNIT, size, UNITS[idx]);
        }
        
        private static String trimConverter(int unit, float size) {
            int unitIdx = unit;
            while (size > 1024) {
                unitIdx++;
                size /= 1024;
            }
    
            int sizeInt = (int) size;
            boolean isfloat = size - sizeInt > 0.0F;
            int idx = unitIdx < LAST_IDX ? unitIdx : LAST_IDX;
            if (isfloat) {
                return String.format(FORMAT_F_UNIT, size, UNITS[idx]);
            }
            return String.format(FORMAT_D_UNIT, sizeInt, UNITS[idx]);
        }
        
        // -----------------------------------------------------------------------
        public static String convertBytes(float B, boolean trim) {
            return trim ? trimConvert(0, B, true) : convert(0, B, true);
        }
        
        public static String convertKB(float KB, boolean trim) {
            return trim ? trimConvert(1, KB, true) : convert(1, KB, true);
        }
        
        public static String convertMB(float MB, boolean trim) {
            return trim ? trimConvert(2, MB, true) : convert(2, MB, true);
        }
        
        /***
         * <p> 存储大小单位间的转换. 注意该方法的最大单位为PB, 最小单位为B, 
         * 任何超出该范围的单位最终会显示为**. </p>
         * 
         * @param unit 从哪个单位开始
         * @param size 存储大小, 注意是float, 不要以整形的形式传入, 否则会溢出(如:1024*1024这种,
         * 它是先将1024*1024作为int相乘再转换为float的, 如果值过大的话就会溢出了, 
         * 所以这么写1024.0F*1024.0F)
         * @param withUnit 返回的结果字符串是否带有对应的单位
         * @return
         */
        private static String convert(int unit, float size, boolean withUnit) {
            int unitIdx = unit;
            while (size > 1024) {
                unitIdx++;
                size /= 1024;
            }
            if (withUnit) {
                int idx = unitIdx < LAST_IDX ? unitIdx : LAST_IDX;
                return String.format(FORMAT_F_UNIT, size, UNITS[idx]);
            }
            return String.format(FORMAT_F, size);
        }
        
        /***
         * <p> 存储大小单位间的转换, 如果转换后小数部分为0, 则去除小数部分. 
         * 注意该方法的最大单位为PB, 最小单位为B, 任何超出该范围的单位最终会显示为**. </p>
         * 
         * @param unit 从哪个单位开始
         * @param size 存储大小, 注意是float, 不要以整形的形式传入, 否则会溢出(如:1024*1024这种,
         * 它是先将1024*1024作为int相乘再转换为float的, 如果值过大的话就会溢出了, 
         * 所以这么写1024.0F*1024.0F)
         * @param withUnit 返回的结果字符串是否带有对应的单位
         * @return
         */
        private static String trimConvert(int unit, float size, boolean withUnit) {
            int unitIdx = unit;
            while (size > 1024) {
                unitIdx++;
                size /= 1024;
            }
    
            int sizeInt = (int) size;
            boolean isfloat = size - sizeInt > 0.0F;
            if (withUnit) {
                int idx = unitIdx < LAST_IDX ? unitIdx : LAST_IDX;
                if (isfloat) {
                    return String.format(FORMAT_F_UNIT, size, UNITS[idx]);
                }
                return String.format(FORMAT_D_UNIT, sizeInt, UNITS[idx]);
            }
    
            if (isfloat) {
                return String.format(FORMAT_F, size);
            }
            return String.format(FORMAT_D, sizeInt);
        }
    }
    

    工具类代码写好了,我们来看一个测试类吧,上代码:

    package com.herman.test;
    
    import com.herman.utils.SizeConverter;
    /**
     * @see 硬盘大小换算测试类
     * @author Herman.Xiong
     * @date 2014年5月27日 13:43:33
     */
    public class SizeConverterTest {
    	public static void main(String[] args) {
    		System.out.println(SizeConverter.MBTrim.convert(419562f));
    	}
    }
    
    好了,就到这里了,如果想下载更详细的内容,请 点击下载:http://download.csdn.net/detail/xmt1139057136/7407229

    或者加入QQ群:135430763共同学习!

    展开全文
  • Formatter.formatFileSize(this, Long.valueOf(target_...//工具类 根据文件大小自动转化为KB, MB, GB  private String formatSize(String target_size) {  return Formatter.formatFileSize(activity, Long.valu

    Formatter.formatFileSize(this, Long.valueOf(target_size));//工具类 根据文件大小自动转化为KB, MB, GB  

       private String formatSize(String target_size) {
            return Formatter.formatFileSize(activity, Long.valueOf(target_size));
        }


    formatSize(123456);

    结果:121KB


    formatSize(12345612);

    11.77MB


    formatSize(1234561234);

    结果:1.15GB




    展开全文
  • mysql配置参数调优(8GB内存和64GB内存)

    千次阅读 2019-09-11 22:33:26
    文章目录一、前言二、查看服务器的CPU和内存1、查看CPU的个数2、查看服务器的内存3、数据库版本三、64GB内存的mysql配置参数四、本机8GB内存的mysql配置参数1、查看数据库版本2、具体的配置参数五、总结1、数据库...

    一、前言

          我们新搭建一个LNMP环境之后该如何设置配置文件来达到最佳性能呢?众所周知,mysql的默认配置参数性能是比较底下的,如果我们的服务器配置比较高,那么势必发挥不出来mysql的真正性能。所以,我们必须要设置合适的mysql参数来达到最完美的性能,最起码不能拖了后腿。

    二、查看服务器的CPU和内存

          博主在配置完LNMP之后,也是一时之间有些恍惚,虽然知道要设置mysql的内存参数,设置连接数之类的,但是一时还真不知道该从何处下手。所幸公司有专门的mysql服务器,并且参数都是经过DBA设置过的,性能强劲,不如咱们就参考mysql服务器上的配置,从而对比咱们的服务器配置,设计出适合咱们mysql的一套配置参数。

    下面先查询出来mysql服务器的配置,方便作为对比:

    1、查看CPU的个数

     //查看逻辑CPU的个数
    cat /proc/cpuinfo| grep "processor"| wc -l            
    40
    
     //查看物理CPU的个数
    cat /proc/cpuinfo| grep "physical id"| sort| uniq| wc -l   数
    2
    
    //查看物理CPU的内核数
     cat /proc/cpuinfo | grep "cores" | uniq 		//查看物理CPU的内核数
    cpu cores	: 10
    

    (1)物理cpu数: 主板上实际插入的cpu数量,可以数不重复的 physical id 有几个(physical id)

    (2) cpu核数: 单块CPU上面能处理数据的芯片组的数量,如双核、四核等 (cpu cores)

    (3)逻辑cpu数: 一般情况下,逻辑cpu=物理CPU个数×每颗核数,如果不相等的话,则表示服务器的CPU支持超线程技术(HT:简单来说,它可使处理器中的1 颗内核如2 颗内核那样在操作系统中发挥作用。这样一来,操作系统可使用的执行资源扩大了一倍,大幅提高了系统的整体性能,此时逻辑cpu=物理CPU个数×每颗核数x2

          也就是说,实际用到的核数是:40 /2 = 20核 ,比着上面的10核多,相当于服务器支持CPU超线程技术

    2、查看服务器的内存

    grep MemTotal /proc/meminfo
    MemTotal:       65936452 kB             //大概是62.8G,也就是64G的机器
    

    3、数据库版本

    select version();
    +------------+
    | version()  |
    +------------+
    | 5.6.34-log |
    
    

          OK,根据咱们上面的这些操作,已经知道公司的Mysql服务器配置是:10核64GB内存的。

    三、64GB内存的mysql配置参数

    
    show global variables like 'key_buffer_size';  					256M
    
    show global variables like 'max_allowed_packet';  				32M
    
    show global variables like 'table_open_cache';  				16384	
    
    show global variables like 'sort_buffer_size';  				32M
    
    show global variables like 'net_buffer_length'; 				16384
    
    show global variables like 'read_buffer_size'; 					16M
    
    show global variables like 'read_rnd_buffer_size';				32M
    
    show global variables like 'myisam_sort_buffer_size';			128M  
    (经常需要调用临时表,所以大了一些)
    
    show global variables like 'thread_cache_size';					64
    
    根据物理内存设置规则如下:
    1G ---> 8
    2G ---> 16
    3G ---> 32
    >3G ---> 64
    
    show global variables like 'query_cache_size';					0 
    
    当开启了 Query Cache 之后,尤其是当我们的 query_cache_type 参数设置为 1 以后,
    MySQL 会对每个 SELECT 语句都进行Query Cache 查找,查找操作虽然比较简单,
    但仍然也是要消耗一些 CPU 运算资源的。而由于 Query Cache 的失效机制的特性,
    可能由于表上的数据变化比较频繁,大量的 Query Cache 频繁的被失效,所以 
    Query Cache 的命中率就可能比较低下。所以有些场景下
    ,Query Cache 不仅不能提高效率,反而可能造成负面影响。 
    
    参考:https://blog.csdn.net/u014044812/article/details/78924315
    
    show global variables like 'tmp_table_size';					128M  
    //临时表相关,不常用的话可以小一点
    
    show global variables like 'explicit_defaults_for_timestamp';	ON  
    //是否显示默认时间戳
    
    show global variables like 'max_connections';					100000  
     //最大连接数,并发连接数
    
    show global variables like 'max_connect_errors';				10000000  
    
    show global variables like 'open_files_limit';					500000  
    //mysql打开最大文件数
    
    show global variables like 'expire_logs_days';					10
    启用二进制日志后,保留日志的天数。
    
    show global variables like 'innodb_file_per_table';				ON
    
    
    show global variables like 'innodb_data_file_path';				ibdata1:1G:autoextend
    用来容纳InnoDB为数据表的表空间: 可能涉及一个以上的文件; 每一个表空间文件
    的最大长度都必须以字节(B)、兆字节(MB)或千兆字节(GB)为单位给出; 
    表空间文件的名字必须以分号隔开; 最后一个表空间文件还可以带一个autoextend
    属性和一个最大长度(max:n)。
    
    ===innodb引擎相关配置====
    
    show global variables like 'innodb_buffer_pool_size';           32G
    
    show global variables like 'innodb_log_file_size'; 				4G  
    //事务日志文件写操作缓存区的最大长度
    
    show global variables like 'innodb_log_buffer_size'; 			64M  
    //经常用到事务的场景,这个值应该大一些
    
    show global variables like 'innodb_flush_log_at_trx_commit'; 	2  
    这个参数要配合sync_binlog参数来设置,在设置为:
    innodb_flush_log_at_trx_commit=2 
    sync_binlog=1000
    mysql的写入性能最高,可以参考:https://www.jianshu.com/p/74b03a792ff8
    
    
    show global variables like 'innodb_lock_wait_timeout';			30s
    
    show global  variables like 'back_log';							4096   	
    //参考:https://www.cnblogs.com/angryprogrammer/p/6667741.html
    
    

    注意:以上参数均为博主计算后的数额,通过show variables查出来的数值都是以字节为单位,这块大家自己到时候自己转换一下就行,博文为了方便展示,故而选用MB来展示。

          上面这些参数是影响mysql服务器性能的主要原因,关于这些参数的具体含义,大家可以参考:MariaDB/MySQL配置文件my.cnf解读 ,注释部分只是列出来部分参数的含义,建议是先弄懂各个参数的含义再对比设置会比较好。

    四、本机8GB内存的mysql配置参数

          咱们的服务器是2核8G,当然是不能像专门的数据库服务器一样,绝大部分内存都分配给mysql,由于业务会有大量的连接,所以决定留下一半的内存给mysql,也就是4GB。剩下的4GB内存交给服务器的线程。

    1、查看数据库版本

    MariaDB [(none)]> select version();
    +--------------------------+
    | version()                |
    +--------------------------+
    | 10.1.41-MariaDB-0+deb9u1 |
    +--------------------------+
    

          这个版本具有MySQL 5.65.7的后端和重新实现的功能,可以参考文档:https://mariadb.com/kb/en/library/mariadb-10141-release-notes/
    不过网上有种说法是10.1-35.7对应,也就是说咱们这个版本也是对标的mysql5.7

    2、具体的配置参数

    show global variables like 'key_buffer_size';  		64M 	//默认16M		//64G的机器设置:256M
    
    show global variables like 'max_allowed_packet';  	32M  	// 默认16M		//64G的机器设置:32M
    
    show global variables like 'table_open_cache';  	2048	// 默认2000		//64G的机器设置:16384	
     
    show global variables like 'sort_buffer_size';  	4M		//默认是2M		//64G的机器设置:32M
    
    show global variables like 'net_buffer_length'; 	 16384  //默认16384		//64G的机器设置:16384
    
    show global variables like 'read_buffer_size'; 	   1M       //默认128k		//64G的机器设置:16M
    
    show global variables like 'read_rnd_buffer_size';	512k	//默认256k		//64G的机器设置:32M
    
    show global variables like 'myisam_sort_buffer_size';128M  	//默认128M		//64G的机器设置:128M
    
    show global variables like 'thread_cache_size';		64		//默认8			//64G的机器设置:64
    
    show global variables like 'query_cache_size';	0 			//默认16M		//64G的机器设置:0
    
    show global variables like 'tmp_table_size';		32M  	//默认16M		//64G的机器设置:128M
    
    show xx like 'explicit_defaults_for_timestamp';	 ON		    //默认OFF		//64G的机器设置:ON
    
    show global variables like 'max_connections';		5000 	//默认151		//64G的机器设置:100000
    
    show global variables like 'max_connect_errors';	500000  //默认100		//64G的设置:10000000
    
    show global variables like 'open_files_limit';		65535	//默认4184		//64G的机器设置:500000	
    
    show global variables like 'expire_logs_days';		10		//默认10			//64G的机器设置:10
    
    show global variables like 'innodb_file_per_table';	ON		//默认ON			//64G的机器设置:ON
    
    show global variables like 'innodb_data_file_path';	64M		//默认12M   		//64G的机器设置:1G
    
    ===innodb相关====
    
    show global variables like 'innodb_buffer_pool_size';   2G	//默认128M   	//64G的机器设置:32G
    
    show global variables like 'innodb_log_file_size'; 	256M	//默认48M   		//64G的机器设置:4G
    
    show global variables like 'innodb_log_buffer_size'; 32M	//默认16M   		//64G的机器设置:64M
    
    show xx like 'innodb_flush_log_at_trx_commit'; 		2  		//默认1   		//64G的机器设置:2
    
    show global variables like 'sync_binlog';		1000		//默认0   		//64G的机器设置:1000
    
    show global variables like 'innodb_lock_wait_timeout';30s	//默认50   		//64G的机器设置:30
    
    show global  variables like 'back_log';				500		//默认80			//64G的机器设置:4096
    

    (PS:对齐实在是太难了,这个样式调了老半天。。)

          mysql的参数很多,但主要影响性能的就是上面这些,针对大部分的情况(中小型业务),修改这些设置可以有效提升mysql的性能,其他的设置
    用默认的就可以。关于查看mysql各种性能指标,可以参考:通过查看mysql 配置参数、状态来优化你的mysql

    五、总结

          通过对比可以看到,mysql有些默认的值实在是太小了,根本发挥不出来机器的性能。明明内存那么大,结果却放着不用,这性能也是非常糟糕了。还有innodb_flush_log_at_trx_commitsync_binlog,这两个默认的设置恰恰是写入性能最低的搭配。

    1、数据库偏向于写操作

          具体的配置还是要根据自己数据库的偏好来的,如果数据库用到的事务比较多,那么建议加大事务相关的配置。如果更偏向于写并且表很大的话,要增加表空间大小,并且增加缓冲区大小,同时事务相关的也要大一些,因为每次插入也是要经过事务处理的,主要是innodb_log_file_size参数要设置的大一些。

    2、数据库偏向于读操作

          如果是更偏向于读,那么事务相关的空间可以小一些,table_open_cacheopen_files_limit也可以设置的大一些,当 Mysql 访问一个表时,如果该表在缓存中已经被打开,则可以直接访问缓存。临时表空间可以适当增大,因为大数据量的查询,用到临时表也很正常,还有read_buffer_size等参数也要注意。

    3、补充

    以上更多的是一种大致的建议,设计要设置的参数很多,偏重于读或者写的配置侧重点也是不同的,大家先了解各个配置代表的意思,这样就能设计出最合适自己机器的配置了。

          根据上面的分析,我们可以发现,mysql的性能是根据不同的配置而变化的,并不是单一的调大某个参数,性能就能来个飞速上涨。还是木桶原理,木桶能装多少水,取决的是最短的那个板子,我们只能尽量让板子都均衡一些,尽量多装一些水而已。

    end

    展开全文
  • 获取大小的类型1为B、2为KB、3为MB、4为GB * @return double值的大小 */ public static double getFileOrFilesSize(String filePath, int sizeType) { File file = new File(filePath); long ...
    import java.io.File;
    import java.io.FileInputStream;
    import java.text.DecimalFormat;
    
    /**
     * Created by Administrator on 2018/6/22 0022.
     */
    
    public class FileSizeUtil {
        private static final String TAG=FileSizeUtil.class.getSimpleName();
    
        public static final int SIZETYPE_B = 1;//获取文件大小单位为B的double值
        public static final int SIZETYPE_KB = 2;//获取文件大小单位为KB的double值
        public static final int SIZETYPE_MB = 3;//获取文件大小单位为MB的double值
        public static final int SIZETYPE_GB = 4;//获取文件大小单位为GB的double值
    
        /**
         * 获取文件指定文件的指定单位的大小
         *
         * @param filePath 文件路径
         * @param sizeType 获取大小的类型1为B、2为KB、3为MB、4为GB
         * @return double值的大小
         */
        public static double getFileOrFilesSize(String filePath, int sizeType) {
            File file = new File(filePath);
            long blockSize = 0;
            try {
                if (file.isDirectory()) {
                    blockSize = getFileSizes(file);
                } else {
                    blockSize = getFileSize(file);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return FormetFileSize(blockSize, sizeType);
        }
    
        /**
         * 调用此方法自动计算指定文件或指定文件夹的大小
         *
         * @param filePath 文件路径
         * @return 计算好的带B、KB、MB、GB的字符串
         */
        public static String getAutoFileOrFilesSize(String filePath) {
            File file = new File(filePath);
            long blockSize = 0;
            try {
                if (file.isDirectory()) {
                    blockSize = getFileSizes(file);
                } else {
                    blockSize = getFileSize(file);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return FormetFileSize(blockSize);
        }
    
        /**
         * 获取指定文件大小
         *
         * @param file
         * @return
         * @throws Exception
         */
        private static long getFileSize(File file) throws Exception {
            long size = 0;
            if (file.exists()) {
                FileInputStream fis = null;
                fis = new FileInputStream(file);
                size = fis.available();
            } else {
                file.createNewFile();
            }
            return size;
        }
    
        /**
         * 获取指定文件夹
         *
         * @param f
         * @return
         * @throws Exception
         */
        private static long getFileSizes(File f) throws Exception {
            long size = 0;
            File flist[] = f.listFiles();
            for (int i = 0; i < flist.length; i++) {
                if (flist[i].isDirectory()) {
                    size = size + getFileSizes(flist[i]);
                } else {
                    size = size + getFileSize(flist[i]);
                }
            }
            return size;
        }
    
        /**
         * 转换文件大小
         *
         * @param fileS
         * @return
         */
        private static String FormetFileSize(long fileS) {
            DecimalFormat df = new DecimalFormat("#.00");
            String fileSizeString = "";
            String wrongSize = "0B";
            if (fileS == 0) {
                return wrongSize;
            }
            if (fileS < 1024) {
                fileSizeString = df.format((double) fileS) + "B";
            } else if (fileS < 1048576) {
                fileSizeString = df.format((double) fileS / 1024) + "KB";
            } else if (fileS < 1073741824) {
                fileSizeString = df.format((double) fileS / 1048576) + "MB";
            } else {
                fileSizeString = df.format((double) fileS / 1073741824) + "GB";
            }
            return fileSizeString;
        }
    
        /**
         * 转换文件大小,指定转换的类型
         *
         * @param fileS
         * @param sizeType
         * @return
         */
        private static double FormetFileSize(long fileS, int sizeType) {
            DecimalFormat df = new DecimalFormat("#.00");
            double fileSizeLong = 0;
            switch (sizeType) {
                case SIZETYPE_B:
                    fileSizeLong = Double.valueOf(df.format((double) fileS));
                    break;
                case SIZETYPE_KB:
                    fileSizeLong = Double.valueOf(df.format((double) fileS / 1024));
                    break;
                case SIZETYPE_MB:
                    fileSizeLong = Double.valueOf(df.format((double) fileS / 1048576));
                    break;
                case SIZETYPE_GB:
                    fileSizeLong = Double.valueOf(df.format((double) fileS / 1073741824));
                    break;
                default:
                    break;
            }
            return fileSizeLong;
        }
    }
    
    展开全文
  • 大家好,我是时间财富网智能客服时间君,上述问题将由我为大家进行解答。内存容量一般比外存容量。计算机的内存容量通常是指随机存储器(RAM)...进入21世纪初期,台式机中主流采用的内存容量为2GB或4GB,512MB、256...
  • 32位系统最大只能支持4GB内存之由来

    千次阅读 2018-03-06 13:20:14
    也许大家对这个问题都不陌生,实际装过系统用过电脑的朋友可能都有这样的经历:自己电脑配的是4G的内存条,可是装完系统之后发现电脑上显示的只有3.2G左右可用内存,其它的内存跑到哪去了?网上也有很多朋友给出了...
  • python 文件数据大小 单位 人性化转换: B KB MB GB
  • 为什么32位机器最大只能用到4GB内存

    千次阅读 2016-09-04 15:53:38
    在此之前先来了解一些计算机存储单位之间的关系以及计算机系统结构和PC硬件方面的一些知识。 一、计算机存储单位之间的关系 ...计算机存储单位一般用B,KB,MBGB,TB,PB,EB,ZB,YB,BB来表示,它们之间...
  • 通过 free -m 命令查看系统的内存使用情况,内存大小单位为 MB,执行结果如下图所示: 通过 free -g 命令查看系统的内存使用情况,内存大小单位为 GB,执行结果如下图所示: 二、实际可用内存大小计算 从上方的...
  • 我是根据百分比算的,一个进程135MB内存占用4.5%,这样总内存才4GB,但是我是8G内存啊,64位系统
  • 昨天去QB买了条2GB 内存插到x60上,目前组建3GB非对称双通道,这么多内存,对于pc机似乎可以有很多利用的地方。系统为xp,目前主要找到提升上网性能的几个办法,开机后剩余内存约2GB。 1、关闭系统虚拟内存,目前尚...
  • 【Git学习】解决GitLab内存消耗的问题

    万次阅读 多人点赞 2018-11-20 09:27:42
    这台服务器消耗了31.3GB内存。 然后我11:14分尝试去连接Gitlab服务器,发现要很久很久才连接上。 直到11点18分才登陆成功。 使用 free命令查看了下内存情况,我艹,太猛了吧,使用了60个G,内存只剩2.6G了。 ...
  • 假设某台计算机的内存储器容量为128MB,硬盘容量为10GB,硬盘的容量是内存容量的80倍。硬盘容量的单位为兆字节(MB)或千兆字节(GB),目前的主流硬盘容量为320~1500GB,影响硬盘容量的因素有单碟容量和碟片数量。许多...
  • C#转换文件大小格式(GB/MB/KB/B)

    千次阅读 2015-05-27 15:59:38
    public static string GetString(this HtmlHelper htmlHelper, long b)  {  const int GB = 1024 * 1024 * 1024;  const int MB = 1024 * 1024;  const int KB = 1024;
  • 文章目录目录前文列表内存Linux 的内存大页的实现原理内存配置透明巨型页 THP页面对内存的影响内存的性能问题 前文列表 内存 在页式虚拟存储器中,会在虚拟存储空间和物理主存空间都分割为一...
  • 内存容量大小单位转换

    千次阅读 2019-08-01 10:55:28
    内存容量大小单位转换 B(Byte): 1Byte 等于 8bit KB: 1KB等于1024B MB: 1MB等于1024KB GB: 1GB等于1024MB TB: 1TB等于1024GB PB: 1PB等于1024TB 从到小排序 PB>TB>GB>MB>KB>B ...
  • gc() 转载于:https://www.cnblogs.com/MarsMercury/p/4916997.html
  • MongoDB占用内存频繁宕机

    千次阅读 2020-02-10 22:01:05
    先看一段文档: 从MongoDB 3.4开始,默认的WiredTiger内部缓存大小是以下两者中的较者: ...相反,总内存为1.25 GB的系统将为WiredTiger缓存分配256 MB,因为这是总RAM的一半以上减去1 GB()。 // 4GB 0.5 *...
  • 所谓的 KB MB GB TB 是指内存大小的单位 他们都有 B , 所以先说说B 吧, B是一个电脑存储的基本单位(字节),1个英文字符是1个字节,也就是1B,1个汉字为2个字符,也就是2B。 然后再说 K ,数学学过吧, K 是千的意思, ...
  • 记录MongoDB占用内存

    万次阅读 2020-07-08 17:49:17
    MongoDB为了优化本身的读写效率,将内存当作缓存,所以读写的次数越多,缓存就越。默认值为 50% *(RAM - 1GB)或者 256MB,从MongoDB3.4开始,WiredTiger内部缓存默认使用默认值中较的一个。 解决办法: 修改...
  • Bit、 Byte、KB、MBGB之间的换算

    万次阅读 多人点赞 2018-02-13 12:14:06
    换算1 Byte = 8 Bits(即 1B=8b)1 KB = 1024 Bytes1 MB = 1024 KB1 GB = 1024 MB基本概念Bit意为“位”或“比特”,是计算机运算的基础,属于二进制的范畴;Byte意为“字节”,是计算机文件大小的基本计算单位;这...
  • 32位机最大虚拟内存为4GB。 因为2^32Byte = 4GB. 1)2是怎么来的呢?计算机中识别的是0和1二进制数,不是八进制、十进制等,所以是2^32。 2)4GB = 4*1024 = 4096MB = 4096*1024 = 4194304KB = 4194304*1024 = ...
  • B,MB,KB,GB分别是什么意思?下面给大家详细介绍的是一兆等于多少kb流量,喜欢的朋友可以关注软件自学网学习电脑常识哦!B,MB,KB,GB分别是什么意思?B是一个电脑存储的基本单位(字节),1个英文字符是1个字节,也就是1B,1...
  • HDFS块大小默认为什么是64MB(或者是128MB) 1 HDFS的设计特点? 可以进行超大文件存储 对商用硬件要求不高 式数据访问:适合一次写入,多次读出的场景,适合用来做数据分析,并不适合用来做网盘应用等文件系统...
  • 虚拟内存的最大容量与实际容量区别 1.概念介绍 虚拟内存的最大容量是计算机的地址结构,CPU寻址范围决定的。 虚拟内存的实际容量是=min(内存与外存之和...虚拟内存的实际容量是=min(512MB+2GB, 4GB)=512MB+2GB ...
  • filebeat实践-内存占用-最大内存占用

    千次阅读 2018-04-09 15:52:17
    filebeat作为日志采集agent, 是需要部署到生产服务器上的.不理解filebeat的工作机制,不了解filebeat...有些文章说filebeat内存消耗很少,不会超过100M, 这简直是不负责任的胡说,假如带着这样的认识把filebeat部署到
  • B、KB、MBGB

    千次阅读 2012-06-19 17:20:11
    1TB=1024GB 1GB=1024MB 1MB=1024KB 1KB=1024Byte 注:Byte就是B也就是字节 KB是千字节 MB是兆 GB是千兆 TB是千千兆 一般情况把他们看作是按千进位就行,准确的是1024也就是2的10次方。 储容量的...
  • stm32/Cortex-M3的内存的4GB的存储空间

    千次阅读 2016-11-01 20:33:47
    在0xE0000000到0xFFFFFFFF的512MB的地址存储空间是用于NVIC、MPU及调试组件等使用; 在0xA0000000到0xDFFFFFFF的1GB的地址存储空间是用于片外外设扩展; 在0x60000000到0x9FFFFFFF的1GB的地址存储空间是用于扩展片...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 113,271
精华内容 45,308
关键字:

内存是gb大还是mb大