Konvertieren von KB, MB, GB, TB, dynamisch

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 = dec.format(k).concat("KB");

    }
    if (m>0)
    {

        hrSize = dec.format(m).concat("MB");
    }
    if (g>0)
    {

        hrSize = dec.format(g).concat("GB");
    }
    if (t>0)
    {

        hrSize = dec.format(t).concat("TB");
    }

    return hrSize;
    }

Dies ist eine Methode, die sollten zurückkehren, Größe in GB,MB, KB oder TB. Input-Wert ist in KB.
zum Beispiel Ergebnis für 1245 sollte wie 1.21 MB, aber was ich bekomme ist 1.00 MB.

InformationsquelleAutor pedja | 2012-11-24

25

Durchführung integer division. So das Ergebnis der division ist auch integer. Und Nachkomma-Teil abgeschnitten.
```
so, 1245 / 1024 = 1
```
Ändern Sie Ihre division zu floating point division: -
```
double m = size/1024.0;
double g = size/1048576.0;
double t = size/1073741824.0;
```
Auch, dein Vergleich ist fehlerhaft. Sie sollte den Vergleich mit 1.
```
if (m > 1), if (t > 1), if (g > 1)
```
Idealerweise würde ich ändern Ihren Vergleich an: -
```
    if (t > 1) {
        hrSize = dec.format(t).concat("TB");
    } else if (g > 1) {
        hrSize = dec.format(g).concat("GB");
    } else if (m > 1) {
        hrSize = dec.format(m).concat("MB");
    } else {
        hrSize = dec.format(size).concat("KB");
    }
```
Müssen Sie vergleichen mit dem höheren Einheit, die ersten, und verschieben Sie dann den unteren.
- nun es gibt immer 0.00 TB
- Für das, was Sie Wert sind, es zu tun. Seine nicht möglich.
- Verwenden else if statt nur if für m, g, und t, da selbst eine kleine Datei sein könnte 0.00000000001 TB (die ist größer als null).
- Ah! haben Sie nicht bemerken, dass.
- jetzt gibt es Wert in kb
- Yo tun sollten, den Vergleich mit 1, und Sie tun es mit 0. Ändern Sie alle, wenn zu k > 1, g > 1, ...
- Nein, noch gibt kb
- Überprüfen Sie die post bearbeitet. Sie müssen ändern Sie Ihre if Vergleich ein wenig.
- Es ist in Ordnung, die in meinem Fall.
- Nein, sorry, es funktioniert jetzt. @Greg Hewgill verwirrt mich mit else if. es sollte nur wenn. Danke für die Hilfe
- Gut, es gibt viele Möglichkeiten zum umsetzen der Funktion, die Sie möchten. Es klingt wie Sie haben schließlich konvergierten auf eine Umsetzung, die für Sie arbeitet.
- Nein, er hatte Recht. Im Grunde, Sie tun der Vergleich falsch. Das ist, warum sonst, wenn nicht funktioniert hat. Sie sollten zunächst prüfen, ob Ihre Größe passen in TB, wenn nicht zu bewegen, um MB, und so weiter.. zu KB. Siehe die if-else-Vergleich habe ich gepostet. So, nicht alle Ihre Bedingungen überprüft werden.
- Ja, beide hatten Sie Recht, nur muss ich umkehren, um zu vergleichen, tb, erste wie Sie erklärt, oder verwenden Sie nur, wenn
- Auch, nicht tun die division erste. Wenn die Datei TB-warum dann Zeit verschwenden für den langsamen GB-und MB-division. Ein anderer Weg ist, vergleichen Sie die Größe in ganze Zahl zuerst, um festzustellen, die Größe der Datei ist TB, GB oder MB dann auch nur in einer Sparte, die die Geschwindigkeit erhöhen
InformationsquelleAutor Rohit Jain

Einer modifizierten version. Nur Anrufe format einmal. Enthält "Bytes".

