জাভাতে কীভাবে বাইট আকারকে মানব পাঠযোগ্য বিন্যাসে রূপান্তর করা যায়?

556

জাভাতে কীভাবে বাইট সাইজকে মানব-পঠনযোগ্য ফর্ম্যাটে রূপান্তর করবেন? 1024 এর মতো "1 কেবি" হওয়া উচিত এবং 1024 * 1024 "1 এমবি" হওয়া উচিত।

আমি প্রতিটি প্রকল্পের জন্য এই ইউটিলিটি পদ্ধতিটি লিখতে একরকম অসুস্থ। এটির জন্য অ্যাপাচি কমন্সে কোনও স্থিতিশীল পদ্ধতি আছে ?

java  formatting  apache-commons 
— ইগর মুখিন
সূত্র
32
আপনি যদি মানকযুক্ত ইউনিটগুলি ব্যবহার করেন, 1024 "1KiB" হওয়া উচিত এবং 1024 * 1024 "1MiB" হয়ে উঠতে হবে। en.wikipedia.org/wiki/Binary_prefix
— পাসকাল Cuoq
@ পাসল: বেস এবং ইউনিট নির্দিষ্ট করার জন্য বেশ কয়েকটি ফাংশন বা একটি বিকল্প থাকতে হবে।
— অ্যারন দিগুল্লা
— অ্যারন ডিগুল্লা
3
@ প্যাসাল কুয়াক: রেফারেন্সের জন্য ধন্যবাদ। আমি এটি পড়ার আগে পর্যন্ত বুঝতে পারি নি যে এখানে ইইউতে আমাদের আইন অনুসারে সঠিক উপসর্গ ব্যবহার করা দরকার।
— জেরেমিপি
2
@ ডেরমাইক আপনি উল্লেখ করেছেন যে "এই ধরণের লাইব্রেরি উপস্থিত না হওয়া পর্যন্ত"। এটি এখন সত্য হয়ে উঠেছে। :-) stackoverflow.com/questions/3758606/...
— খ্রিস্টান Esken

উত্তর:

1310

মজাদার ঘটনা: এখানে পোস্ট করা আসল স্নিপেট স্ট্যাক ওভারফ্লোতে সর্বকালের সবচেয়ে অনুলিপি করা জাভা স্নিপেট ছিল এবং এটি ত্রুটিযুক্ত ছিল। এটি ঠিক করা হয়েছিল তবে এটি অগোছালো হয়ে গেছে।

এই নিবন্ধে সম্পূর্ণ গল্প: সর্বকালের সবচেয়ে অনুলিপি করা স্ট্যাকওভারফ্লো স্নিপেট ত্রুটিযুক্ত!

উত্স: বাইট আকারটি মানব পাঠযোগ্য বিন্যাসে ফর্ম্যাট করা Programming.Guide

এসআই (1 কে = 1,000)

public static String humanReadableByteCountSI(long bytes) {
    if (-1000 < bytes && bytes < 1000) {
        return bytes + " B";
    }
    CharacterIterator ci = new StringCharacterIterator("kMGTPE");
    while (bytes <= -999_950 || bytes >= 999_950) {
        bytes /= 1000;
        ci.next();
    }
    return String.format("%.1f %cB", bytes / 1000.0, ci.current());
}

বাইনারি (1 কে = 1,024)

public static String humanReadableByteCountBin(long bytes) {
    long absB = bytes == Long.MIN_VALUE ? Long.MAX_VALUE : Math.abs(bytes);
    if (absB < 1024) {
        return bytes + " B";
    }
    long value = absB;
    CharacterIterator ci = new StringCharacterIterator("KMGTPE");
    for (int i = 40; i >= 0 && absB > 0xfffccccccccccccL >> i; i -= 10) {
        value >>= 10;
        ci.next();
    }
    value *= Long.signum(bytes);
    return String.format("%.1f %ciB", value / 1024.0, ci.current());
}

উদাহরণ আউটপুট:

                              SI     BINARY

                   0:        0 B        0 B
                  27:       27 B       27 B
                 999:      999 B      999 B
                1000:     1.0 kB     1000 B
                1023:     1.0 kB     1023 B
                1024:     1.0 kB    1.0 KiB
                1728:     1.7 kB    1.7 KiB
              110592:   110.6 kB  108.0 KiB
             7077888:     7.1 MB    6.8 MiB
           452984832:   453.0 MB  432.0 MiB
         28991029248:    29.0 GB   27.0 GiB
       1855425871872:     1.9 TB    1.7 TiB
 9223372036854775807:     9.2 EB    8.0 EiB   (Long.MAX_VALUE)
— aioobe
সূত্র
12
আমি 1.0 কেবি পছন্দ করি। তারপরে এটি স্পষ্ট যে আউটপুটটি কতগুলি গুরুত্বপূর্ণ পরিসংখ্যানকে অন্তর্ভুক্ত করে। (এটি duলিনাক্সের কমান্ডের উদাহরণস্বরূপ আচরণ হিসাবেও মনে হয় ))
— আইওউব
19
আমি মনে করি প্রত্যেককে লক্ষ্য করা উচিত যে আপনার প্রকল্পে গ্রাহক বেস 2 (1024 দ্বারা বিভক্ত) এর মান দেখতে চান তবে সাধারণ উপসর্গ সহ। কিবি, এমআইবি, জিআইবি ইত্যাদি নয় এটির জন্য কেবি, এমবি, জিবি, টিবি ব্যবহার করুন।
— বোরিস
27
@ বোরিস "1024 বাইট" বোঝাতে "কেবি" ব্যবহার করা ভুল is এটা করবেন না।
— এন্ডোলিথ
8
পাঠকরা এটি শিখবেন। কোনও কিছুর সাথে তারা অপরিচিত তার চেয়ে ভাল এবং কিছু ভুল হওয়ার চেয়ে এটি শিখতে পারে। কেবি লিখলে এটির সাথে পরিচিত একজন ব্যবহারকারী আশা করবেন 1000 এবং অপরিচিত কোন ব্যবহারকারী 1024 আশা করবেন
— কেপ
16
উত্তর সম্পূর্ণরূপে পুনরায় লিখিত। উপরোক্ত অনেক মন্তব্য অপ্রচলিত।
— আইয়ুব
304

