Java - Converti dimensioni leggibili da lettura in byte

Question

Ho trovato molte informazioni sulla conversione di informazioni di byte grezzi in un formato leggibile dall'uomo, ma ho bisogno di fare il contrario, ovvero convertire la stringa "1,6 GB" nel valore lungo 1717990000. Esiste un modo in-built/ben definito per farlo, o dovrò praticamente girare il mio?

[Edit]: Ecco il mio primo tentativo ...

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

non ho mai sentito parlare di tale libreria ben noto, che implementa tali metodi di utilità testo-analisi. Ma la tua soluzione sembra essere vicina alla corretta implementazione.

Le uniche due cose che vorrei correggere nel codice sono:

1. definiscono metodo Number parse(String arg0) come static grazie alla sua utilità natura

2. definiscono factor s per ogni tipo di definizione della taglia come campi final static.

I.e. sarà come questo:

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

So che questo è molto più tardi, ma ero alla ricerca di una funzione simile, che tiene conto del SI prefix pure. Così sono arrivato a crearne uno anch'io e ho pensato che potesse essere utile per altre persone.

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

Sono sicuro che questo è possibile anche con la ricorsione. Era troppo semplice fastidio ...

Answer 3

Una versione riveduta della risposta di Andremoniy che distingue correttamente tra chilo e kibi, ecc

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

Tutto in una risposta, analizza a 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")); 
    } 
}