por qué inicializar esta matriz de bytes a 1024

Question

Soy relativamente nuevo en Java y estoy intentando escribir una aplicación de Android simple. Tengo un archivo de texto grande con aproximadamente 3500 líneas en la carpeta de activos de mis aplicaciones y necesito leerlo en una cadena. Encontré un buen ejemplo sobre cómo hacer esto, pero tengo una pregunta acerca de por qué la matriz de bytes se inicializa en 1024. ¿No quisiera inicializarla a la longitud de mi archivo de texto? Además, ¿no quisiera utilizar char, no byte? Aquí está el código:

private void populateArray(){ 
    AssetManager assetManager = getAssets(); 
    InputStream inputStream = null; 
    try { 
     inputStream = assetManager.open("3500LineTextFile.txt"); 
    } catch (IOException e) { 
     Log.e("IOException populateArray", e.getMessage()); 
    } 
    String s = readTextFile(inputStream); 
    // Add more code here to populate array from string 
} 

private String readTextFile(InputStream inputStream) { 
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); 
    inputStream.length 
    byte buf[] = new byte[1024]; 
    int len; 
    try { 
     while ((len = inputStream.read(buf)) != -1) { 
      outputStream.write(buf, 0, len); 
     } 
     outputStream.close(); 
     inputStream.close(); 
    } catch (IOException e) { 
     Log.e("IOException readTextFile", e.getMessage()); 
    } 
    return outputStream.toString(); 
} 

EDITAR: En función de sus sugerencias, probé este enfoque. ¿Es mejor? Gracias.

private void populateArray(){ 
    AssetManager assetManager = getAssets(); 
    InputStream inputStream = null; 
    Reader iStreamReader = null; 
    try { 
     inputStream = assetManager.open("List.txt"); 
     iStreamReader = new InputStreamReader(inputStream, "UTF-8"); 
    } catch (IOException e) { 
     Log.e("IOException populateArray", e.getMessage()); 
    } 
    String String = readTextFile(iStreamReader); 
    // more code here 
} 

private String readTextFile(InputStreamReader inputStreamReader) { 
    StringBuilder sb = new StringBuilder(); 
    char buf[] = new char[2048]; 
    int read; 
    try { 
     do { 
      read = inputStreamReader.read(buf, 0, buf.length); 
      if (read>0) { 
       sb.append(buf, 0, read); 
      } 
     } while (read>=0); 
    } catch (IOException e) { 
     Log.e("IOException readTextFile", e.getMessage()); 
    } 
    return sb.toString(); 
} 

Answer 1

Este ejemplo no es bueno en absoluto. Está lleno de malas prácticas (ocultar excepciones, no cerrar flujos en bloques finalmente, no especificar una codificación explícita, etc.). Utiliza un búfer de 1024 bytes de longitud porque no tiene forma de conocer la longitud del flujo de entrada.

Lea Java IO tutorial para aprender a leer el texto de un archivo.

Answer 2

Está leyendo el archivo en un búfer de 1024 Bytes. Luego esos 1024 bytes se escriben en outputStream. Este proceso se repite hasta que todo el archivo se lee en outputStream. Como mencionó JB Nizet, el ejemplo está lleno de malas prácticas.

Answer 3

Para leer desde un archivo, utilizo habitualmente un escáner y un StringBuilder.

 Scanner scan = new Scanner(new BufferedInputStream(new FileInputStream(filename)), "UTF-8"); 
     StringBuilder sb = new StringBuilder(); 
     while (scan.hasNextLine()) { 
      sb.append(scan.nextLine()); 
      sb.append("\n"); 
     } 
     scan.close 

     return sb.toString(); 

Trate de arrojar sus excepciones en lugar de tragarlas. La persona que llama debe saber que hubo un problema al leer su archivo.

Editar: También tenga en cuenta que el uso de un BufferedInputStream es importante. De lo contrario, intentará leer bytes por bytes, que pueden ser lentos.

Answer 4

¿No quisiera inicializarlo a la longitud de mi archivo de texto? Además, ¿no querría usar char, not byte?

Sí, y sí ... y como han dicho otras respuestas, ha elegido un ejemplo con varios errores.

Sin embargo, hay un problema teórico al hacer ambas cosas; es decir, establecer la longitud del búfer en la longitud del archivo y usando un búfer de caracteres en lugar de un búfer de bytes. El problema es que el tamaño del archivo se mide en bytes, pero el tamaño del búfer debe medirse en caracteres. Esto normalmente es correcto, pero es teóricamente posible que necesitará más caracteres que el tamaño del archivo en bytes; p.ej. si el archivo de entrada usó un conjunto de caracteres de 6 bits y empaquetó 4 caracteres en 3 bytes.