FileUtils.byteCountToDisplaySize(long size)আপনার প্রকল্প নির্ভর করতে পারে যদি কাজ করবে org.apache.commons.io।

এই পদ্ধতির জন্য জাভডোক

— user601806
সূত্র
18
আমার প্রকল্পটিতে ইতিমধ্যে কমন্স-আইও রয়েছে, তবে রাউন্ডিং আচরণের কারণে আইভাবের কোড ব্যবহার করে শেষ হয়েছে (
— জাভাডকের
3
বিপরীতমুখী অপারেশন করার কি কোনও ইউটিলিটি আছে? মানব পাঠযোগ্য বাইট গণনা থেকে বাইট গণনা পাচ্ছেন?
— অরুনমোজি
6
দুর্ভাগ্যক্রমে এই ফাংশন স্থানীয়ভাবে সচেতন নয়; ফরাসি ভাষায়, উদাহরণস্বরূপ, তারা সর্বদা বাইটগুলিকে "অক্টেটস" বলে ডাকে তাই আপনি যদি কোনও ফরাসী ব্যবহারকারীর কাছে 100 কেবি ফাইল প্রদর্শন করতে যাচ্ছেন তবে সঠিক লেবেলটি 100 কো হবে।
— ট্যাক্রয়
@ ট্যাক্রয় আপনি ত্রিভা লাইব্রেরিতে ইউনিটফর্মেটরের সাথে অক্টেটস আউটপুট পেতে পারেন। আপনি বাইটস, ওয়াটস বা অক্টেটের জন্য যে কোনও ইউনিট পাস করতে পারেন। উদাহরণ, github.com/trivago/triava- এর উদাহরণ থেকে কিছুটা সংশোধন করা হয়েছে : ইউনিট ফর্ম্যাটর.ফর্ম্যাট এএসইউনিত (1126, ইউনিটসিস্টেম.এসআই, "ও"); // = "1.13 কো" আরো উদাহরণ: stackoverflow.com/questions/3758606/...
— খ্রিস্টান Esken
5
এই
— গোলটি নিকটতম জিবিতে পৌঁছে যায়
180

অ্যান্ড্রয়েড বিল্টিন ক্লাস ব্যবহার করুন

অ্যান্ড্রয়েডের জন্য একটি শ্রেণির ফর্ম্যাটর রয়েছে । কোডের এক লাইন এবং আপনার কাজ শেষ।

android.text.format.Formatter.formatShortFileSize(activityContext, bytes);

এটি এর মতো formatFileSize(), তবে সংক্ষিপ্ত সংখ্যা উত্পন্ন করার চেষ্টা করছে (কম দশমিক দেখায়)।

android.text.format.Formatter.formatFileSize(activityContext, bytes);

কোনও সামগ্রীর আকার বাইটস, কিলোবাইট, মেগাবাইটস ইত্যাদি আকারে ফর্ম্যাট করে

— AZ_
সূত্র
12
অ্যান্ড্রয়েডের জন্য অবশ্যই যথাযথ উত্তর হওয়া উচিত। কোনও অতিরিক্ত লাইব্রেরির প্রয়োজন নেই। +1
— ডাইটার
11
আমি আপনাকে পাস করতে হবে সত্য আমি ঘৃণা করি Context।
— জ্যারেড বুরোজ
4
অ্যান্ড্রয়েডের জন্য অবশ্যই যথাযথ উত্তর হওয়া উচিত।
— শ্রীদত্ত কোঠারি
5
আপনি প্রসঙ্গে পাস করুন যাতে এটি ব্যবহারকারীর বর্তমান লোকালে অনুবাদ হয়। অন্যথায় এটি খুব কার্যকর ফাংশন হবে না।
— ফ্রেইকহেড
7
এটি জানার আগে আমি স্বীকৃত উত্তরটি ব্যবহার করছিলাম। কেবল লক্ষণীয়ভাবে, বিল্ডে ERS VERSION_CODES.N এবং এর আগে, 1024 এর পাওয়ারগুলি পরিবর্তে KB = 1024 বাইট, এমবি = 1,048,576 বাইট ইত্যাদির সাহায্যে ব্যবহৃত হয় O , তাই ইত্যাদি kB র = 1000 বাইট, মেগাবাইট = 1,000,000 বাইট,
— HendraWD
57

আমরা ইউনিটগুলির মধ্যে ফ্যাক্টর (যেমন বি, কেবি, এমবি ইত্যাদি) 1024 যা 2 ^ 10 হয় এর ফলে সরলতার ত্যাগ ছাড়াই ধীর Math.pow()এবং Math.log()পদ্ধতিগুলি সম্পূর্ণভাবে এড়াতে পারি । Longবর্গ একটি সহজ হয়েছে numberOfLeadingZeros()পদ্ধতি যা আমরা বলতে যা ইউনিট আকার মান পড়ে ব্যবহার করতে পারেন।

মূল বক্তব্য: আকারের ইউনিটগুলির মধ্যে 10 বিট (1024 = 2 ^ 10) এর দূরত্ব রয়েছে যার অর্থ সর্বোচ্চ 1 বিটের অবস্থান - বা অন্য কথায় নেতৃস্থানীয় শূন্যগুলির সংখ্যা 10 দ্বারা পৃথক হয় (বাইটস = কেবি * 1024, কেবি = এমবি) * 1024 ইত্যাদি)।