public static String formatFileSize(long size) {
    String hrSize = null;

    double b = size;
    double k = size/1024.0;
    double m = ((size/1024.0)/1024.0);
    double g = (((size/1024.0)/1024.0)/1024.0);
    double t = ((((size/1024.0)/1024.0)/1024.0)/1024.0);

    DecimalFormat dec = new DecimalFormat("0.00");

    if ( t>1 ) {
        hrSize = dec.format(t).concat(" TB");
    } else if ( g>1 ) {
        hrSize = dec.format(g).concat(" GB");
    } else if ( m>1 ) {
        hrSize = dec.format(m).concat(" MB");
    } else if ( k>1 ) {
        hrSize = dec.format(k).concat(" KB");
    } else {
        hrSize = dec.format(b).concat(" Bytes");
    }

    return hrSize;
}

dies sollte die akzeptierte Antwort

InformationsquelleAutor bickster

Ich Liebe dieses:

public static String getDynamicSpace(long diskSpaceUsed)
{
    if (diskSpaceUsed <= 0) {
        return "0";
    }

    final String[] units = new String[] { "B", "KiB", "MiB", "GiB", "TiB" };
    int digitGroups = (int) (Math.log10(diskSpaceUsed) / Math.log10(1024));
    return new DecimalFormat("#,##0.#").format(diskSpaceUsed / Math.pow(1024, digitGroups))
            + " " + units[digitGroups];
}

InformationsquelleAutor Sampisa

5

Das problem ist, dass Sie unter Verwendung der integer-division. Ändern Sie Ihren code ein:
```
double m = size/1024.0;
double g = size/1048576.0;
double t = size/1073741824.0;
```
In Ihrem ursprünglichen code double m = size/1024 würde teilen die integer size durch 1024, abschneiden des Ergebnisses auf einen ganzzahligen, und nur dann konvertieren, um double. Dies ist der Grund, warum der gebrochene Teil war verloren.

InformationsquelleAutor NPE
3

Durchführung integer-division,

d.h., 31/15 Folge 2, nicht 2.was

fügen Sie einfach die Anzahl mit D oder d bezeichnet es als verdoppeln, und Sie werden in Ordnung sein
```
double m = size/1024D;
double g = size/1048576D;
double t = size/1073741824D;
```
InformationsquelleAutor PermGenError
3

Nicht einfach um das richtig zu stellen. Rohit Jain erwähnt die integer-operation. Auch die Rundung kann ein Problem sein, wie immer, die Rundung nach unten kann nicht wünschenswert sein. Ich würde Ihnen raten, gehen Sie für eine Lösung wie in der triava Bibliothek.

Kann formatieren von zahlen mit beliebiger Genauigkeit, in 3 verschiedenen Systemen (SI, IEC, JEDEC) und verschiedenen output-Optionen. Hier sind einige code-Beispiele aus dem triava unit-tests:
```
UnitFormatter.formatAsUnit(1126, UnitSystem.SI, "B");
//= "1.13kB"
UnitFormatter.formatAsUnit(2094, UnitSystem.IEC, "B");
//= "2.04KiB"
```
Drucken genauen kilo -, mega-Werte (hier mit W = Watt):
```
UnitFormatter.formatAsUnits(12_000_678, UnitSystem.SI, "W", ", ");
//= "12MW, 678W"
```
Können Sie ein DecimalFormat zum anpassen der Ausgabe:
```
UnitFormatter.formatAsUnit(2085, UnitSystem.IEC, "B", new DecimalFormat("0.0000"));
//= "2.0361KiB"
```
Für beliebige Operationen auf kilo-oder mega-Werte, können Sie Sie trennen, in Komponenten:
```
UnitComponent uc = new  UnitComponent(123_345_567_789L, UnitSystem.SI);
int kilos = uc.kilo(); //567
int gigas = uc.giga(); //123
```
InformationsquelleAutor Christian Esken

