La conversion de KO MO, GO, to dynamiquement

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

C'est une méthode qui doit renvoyer la taille en GO,MO, KO ou la TUBERCULOSE. La valeur d'entrée est en KO.
par exemple, résulter de 1245 devrait être comme 1.21 MO, mais ce que je reçois est de 1,00 MO.

OriginalL'auteur pedja | 2012-11-24

25

Vous effectuez integer division. Si le résultat de la division est également integer. Et la partie fractionnaire est tronqué.
```
so, 1245 / 1024 = 1
```
Changer votre division à floating point division: -
```
double m = size/1024.0;
double g = size/1048576.0;
double t = size/1073741824.0;
```
Aussi, votre comparaison est défectueux. Vous devez faire la comparaison avec 1.
```
if (m > 1), if (t > 1), if (g > 1)
```
Idéalement, j'aimerais changer votre rapport à: -
```
    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");
    }
```
Vous avez besoin de comparer avec la hausse de l'unité première, et de passer ensuite à la partie inférieure.

Utilisation else if au lieu de simplement if pour m, g, et t, car même un petit fichier peut être 0.00000000001 la TUBERCULOSE (qui est plus grande que zéro).
Ah! n'a pas remarqué.
Yo devez faire la comparaison avec 1, et vous le faites avec 0. Changement de tous les cas de k > 1, g > 1, ...
De vérifier la modification de la poste. Vous avez besoin de modifier votre if comparaison un peu.
Ça fonctionne dans mon cas.

OriginalL'auteur Rohit Jain

Une version modifiée. Seuls les appels format une fois. Inclut Les "Octets".

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

ce doit être la accepté de répondre à

OriginalL'auteur bickster

J'aime ceci:

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

OriginalL'auteur Sampisa

5

Le problème est que vous utilisez division entière. Modifiez votre code pour:
```
double m = size/1024.0;
double g = size/1048576.0;
double t = size/1073741824.0;
```
Dans votre code original, double m = size/1024 aurait pour effet de diviser l'entier size par 1024, tronquer le résultat à un nombre entier, et seulement ensuite le convertir en double. C'est pourquoi la partie fractionnaire a été de se perdre.

OriginalL'auteur NPE
3

Vous effectuez de la division entière,

c'est à dire, 31/15 donnera 2, pas 2.quelle que soit

ajoutez simplement le numéro d' D ou d qui désigne comme un double et vous serez amende
```
double m = size/1024D;
double g = size/1048576D;
double t = size/1073741824D;
```
OriginalL'auteur PermGenError
3

Ce n'est pas facile à obtenir ce droit. Rohit Jain mentionné l'entier de l'opération. Aussi arrondi peut être un problème, comme toujours arrondi vers le bas peut ne pas être souhaitable. Je vous conseille d'aller pour une solution disponible, comme dans le triava bibliothèque.

Il peut formater les nombres avec une précision arbitraire, dans 3 différents systèmes (SI, IEC, JEDEC) et diverses options de sortie. Voici quelques exemples de code à partir de la triava tests unitaires:
```
UnitFormatter.formatAsUnit(1126, UnitSystem.SI, "B");
//= "1.13kB"
UnitFormatter.formatAsUnit(2094, UnitSystem.IEC, "B");
//= "2.04KiB"
```
Impression exacte kilo, mega valeurs (ici avec W = Watt):
```
UnitFormatter.formatAsUnits(12_000_678, UnitSystem.SI, "W", ", ");
//= "12MW, 678W"
```
Vous pouvez passer une DecimalFormat pour personnaliser la sortie:
```
UnitFormatter.formatAsUnit(2085, UnitSystem.IEC, "B", new DecimalFormat("0.0000"));
//= "2.0361KiB"
```
Pour arbitraire des opérations sur les kilo, mega valeurs, vous pouvez les diviser en composants:
```
UnitComponent uc = new  UnitComponent(123_345_567_789L, UnitSystem.SI);
int kilos = uc.kilo(); //567
int gigas = uc.giga(); //123
```
OriginalL'auteur 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;
}

Simplement ajouter plus d'un fichier d'unités (si tous les disparus), et vous verrez la taille de l'unité jusqu'à l'unité (si votre fichier a beaucoup de longueur)

Très belle réponse! Merci Vishwajit

OriginalL'auteur Vishwajit R. Shinde

Ma version de base (vous POUVEZ définir des constantes au lieu de l'informatique POW tout le temps):

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

OriginalL'auteur Buffalo

bickster réponse fonctionne très bien, mais le problème c'est qu'il renvoie des résultats comme 45.00 Bytes et 12.00 KB. À mon avis, les derniers chiffres décimaux doivent être supprimés s'ils sont des zéros. Ainsi, au lieu de 45.00 Bytes et 12.00 KB, vous obtenez 45 B et 12 KB (notez que Bytes a été modifié pour B. C'est juste pour une question d'uniformité, puisque nous avons KO, MO, etc et pas de kilo-octets, méga-octets, 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;
        }
    }

La méthode ci-dessus vérifie simplement si la valeur a de zéros que de chiffres décimaux.

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

OriginalL'auteur 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;
}
}

Pour mieux comprendre - https://www.techspot.com/news/68482-quickly-convert-between-storage-size-units-kb-mb.html

OriginalL'auteur Ilya Budu

Vous devez vous connecter pour publier un commentaire.