শীর্ষস্থানীয় শূন্য এবং আকারের ইউনিটের মধ্যে সম্পর্ক:

# of leading 0's   Size unit
-------------------------------
>53                B (Bytes)
>43                KB
>33                MB
>23                GB
>13                TB
>3                 PB
<=2                EB

চূড়ান্ত কোড:

public static String formatSize(long v) {
    if (v < 1024) return v + " B";
    int z = (63 - Long.numberOfLeadingZeros(v)) / 10;
    return String.format("%.1f %sB", (double)v / (1L << (z*10)), " KMGTPE".charAt(z));
}
— icza
সূত্র
24

আমি সম্প্রতি একই প্রশ্নটি জিজ্ঞাসা করেছি:

এমবি, জিবি ইত্যাদি হিসাবে ফর্ম্যাট ফাইলের আকার

বাক্সের বাইরে উত্তর না থাকলেও আমি সমাধানটি নিয়ে বেঁচে থাকতে পারি:

private static final long K = 1024;
private static final long M = K * K;
private static final long G = M * K;
private static final long T = G * K;

public static String convertToStringRepresentation(final long value){
    final long[] dividers = new long[] { T, G, M, K, 1 };
    final String[] units = new String[] { "TB", "GB", "MB", "KB", "B" };
    if(value < 1)
        throw new IllegalArgumentException("Invalid file size: " + value);
    String result = null;
    for(int i = 0; i < dividers.length; i++){
        final long divider = dividers[i];
        if(value >= divider){
            result = format(value, divider, units[i]);
            break;
        }
    }
    return result;
}

private static String format(final long value,
    final long divider,
    final String unit){
    final double result =
        divider > 1 ? (double) value / (double) divider : (double) value;
    return new DecimalFormat("#,##0.#").format(result) + " " + unit;
}

পরীক্ষার কোড:

public static void main(final String[] args){
    final long[] l = new long[] { 1l, 4343l, 43434334l, 3563543743l };
    for(final long ll : l){
        System.out.println(convertToStringRepresentation(ll));
    }
}

আউটপুট (আমার জার্মান লোকালে):

1 B
4,2 KB
41,4 MB
3,3 GB

সম্পাদনা করুন: আমি গুগল পেয়ারার জন্য এই কার্যকারিতাটির অনুরোধ করে একটি সমস্যা খুলেছি । সম্ভবত কেউ এটি সমর্থন যত্ন নেবে।

— শন প্যাট্রিক ফ্লয়েড
সূত্র
2
কেন 0 টি একটি অবৈধ ফাইল-আকার?
— আইয়ুব
@ আইউব এটি আমার ব্যবহারের ক্ষেত্রে ছিল (একটি আপলোড করা ফাইলের আকার প্রদর্শন করে) তবে তর্কাতীতভাবে এটি সর্বজনীন নয়
— সান প্যাট্রিক ফ্লয়েড
আপনি যদি নম্বরটি ফরম্যাট.গ্যাট ফরমেট ("#, ## 0। #") ফর্ম্যাট (ফলাফল) + "" + ইউনিট ফেরানোর জন্য শেষ লাইনটি পরিবর্তন করেন; এটি জিডব্লিউটিতেও কাজ করে! এর জন্য ধন্যবাদ, এটি এখনও পেয়ারাতে নেই।
— tom
9

এটি আইওবের উত্তরের পরিবর্তিত সংস্করণ ।

পরিবর্তন করুন:

  • Localeপরামিতি, কারণ কিছু কিছু ভাষায় ব্যবহার .এবং অন্যদের ,দশমিক বিন্দু হিসাবে।
  • মানব-পঠনযোগ্য কোড 
private static final String[] SI_UNITS = { "B", "kB", "MB", "GB", "TB", "PB", "EB" };
private static final String[] BINARY_UNITS = { "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB" };

public static String humanReadableByteCount(final long bytes, final boolean useSIUnits, final Locale locale)
{
    final String[] units = useSIUnits ? SI_UNITS : BINARY_UNITS;
    final int base = useSIUnits ? 1000 : 1024;

    // When using the smallest unit no decimal point is needed, because it's the exact number.
    if (bytes < base) {
        return bytes + " " + units[0];
    }

    final int exponent = (int) (Math.log(bytes) / Math.log(base));
    final String unit = units[exponent];
    return String.format(locale, "%.1f %s", bytes / Math.pow(base, exponent), unit);
}
— খ্রিস্টান স্ট্র্যাম্পার
সূত্র
কেবল পৃথককারী প্রতীকগুলির জন্য লোকেল প্যারামিটারটি পেরিয়ে যাওয়ার জন্য এটি কিছুটা মিশ্র ফলাফল but
— Nzall
@ নাজাল আপনি কি অক্টেট বলতে চান? উইকিপিডিয়া জানিয়েছে যে এটি আর সাধারণ নেই। অন্যথায়, আপনি একটি রেফারেন্স আছে?
— ক্রিশ্চিয়ান স্ট্র্যাম্পার
7

