Java - Konwertuj ludzki czytelny rozmiar na bajty

Question

Znalazłem wiele informacji na temat konwersji informacji o bajtach surowych do formatu czytelnego dla człowieka, ale muszę zrobić coś odwrotnego, tj. Przekonwertować ciąg "1.6 GB" na długą wartość 1717990000. Czy jest to wbudowany/dobrze zdefiniowany sposób, aby to zrobić, czy też będę musiał samodzielnie wykonać własne?

[Edit]: Oto moja pierwsza stab ...

static class ByteFormat extends NumberFormat { 
    @Override 
    public StringBuffer format(double arg0, StringBuffer arg1, FieldPosition arg2) { 
     // TODO Auto-generated method stub 
     return null; 
    } 

    @Override 
    public StringBuffer format(long arg0, StringBuffer arg1, FieldPosition arg2) { 
     // TODO Auto-generated method stub 
     return null; 
    } 

    @Override 
    public Number parse(String arg0, ParsePosition arg1) { 
     return parse (arg0); 
    } 

    @Override 
    public Number parse(String arg0) { 
     int spaceNdx = arg0.indexOf(" "); 
     double ret = Double.parseDouble(arg0.substring(0, spaceNdx)); 
     String unit = arg0.substring(spaceNdx + 1); 
     int factor = 0; 
     if (unit.equals("GB")) { 
      factor = 1073741824; 
     } 
     else if (unit.equals("MB")) { 
      factor = 1048576; 
     } 
     else if (unit.equals("KB")) { 
      factor = 1024; 
     } 

     return ret * factor; 
    } 
} 

Answer 1

Nigdy nie słyszałem o takiej znanej biblioteki, który realizuje takie metody narzędzie konwertujące tekst parsowania. Ale Twoje rozwiązanie wydaje się być bliskie poprawnej implementacji.

Tylko dwie rzeczy, które chciałbym poprawić w kodzie są:

1. określić sposób Number parse(String arg0) jako statyczny ze względu na jej charakter użytkowy

2. określić factor s dla każdego typu definicja rozmiaru jako pola final static.

tj. to będzie jak ten:

private final static long KB_FACTOR = 1024; 
private final static long MB_FACTOR = 1024 * KB_FACTOR; 
private final static long GB_FACTOR = 1024 * MB_FACTOR; 

public static double parse(String arg0) { 
    int spaceNdx = arg0.indexOf(" "); 
    double ret = Double.parseDouble(arg0.substring(0, spaceNdx)); 
    switch (arg0.substring(spaceNdx + 1)) { 
     case "GB": 
      return ret * GB_FACTOR; 
     case "MB": 
      return ret * MB_FACTOR; 
     case "KB": 
      return ret * KB_FACTOR; 
    } 
    return -1; 
} 

Answer 2

Wiem, że to dużo później, ale szukałam podobnej funkcji, które bierze pod uwagę SI prefix również. Więc sam wylądowałem i sam go stworzyłem i pomyślałem, że może być użyteczny dla innych ludzi.

public static String units = "KMGTPE"; 

/** 
* Converts from human readable to byte format 
* @param number The number value of the amount to convert 
* @param unit The unit: B, KB, MB, GB, TB, PB, EB 
* @param si Si prefix 
* @return byte value 
*/ 
public static double parse(double number, String unit, boolean si) 
{ 
    String identifier = unit.substring(0, 1); 
    int index = units.indexOf(identifier); 
    //not already in bytes 
    if (index!=-1) 
    { 
     for (int i = 0; i <= index; i++) 
      number = number * (si ? 1000 : 1024); 
    } 
    return number; 
} 

Jestem pewny, że można to zrobić również z rekursją. To było zbyt proste, aby niepokoić ...

Answer 3

Zmieniona wersja odpowiedzi Andremoniy że prawidłowo rozróżnia kilogram i KIBI itp

private final static long KB_FACTOR = 1000; 
private final static long KIB_FACTOR = 1024; 
private final static long MB_FACTOR = 1000 * KB_FACTOR; 
private final static long MIB_FACTOR = 1024 * KIB_FACTOR; 
private final static long GB_FACTOR = 1000 * MB_FACTOR; 
private final static long GIB_FACTOR = 1024 * MIB_FACTOR; 

public static double parse(String arg0) { 
    int spaceNdx = arg0.indexOf(" "); 
    double ret = Double.parseDouble(arg0.substring(0, spaceNdx)); 
    switch (arg0.substring(spaceNdx + 1)) { 
     case "GB": 
      return ret * GB_FACTOR; 
     case "GiB": 
      return ret * GIB_FACTOR; 
     case "MB": 
      return ret * MB_FACTOR; 
     case "MiB": 
      return ret * MIB_FACTOR; 
     case "KB": 
      return ret * KB_FACTOR; 
     case "KiB": 
      return ret * KIB_FACTOR; 
    } 
    return -1; 
} 

Answer 4

Wszystko w jednym odpowiedź, analizuje się long:

public class SizeUtil { 

    public static String units = "BKMGTPEZY"; 

    public static long parse(String arg0) { 
     int spaceNdx = arg0.indexOf(" ");  
     double ret = Double.parseDouble(arg0.substring(0, spaceNdx)); 
     String unitString = arg0.substring(spaceNdx+1); 
     int unitChar = unitString.charAt(0); 
     int power = units.indexOf(unitChar); 
     boolean isSi = unitString.indexOf('i')!=-1; 
     int factor = 1024; 
     if (isSi) 
     { 
      factor = 1000; 
     } 

     return new Double(ret * Math.pow(factor, power)).longValue(); 
    } 

    public static void main(String[] args) { 
     System.out.println(parse("300.00 GiB")); // requires a space 
     System.out.println(parse("300.00 GB")); 
     System.out.println(parse("300.00 B")); 
     System.out.println(parse("300 EB")); 
    } 
}