String[] fileSizeUnits = {"bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
public String calculateProperFileSize(double bytes){
    String sizeToReturn = "";//= FileUtils.byteCountToDisplaySize(bytes), unit = ""; 
    int index = 0;
    for(index = 0; index < fileSizeUnits.length; index++){
        if(bytes < 1024){
            break;
        }
        bytes = bytes / 1024;
    }
    System.out.println("Systematic file size: " + bytes + " " + fileSizeUnits[index]);
    sizeToReturn = String.valueOf(bytes) + " " + fileSizeUnits[index];
    return sizeToReturn;
}

Nur hinzufügen weitere Datei-Einheiten (falls vorhanden), und Sie werden sehen, unit-Größe bis zu, dass die Einheit (wenn Sie Ihre Datei hat, die viel Länge)

Sehr nette Antwort! Danke Vishwajit

InformationsquelleAutor Vishwajit R. Shinde

Meiner basic-version (Sie KÖNNEN festlegen, einige Konstanten anstelle von computing-POW die ganze Zeit):

public static String GetFolderSizeHuman(long aBytes)
{
  if (aBytes < 1024 * 1024) 
    return aBytes + " KB";
  else if (aBytes < Math.pow(2, 20) * 1024)
    return (int) aBytes / Math.pow(2, 20) + " MB";
  else if (aBytes < Math.pow(2, 30) * 1024 )
    return kGbTbFormatter.format(aBytes / Math.pow(2, 30)) + " GB";
  else if (aBytes < Math.pow(2, 40) * 1024)
    return kGbTbFormatter.format(aBytes / Math.pow(2, 40)) + " TB";

  else return "N/A (1TB?)";
}

InformationsquelleAutor Buffalo

bickster Antwort funktioniert ganz in Ordnung, aber das problem dabei ist, dass es Ergebnisse liefert wie 45.00 Bytes und 12.00 KB. Meiner Meinung nach, die letzten Dezimalstellen sollten entfernt werden, wenn Sie Nullen. Also anstatt 45.00 Bytes und 12.00 KB erhalten Sie 45 B und 12 KB (beachten Sie, dass Bytes wurde geändert, um B. Dies ist nur für Homogenität, da haben wir KB, MB usw und nicht Kilobyte, Megabyte etc.).

private boolean isDouble(double value) {
        if (value % 1 == 0) {
            Log.d(TAG, "value is " + value + " and is not double");
            return false;
        } else {
            Log.d(TAG, "value is " + value + " and is double");
            return true;
        }
    }

Der oben beschriebenen Methode wird einfach geprüft, ob der Wert Nullen als Nachkommastellen.

private String formatFileSize(long size) {
        String hrSize = null;
        double b = size;
        double k = size/1024.0;
        double m = ((size/1024.0)/1024.0);
        double g = (((size/1024.0)/1024.0)/1024.0);
        double t = ((((size/1024.0)/1024.0)/1024.0)/1024.0);

        DecimalFormat dec1 = new DecimalFormat("0.00");
        DecimalFormat dec2 = new DecimalFormat("0");
        if (t>1) {
            hrSize = isDouble(t) ? dec1.format(t).concat(" TB") : dec2.format(t).concat(" TB");
        } else if (g>1) {
            hrSize = isDouble(g) ? dec1.format(g).concat(" GB") : dec2.format(g).concat(" GB");
        } else if (m>1) {
            hrSize = isDouble(m) ? dec1.format(m).concat(" MB") : dec2.format(m).concat(" MB");
        } else if (k>1) {
            hrSize = isDouble(k) ? dec1.format(k).concat(" KB") : dec2.format(k).concat(" KB");
        } else {
            hrSize = isDouble(b) ? dec1.format(b).concat(" B") : dec2.format(b).concat(" B");
        }
        return hrSize;
    }

InformationsquelleAutor X09

class ConverterUtils{
    public static void main(String[] args) {
        System.out.println(getSize(1234567));
    }
    public static String getSize(long size) {
        String s = "";
        double kb = size / 1024;
        double mb = kb / 1024;
        double gb = kb / 1024;
        double tb = kb / 1024;
        if(size < 1024) {
            s = size + " Bytes";
        } else if(size >= 1024 && size < (1024 * 1024)) {
            s =  String.format("%.2f", kb) + " KB";
        } else if(size >= (1024 * 1024) && size < (1024 * 1024 * 1024)) {
            s = String.format("%.2f", mb) + " MB";
        } else if(size >= (1024 * 1024 * 1024) && size < (1024 * 1024 * 1024 * 1024)) {
            s = String.format("%.2f", gb) + " GB";
        } else if(size >= (1024 * 1024 * 1024 * 1024)) {
            s = String.format("%.2f", tb) + " TB";
        }
        return s;
    }
}

Besser zu verstehen - https://www.techspot.com/news/68482-quickly-convert-between-storage-size-units-kb-mb.html

InformationsquelleAutor Ilya Budu

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.