আপনি যদি অ্যান্ড্রয়েড ব্যবহার করেন তবে আপনি সহজেই android.text.format . Formatter.formatFileSize () ব্যবহার করতে পারেন ।

বিকল্প, এখানে এই জনপ্রিয় পোস্টের উপর ভিত্তি করে একটি সমাধান :

  /**
   * formats the bytes to a human readable format
   *
   * @param si true if each kilo==1000, false if kilo==1024
   */
  @SuppressLint("DefaultLocale")
  public static String humanReadableByteCount(final long bytes,final boolean si)
    {
    final int unit=si ? 1000 : 1024;
    if(bytes<unit)
      return bytes+" B";
    double result=bytes;
    final String unitsToUse=(si ? "k" : "K")+"MGTPE";
    int i=0;
    final int unitsCount=unitsToUse.length();
    while(true)
      {
      result/=unit;
      if(result<unit)
        break;
      // check if we can go further:
      if(i==unitsCount-1)
        break;
      ++i;
      }
    final StringBuilder sb=new StringBuilder(9);
    sb.append(String.format("%.1f ",result));
    sb.append(unitsToUse.charAt(i));
    if(si)
      sb.append('B');
    else sb.append('i').append('B');
    final String resultStr=sb.toString();
    return resultStr;
    }

বা কোটলিনে:

/**
 * formats the bytes to a human readable format
 *
 * @param si true if each kilo==1000, false if kilo==1024
 */
@SuppressLint("DefaultLocale")
fun humanReadableByteCount(bytes: Long, si: Boolean): String? {
    val unit = if (si) 1000.0 else 1024.0
    if (bytes < unit)
        return "$bytes B"
    var result = bytes.toDouble()
    val unitsToUse = (if (si) "k" else "K") + "MGTPE"
    var i = 0
    val unitsCount = unitsToUse.length
    while (true) {
        result /= unit
        if (result < unit || i == unitsCount - 1)
            break
        ++i
    }
    return with(StringBuilder(9)) {
        append(String.format("%.1f ", result))
        append(unitsToUse[i])
        if (si) append('B') else append("iB")
    }.toString()
}
— অ্যান্ড্রয়েড বিকাশকারী
সূত্র
আপনার লুপে আপ-ও-ওয়ান ত্রুটি রয়েছে বলে মনে হচ্ছে। আমি মনে করি এটি হওয়া উচিত unitsCountএবং না হওয়া উচিত unitsCount-1।
— আইওউব
@ আইউব তবে এর অর্থ লুপটি থামতে পারে যখন আমি == ইউনিটসাউন্ট, যার অর্থ আমি ==,, যার অর্থ "চারআউট" ব্যর্থ হবে ...
— অ্যান্ড্রয়েড বিকাশকারী
if(result<unit) break;তার আগে লাথি মারবে। কোন চিন্তা করো না. (আপনি যদি এটি পরীক্ষা করেন তবে লক্ষ্য করবেন যে আপনি লুপের অবস্থাটি পুরোপুরি এড়িয়ে যেতে পারেন))
— আইওব
@ আইউব সঠিক, এটি অনুমানের কারণে (যা সঠিক) আমি "দীর্ঘ" পরিবর্তনশীল প্রকারটি পরিচালনা করি। এছাড়াও, এটি ইউনিটগুলি কমপক্ষে আমি যা লিখেছি তা হবে এই ধারণার উপর ভিত্তি করে। আপনি যদি কম ইউনিট ব্যবহার করেন তবে এটি অদ্ভুত ফলাফল আনবে (1000-এর চেয়ে বেশি মানের চেয়ে 1-এর চেয়ে কম মান পছন্দ করবে)।
— অ্যান্ড্রয়েড বিকাশকারী 13
@ আইউব সঠিক আমি এটা ঠিক করব. বিটিডাব্লু, আপনার অ্যালগোরিদম একটি অদ্ভুত ফলাফলও সরবরাহ করতে পারে। আর্গুমেন্ট হিসাবে এটি "999999, সত্য" দেওয়ার চেষ্টা করুন। এটি "1000.0 কেবি" প্রদর্শন করবে, সুতরাং এটি বৃত্তাকার, তবে লোকেরা এটি দেখলে অবাক হতে পারে: কেন এটি 1 এমবি, 1000 কেবি = 1 এমবি হিসাবে দেখাতে পারে না ... আপনি কীভাবে মনে করেন এটি পরিচালনা করা উচিত? এটি স্ট্রিং.ফর্ম্যাট এর কারণে, তবে কীভাবে এটি ঠিক করা উচিত তা আমি নিশ্চিত নই।
— অ্যান্ড্রয়েড বিকাশকারী
6 

private static final String[] Q = new String[]{"", "K", "M", "G", "T", "P", "E"};

public String getAsString(long bytes)
{
    for (int i = 6; i > 0; i--)
    {
        double step = Math.pow(1024, i);
        if (bytes > step) return String.format("%3.1f %s", bytes / step, Q[i]);
    }
    return Long.toString(bytes);
}
— লার্স বোহল
সূত্র
6 
  private String bytesIntoHumanReadable(long bytes) {
        long kilobyte = 1024;
        long megabyte = kilobyte * 1024;
        long gigabyte = megabyte * 1024;
        long terabyte = gigabyte * 1024;

        if ((bytes >= 0) && (bytes < kilobyte)) {
            return bytes + " B";

        } else if ((bytes >= kilobyte) && (bytes < megabyte)) {
            return (bytes / kilobyte) + " KB";

        } else if ((bytes >= megabyte) && (bytes < gigabyte)) {
            return (bytes / megabyte) + " MB";

        } else if ((bytes >= gigabyte) && (bytes < terabyte)) {
            return (bytes / gigabyte) + " GB";

        } else if (bytes >= terabyte) {
            return (bytes / terabyte) + " TB";

        } else {
            return bytes + " Bytes";
        }
    }
