convert - string to blob javascript
¿Cómo convertir tamaño de bytes en formato legible por humanos en java? (20)
¿Has probado JSR 363 ? Sus módulos de extensión de unidad como Unicode CLDR (en GitHub: uom-systems ) hacen todo eso por usted.
Puede usar MetricPrefix incluido en cada implementación o BinaryPrefix (comparable a algunos de los ejemplos anteriores) y si, por ejemplo, vive y trabaja en India o un país cercano, IndianPrefix (también en el módulo común de uom-systems) le permite usar y formato "Crore Bytes" o "Lakh Bytes", también.
¿Cómo convertir tamaño de bytes en formato legible por humanos en Java? Al igual que 1024 debería convertirse en "1 Kb" y 1024 * 1024 debería convertirse en "1 Mb".
Estoy un poco cansado de escribir este método de utilidad para cada proyecto. ¿Hay métodos estáticos en Apache Commons para esto?
Ahora hay una biblioteca disponible que contiene el formato de la unidad. Lo agregué a la biblioteca triava , ya que la única otra biblioteca existente parece ser una para Android.
Puede formatear números con precisión arbitraria, en 3 sistemas diferentes (SI, IEC, JEDEC) y varias opciones de salida. Aquí hay algunos ejemplos de código de las pruebas unitarias de triava :
UnitFormatter.formatAsUnit(1126, UnitSystem.SI, "B");
// = "1.13kB"
UnitFormatter.formatAsUnit(2094, UnitSystem.IEC, "B");
// = "2.04KiB"
Imprimiendo kilo exacto, mega valores (aquí con W = Watt):
UnitFormatter.formatAsUnits(12_000_678, UnitSystem.SI, "W", ", ");
// = "12MW, 678W"
Puede pasar un DecimalFormat para personalizar la salida:
UnitFormatter.formatAsUnit(2085, UnitSystem.IEC, "B", new DecimalFormat("0.0000"));
// = "2.0361KiB"
Para operaciones arbitrarias en kilo o mega valores, puede dividirlos en componentes:
UnitComponent uc = new UnitComponent(123_345_567_789L, UnitSystem.SI);
int kilos = uc.kilo(); // 567
int gigas = uc.giga(); // 123
Aquí está el equivalente de C # .net para la respuesta de consenso correcta de Java anterior. (hay otro debajo que tiene códigos más cortos)
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);
}
Técnicamente hablando, si nos atenemos a las unidades SI, esta rutina funciona para cualquier uso regular de números. Hay muchas otras buenas respuestas de los expertos. Supongamos que está haciendo un enlace de datos de números en las vistas de cuadrícula, vale la pena revisar las rutinas de rendimiento optimizado de ellos.
PD: publicado porque esta pregunta / respuesta se ubicó en la parte superior de la búsqueda de google mientras realizaba el proyecto C #.
Aquí está mi ir a ella (no hay bucles y maneja tanto las unidades SI como las unidades binarias):
public static String humanReadableByteCount(long bytes, boolean si) {
int unit = si ? 1000 : 1024;
if (bytes < unit) return bytes + " B";
int exp = (int) (Math.log(bytes) / Math.log(unit));
String pre = (si ? "kMGTPE" : "KMGTPE").charAt(exp-1) + (si ? "" : "i");
return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre);
}
Ejemplo de salida:
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)
Artículo relacionado: Java: formato de tamaño de byte a formato legible por humanos
En la remota posibilidad de que ahorre a alguien un poco de tiempo, o tal vez solo por un poco de diversión, aquí hay una versión Go. Para simplificar, solo he incluido el caso de salida binaria.
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);
Esta es una versión modificada de la respuesta de aioobe .
Cambios:
- Parámetro
Locale, porque algunos lenguajes usan.y otros,como punto decimal. - código legible por humanos
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);
}
Le hice la misma pregunta recientemente:
Formato de tamaño de archivo como MB, GB, etc.
Si bien no hay una respuesta lista para usar, puedo vivir con la solución:
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;
}
Código de prueba:
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));
}
}
Salida (en mi configuración regional alemana):
1 B
4,2 KB
41,4 MB
3,3 GB
Editar: He abierto un problema que solicita esta funcionalidad para Google Guava . Tal vez alguien quiera apoyarlo.
Podemos evitar completamente el uso de los Math.pow() lentos Math.pow() y Math.log() sin sacrificar la simplicidad, ya que el factor entre las unidades (por ejemplo, B, KB, MB, etc.) es 1024, que es 2 ^ 10. La clase Long tiene un práctico método numberOfLeadingZeros() que podemos usar para indicar en qué unidad cae el valor de tamaño.
Punto clave: las unidades de tamaño tienen una distancia de 10 bits (1024 = 2 ^ 10), lo que significa la posición del 1 bit más alto, o, en otras palabras, el número de ceros a la izquierda - difieren en 10 (Bytes = KB * 1024, KB = MB) * 1024 etc.).
Correlación entre el número de ceros iniciales y la unidad de tamaño:
# of leading 0''s Size unit
-------------------------------
>53 B (Bytes)
>43 KB
>33 MB
>23 GB
>13 TB
>3 PB
<=2 EB
El código final:
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));
}
Puede usar el StringUtils de StringUtils TraditionalBinarPrefix StringUtils :
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";
Quizás puedas usar este código (en C #):
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)
}
Sé que es demasiado tarde para actualizar esta publicación! pero me divertí un poco con esto:
Crear una interfaz:
public interface IUnits {
public String format(long size, String pattern);
public long getUnitSize();
}
Crear clase StorageUnits:
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.#");
}
}
Llámalo:
class Main {
public static void main(String... args) {
System.out.println(StorageUnits.format(21885));
System.out.println(StorageUnits.format(2188121545L));
}
}
Salida:
21.4kB
2GB
Si usa Android, simplemente puede usar Formatter.formatFileSize() .
Alternativamente, aquí hay una solución basada en este popular post :
/**
* 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;
}
Byte Units te permite hacerlo así:
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));
He escrito otra biblioteca llamada storage-units que le permite hacerlo así:
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);
En caso de que quieras forzar una unidad determinada, haz esto:
String formattedUnit9 = StorageUnits.formatAsKibibyte(input2);
String formattedUnit10 = StorageUnits.formatAsCommonMegabyte(input2);
Assert.assertEquals("1024.00 KiB", formattedUnit9);
Assert.assertEquals("1.00 MB", formattedUnit10);
FileUtils.byteCountToDisplaySize(long size) funcionaría si su proyecto puede depender de org.apache.commons.io .
Usa la clase incorporada de Android
Para Android hay un Formatter clase. Sólo uno como código y ya está.
android.text.format.Formatter.formatShortFileSize(activityContext, bytes);
Es como formatFileSize() , pero intenta generar números más cortos (mostrando menos decimales).
android.text.format.Formatter.formatFileSize(activityContext, bytes);
Da formato a un tamaño de contenido en forma de bytes, kilobytes, megabytes, etc.
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);
}
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 "???";
}
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";
}
}
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;
}
Solo agregue más unidades de archivo (si falta), y verá el tamaño de la unidad hasta esa unidad (si su archivo tiene esa longitud) System.out.println ("Tamaño de archivo en el formato adecuado:" + bytes + "" + fileSizeUnits [índice]); sizeToReturn = String.valueOf (bytes) + "" + fileSizeUnits [index]; devuelve sizeToReturn; }
public static String humanReadableInt(long number) {
return TraditionalBinaryPrefix.long2String(number,””,1);
}