— সুজিথ মানজাবনা
সূত্র
আমি এটি পছন্দ করি কারণ এটি অনুসরণ করা সহজ এবং বুঝতে সহজ।
— জোশুয়া পিন্টার
6

বাইট ইউনিটগুলি আপনাকে এটি এমনভাবে করার অনুমতি দেয়:

long input1 = 1024;
long input2 = 1024 * 1024;

Assert.assertEquals("1 KiB", BinaryByteUnit.format(input1));
Assert.assertEquals("1 MiB", BinaryByteUnit.format(input2));

Assert.assertEquals("1.024 KB", DecimalByteUnit.format(input1, "#.0"));
Assert.assertEquals("1.049 MB", DecimalByteUnit.format(input2, "#.000"));

NumberFormat format = new DecimalFormat("#.#");
Assert.assertEquals("1 KiB", BinaryByteUnit.format(input1, format));
Assert.assertEquals("1 MiB", BinaryByteUnit.format(input2, format));

আমি স্টোরেজ-ইউনিট নামে একটি অন্য লাইব্রেরি লিখেছি যা আপনাকে এটির মতো এটি করতে দেয়:

String formattedUnit1 = StorageUnits.formatAsCommonUnit(input1, "#");
String formattedUnit2 = StorageUnits.formatAsCommonUnit(input2, "#");
String formattedUnit3 = StorageUnits.formatAsBinaryUnit(input1);
String formattedUnit4 = StorageUnits.formatAsBinaryUnit(input2);
String formattedUnit5 = StorageUnits.formatAsDecimalUnit(input1, "#.00", Locale.GERMAN);
String formattedUnit6 = StorageUnits.formatAsDecimalUnit(input2, "#.00", Locale.GERMAN);
String formattedUnit7 = StorageUnits.formatAsBinaryUnit(input1, format);
String formattedUnit8 = StorageUnits.formatAsBinaryUnit(input2, format);

Assert.assertEquals("1 kB", formattedUnit1);
Assert.assertEquals("1 MB", formattedUnit2);
Assert.assertEquals("1.00 KiB", formattedUnit3);
Assert.assertEquals("1.00 MiB", formattedUnit4);
Assert.assertEquals("1,02 kB", formattedUnit5);
Assert.assertEquals("1,05 MB", formattedUnit6);
Assert.assertEquals("1 KiB", formattedUnit7);
Assert.assertEquals("1 MiB", formattedUnit8);

আপনি যদি কোনও নির্দিষ্ট ইউনিটকে জোর করতে চান তবে এটি করুন:

String formattedUnit9 = StorageUnits.formatAsKibibyte(input2);
String formattedUnit10 = StorageUnits.formatAsCommonMegabyte(input2);

Assert.assertEquals("1024.00 KiB", formattedUnit9);
Assert.assertEquals("1.00 MB", formattedUnit10);
— সেবাস্তিয়ান হো ß
সূত্র
5 
    public static String floatForm (double d)
    {
       return new DecimalFormat("#.##").format(d);
    }


    public static String bytesToHuman (long size)
    {
        long Kb = 1  * 1024;
        long Mb = Kb * 1024;
        long Gb = Mb * 1024;
        long Tb = Gb * 1024;
        long Pb = Tb * 1024;
        long Eb = Pb * 1024;

        if (size <  Kb)                 return floatForm(        size     ) + " byte";
        if (size >= Kb && size < Mb)    return floatForm((double)size / Kb) + " Kb";
        if (size >= Mb && size < Gb)    return floatForm((double)size / Mb) + " Mb";
        if (size >= Gb && size < Tb)    return floatForm((double)size / Gb) + " Gb";
        if (size >= Tb && size < Pb)    return floatForm((double)size / Tb) + " Tb";
        if (size >= Pb && size < Eb)    return floatForm((double)size / Pb) + " Pb";
        if (size >= Eb)                 return floatForm((double)size / Eb) + " Eb";

        return "???";
    }
— XXX এর
সূত্র
3

এখন একটি গ্রন্থাগার পাওয়া যাচ্ছে যা ইউনিট ফর্ম্যাটিং রয়েছে। আমি এটিকে ত্রিভা লাইব্রেরিতে যুক্ত করেছি, যেহেতু কেবলমাত্র অন্যান্য বিদ্যমান লাইব্রেরি অ্যান্ড্রয়েডের জন্য একটি বলে মনে হয়।

এটি 3 টি পৃথক সিস্টেমে (এসআই, আইইসি, জেইডিসি) এবং বিভিন্ন আউটপুট বিকল্পে নির্বিচারে নির্ভুলতার সাথে সংখ্যার ফর্ম্যাট করতে পারে। এখানে ত্রিভা ইউনিট পরীক্ষার কয়েকটি কোড উদাহরণ রয়েছে :

UnitFormatter.formatAsUnit(1126, UnitSystem.SI, "B");
// = "1.13kB"
UnitFormatter.formatAsUnit(2094, UnitSystem.IEC, "B");
// = "2.04KiB"

সঠিক কিলো, মেগা মানগুলি মুদ্রণ করা হচ্ছে (এখানে ডাব্লু = ওয়াটের সাথে):

UnitFormatter.formatAsUnits(12_000_678, UnitSystem.SI, "W", ", ");
// = "12MW, 678W"

আউটপুট কাস্টমাইজ করতে আপনি একটি দশমিক ফর্ম্যাটটি পাস করতে পারেন:

UnitFormatter.formatAsUnit(2085, UnitSystem.IEC, "B", new DecimalFormat("0.0000"));
// = "2.0361KiB"

কিলো বা মেগা মানগুলিতে স্বেচ্ছাসেবক ক্রিয়াকলাপের জন্য আপনি এগুলিকে উপাদানগুলিতে বিভক্ত করতে পারেন:

UnitComponent uc = new  UnitComponent(123_345_567_789L, UnitSystem.SI);
int kilos = uc.kilo(); // 567
int gigas = uc.giga(); // 123
— খ্রিস্টান এস্কেন
সূত্র
2

আমি জানি এই পোস্টটি আপডেট করতে খুব দেরী হয়েছে! তবে আমি এটি দিয়ে কিছু মজা করেছি:

একটি ইন্টারফেস তৈরি করুন:

public interface IUnits {
     public String format(long size, String pattern);
     public long getUnitSize();
}

স্টোরেজউনিট ক্লাস তৈরি করুন:

import java.text.DecimalFormat;

public class StorageUnits {
private static final long K = 1024;
private static final long M = K * K;
private static final long G = M * K;
private static final long T = G * K;

enum Unit implements IUnits {
    TERA_BYTE {
        @Override
        public String format(long size, String pattern) {
            return format(size, getUnitSize(), "TB", pattern);
        }
        @Override
        public long getUnitSize() {
            return T;
        }
        @Override
        public String toString() {
            return "Terabytes";
        }
    },
    GIGA_BYTE {
        @Override
        public String format(long size, String pattern) {
            return format(size, getUnitSize(), "GB", pattern);
        }
        @Override
        public long getUnitSize() {
            return G;
        }
        @Override
        public String toString() {
            return "Gigabytes";
        }
    },
    MEGA_BYTE {
        @Override
        public String format(long size, String pattern) {
            return format(size, getUnitSize(), "MB", pattern);
        }
        @Override
        public long getUnitSize() {
            return M;
        }
        @Override
        public String toString() {
            return "Megabytes";
        }
    },
    KILO_BYTE {
        @Override
        public String format(long size, String pattern) {
            return format(size, getUnitSize(), "kB", pattern);
        }
        @Override
        public long getUnitSize() {
            return K;
        }
        @Override
        public String toString() {
            return "Kilobytes";
        }

    };
    String format(long size, long base, String unit, String pattern) {
        return new DecimalFormat(pattern).format(
                Long.valueOf(size).doubleValue() / Long.valueOf(base).doubleValue()
        ) + unit;
    }
}

public static String format(long size, String pattern) {
    for(Unit unit : Unit.values()) {
        if(size >= unit.getUnitSize()) {
            return unit.format(size, pattern);
        }
    }
    return ("???(" + size + ")???");
}

public static String format(long size) {
    return format(size, "#,##0.#");
}
}

ডাকা:

class Main {
    public static void main(String... args) {
         System.out.println(StorageUnits.format(21885));
         System.out.println(StorageUnits.format(2188121545L));
    }
}

আউটপুট:

21.4kB
2GB
— আহমদ আলমুগ্রাবি
সূত্র
2

অফ-সুযোগে এটি কাউকে কিছুটা সময় সাশ্রয় দেয় বা সম্ভবত কিছুটা মজা করার জন্য, এখানে একটি গো সংস্করণ। সরলতার জন্য, আমি কেবল বাইনারি আউটপুট কেস অন্তর্ভুক্ত করেছি।

func sizeOf(bytes int64) string {
    const unit = 1024
    if bytes < unit {
        return fmt.Sprintf("%d B", bytes)
    }

    fb := float64(bytes)
    exp := int(math.Log(fb) / math.Log(unit))
    pre := "KMGTPE"[exp-1]
    div := math.Pow(unit, float64(exp))
    return fmt.Sprintf("%.1f %ciB", fb / div, pre)
}
— রিক-777
সূত্র
1 
String[] fileSizeUnits = {"bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
public String calculateProperFileSize(double bytes){
    String sizeToReturn = "";
    int index = 0;
    for(index = 0; index < fileSizeUnits.length; index++){
        if(bytes < 1024){
            break;
        }
        bytes = bytes / 1024;
    }

কেবলমাত্র আরও ফাইল ইউনিট যুক্ত করুন (যদি কোনও অনুপস্থিত থাকে), এবং আপনি সেই ইউনিট পর্যন্ত ইউনিট আকার দেখতে পাবেন (যদি আপনার ফাইলের এত দৈর্ঘ্য থাকে) System.out.println ("সঠিক ফর্ম্যাটে ফাইলের আকার:" + বাইট + "" + ফাইলসাইজ ইউনাইটস [INDEX]); সাইজটোরিটেন = স্ট্রিং.ভ্যালুওফ (বাইটস) + "" + ফাইলসাইজ ইউনাইটস [সূচক]; রিটার্ন আকার }

— বিশ্বজিৎ আর শিন্ডে
সূত্র
1

উপরে জাভা সঠিক sensকমত্য উত্তর জন্য সি #। নেট সমতুল্য। (নীচে আরও একটি সংক্ষিপ্ত কোড রয়েছে)

    public static String BytesNumberToHumanReadableString(long bytes, bool SI1000orBinary1024)
    {

        int unit = SI1000orBinary1024 ? 1000 : 1024;
        if (bytes < unit) return bytes + " B";
        int exp = (int)(Math.Log(bytes) / Math.Log(unit));
        String pre = (SI1000orBinary1024 ? "kMGTPE" : "KMGTPE")[(exp - 1)] + (SI1000orBinary1024 ? "" : "i");
        return String.Format("{0:F1} {1}B", bytes / Math.Pow(unit, exp), pre);
    }

প্রযুক্তিগতভাবে বলতে গেলে, আমরা যদি এসআই ইউনিটগুলিতে লেগে থাকি তবে এই রুটিনটি কোনও নিয়মিত সংখ্যার ব্যবহারের জন্য কাজ করে। বিশেষজ্ঞদের আরও অনেক ভাল উত্তর রয়েছে। মনে করুন আপনি গ্রিডভিউগুলিতে সংখ্যার ডেটাবাইন্ডিং করছেন, সেগুলি থেকে পারফরম্যান্স অপ্টিমাইজড রুটিনগুলি পরীক্ষা করা তার পক্ষে মূল্য।

পিএস: পোস্ট করা হয়েছে কারণ আমি সি # প্রকল্পের সময় এই প্রশ্ন / উত্তরটি গুগল অনুসন্ধানে শীর্ষে এসেছি।

— চ্যান ফান চিয়াট
সূত্র
1

আপনি ব্যবহার করতে পারেন StringUtils এর TraditionalBinarPrefix:

public static String humanReadableInt(long number) {
    return TraditionalBinaryPrefix.long2String(number,””,1);
}
— জো
সূত্র
1

কিছুটা পুরানো তবে, ... org.springframework.util.unit.DataSize কমপক্ষে গণনার জন্য এই পুনরুক্তিটির জন্য স্যুট করতে পারে, তবে একটি সাধারণ সাজসজ্জা করতে হবে

— Tama
সূত্র
0 
filename=filedilg.getSelectedFile().getAbsolutePath();
File file=new File(filename);

String disp=FileUtils.byteCountToDisplaySize(file.length());
System.out.println("THE FILE PATH IS "+file+"THIS File SIZE IS IN MB "+disp);
— মনো চেল্লা
সূত্র
এই উত্তরটি, যখন এটি কাজ করে, @ user601806 দ্বারা এই থ্রেড পূর্ববর্তী উত্তর একটি পরিপূরক: stackoverflow.com/a/4888400/3987745 কাজ এই উত্তরের জন্য আপনার যা দরকার এ্যাপাচি কমন্স আই ( commons.apache.org/proper/ কমন্স-আইও ) নির্ভরতা।
— এডওয়ার্ড কুইক্সোট
0

আপনি জেএসআর 363 চেষ্টা করেছেন ? এর ইউনিট এক্সটেনশন মডিউলগুলির মতো ইউনিকোড সিএলডিআর ( গিটহাব: ইউওম-সিস্টেমগুলিতে ) আপনার জন্য যা কিছু করে।

আপনি MetricPrefixপ্রতিটি বাস্তবায়নে অন্তর্ভুক্ত ব্যবহার করতে পারেন বা BinaryPrefix(উপরের কয়েকটি উদাহরণের সাথে তুলনীয়) এবং যদি আপনি যেমন ভারতে বা নিকটবর্তী দেশে বাস করেন এবং কাজ করেন, IndianPrefix(এছাড়াও ইউওম-সিস্টেমগুলির সাধারণ মডিউলটিতে) আপনাকে "কোটি টাকার ব্যবহার এবং বিন্যাস করতে দেয় বাইটস "বা" লাখ বাইটস "।

— ওয়ার্নার কেইল
সূত্র
0

হতে পারে আপনি এই কোডটি ব্যবহার করতে পারেন (সি # তে):

        long Kb = 1024;
        long Mb = Kb * 1024;
        long Gb = Mb * 1024;
        long Tb = Gb * 1024;
        long Pb = Tb * 1024;
        long Eb = Pb * 1024;

        if (size < Kb) return size.ToString() + " byte";
        if (size < Mb) return (size / Kb).ToString("###.##") + " Kb.";
        if (size < Gb) return (size / Mb).ToString("###.##") + " Mb.";
        if (size < Tb) return (size / Gb).ToString("###.##") + " Gb.";
        if (size < Pb) return (size / Tb).ToString("###.##") + " Tb.";
        if (size < Eb) return (size / Pb).ToString("###.##") + " Pb.";
        if (size >= Eb) return (size / Eb).ToString("###.##") + " Eb.";

        return "invalid size";
— জ্যাকস মোরেইস
সূত্র
0 
public String humanReadable(long size) {
    long limit = 10 * 1024;
    long limit2 = limit * 2 - 1;
    String negative = "";
    if(size < 0) {
        negative = "-";
        size = Math.abs(size);
    }

    if(size < limit) {
        return String.format("%s%s bytes", negative, size);
    } else {
        size = Math.round((double) size / 1024);
        if (size < limit2) {
            return String.format("%s%s kB", negative, size);
        } else {
            size = Math.round((double)size / 1024);
            if (size < limit2) {
                return String.format("%s%s MB", negative, size);
            } else {
                size = Math.round((double)size / 1024);
                if (size < limit2) {
                    return String.format("%s%s GB", negative, size);
                } else {
                    size = Math.round((double)size / 1024);
                        return String.format("%s%s TB", negative, size);
                }
            }
        }
    }
}
— সামকভ ম্যাক্স
সূত্র
0

সঠিক তথ্য পেতে নিম্নলিখিত ফাংশনটি ব্যবহার করুন, ATM_CashWithdrawlধারণাটির ভিত্তি গ্রহণ করে উত্পন্ন হয়েছে ।

getFullMemoryUnit(): Total: [123 MB], Max: [1 GB, 773 MB, 512 KB], Free: [120 MB, 409 KB, 304 Bytes]
public static String getFullMemoryUnit(long unit) {
    long BYTE = 1024, KB = BYTE, MB = KB * KB, GB = MB * KB, TB = GB * KB;
    long KILO_BYTE, MEGA_BYTE = 0, GIGA_BYTE = 0, TERA_BYTE = 0;
    unit = Math.abs(unit);
    StringBuffer buffer = new StringBuffer();
    if ( unit / TB > 0 ) {
        TERA_BYTE = (int) (unit / TB);
        buffer.append(TERA_BYTE+" TB");
        unit -= TERA_BYTE * TB;
    }
    if ( unit / GB > 0 ) {
        GIGA_BYTE = (int) (unit / GB);
        if (TERA_BYTE != 0) buffer.append(", ");
        buffer.append(GIGA_BYTE+" GB");
        unit %= GB;
    }
    if ( unit / MB > 0 ) {
        MEGA_BYTE = (int) (unit / MB);
        if (GIGA_BYTE != 0) buffer.append(", ");
        buffer.append(MEGA_BYTE+" MB");
        unit %= MB;
    }
    if ( unit / KB > 0 ) {
        KILO_BYTE = (int) (unit / KB);
        if (MEGA_BYTE != 0) buffer.append(", ");
        buffer.append(KILO_BYTE+" KB");
        unit %= KB;
    }
    if ( unit > 0 ) buffer.append(", "+unit+" Bytes");
    return buffer.toString();
}

আমি নীচে ফর্ম্যাটটি পেতে ফেসবুকআরভিভেরStringUtils কোডটি কেবলমাত্র সংশোধন করেছি । আপনি Apache.hadoop- ব্যবহার করার সময় একই ফর্ম্যাটটি পাবেনStringUtils

getMemoryUnit(): Total: [123.0 MB], Max: [1.8 GB], Free: [120.4 MB]
public static String getMemoryUnit(long bytes) {
    DecimalFormat oneDecimal = new DecimalFormat("0.0");
    float BYTE = 1024.0f, KB = BYTE, MB = KB * KB, GB = MB * KB, TB = GB * KB;
    long absNumber = Math.abs(bytes);
    double result = bytes;
    String suffix = " Bytes";
    if (absNumber < MB) {
        result = bytes / KB;
        suffix = " KB";
    } else if (absNumber < GB) {
        result = bytes / MB;
        suffix = " MB";
    } else if (absNumber < TB) {
        result = bytes / GB;
        suffix = " GB";
    }
    return oneDecimal.format(result) + suffix;
}

উপরোক্ত পদ্ধতিগুলির ব্যবহারের উদাহরণ:

public static void main(String[] args) {
    Runtime runtime = Runtime.getRuntime();
    int availableProcessors = runtime.availableProcessors();

    long heapSize = Runtime.getRuntime().totalMemory(); 
    long heapMaxSize = Runtime.getRuntime().maxMemory();
    long heapFreeSize = Runtime.getRuntime().freeMemory();

    System.out.format("Total: [%s], Max: [%s], Free: [%s]\n", heapSize, heapMaxSize, heapFreeSize);
    System.out.format("getMemoryUnit(): Total: [%s], Max: [%s], Free: [%s]\n",
            getMemoryUnit(heapSize), getMemoryUnit(heapMaxSize), getMemoryUnit(heapFreeSize));
    System.out.format("getFullMemoryUnit(): Total: [%s], Max: [%s], Free: [%s]\n",
            getFullMemoryUnit(heapSize), getFullMemoryUnit(heapMaxSize), getFullMemoryUnit(heapFreeSize));
}

উপরের ফর্ম্যাটটি পেতে বাইটস

Total: [128974848], Max: [1884815360], Free: [126248240]

মানব পাঠযোগ্য বিন্যাসে সময় প্রদর্শনের জন্য এই ফাংশনটি ব্যবহার করুন millisToShortDHMS(long duration)।

— যশ
সূত্র
0

এখানে @aioobe থেকে কোটলিনে রূপান্তর

/**
 * https://stackoverflow.com/a/3758880/1006741
 */
fun Long.humanReadableByteCountBinary(): String {
    val b = when (this) {
        Long.MIN_VALUE -> Long.MAX_VALUE
        else -> abs(this)
    }
    return when {
        b < 1024L -> "$this B"
        b <= 0xfffccccccccccccL shr 40 -> "%.1f KiB".format(Locale.UK, this / 1024.0)
        b <= 0xfffccccccccccccL shr 30 -> "%.1f MiB".format(Locale.UK, this / 1048576.0)
        b <= 0xfffccccccccccccL shr 20 -> "%.1f GiB".format(Locale.UK, this / 1.073741824E9)
        b <= 0xfffccccccccccccL shr 10 -> "%.1f TiB".format(Locale.UK, this / 1.099511627776E12)
        b <= 0xfffccccccccccccL -> "%.1f PiB".format(Locale.UK, (this shr 10) / 1.099511627776E12)
        else -> "%.1f EiB".format(Locale.UK, (this shr 20) / 1.099511627776E12)
    }
}
— Kibotu
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.