Comment lire un fichier texte à partir de “l'actif” du répertoire sous forme de chaîne de caractères?

Vous pouvez ouvrir un flux d'entrée à l'aide de AssetsManager.

InputStream input = getAssets().open("origin");
Reader reader = new InputStreamReader(input, "UTF-8");

getAssets() est une méthode de la Context classe.

Notez également que vous ne devez pas recréer un tampon de caractères (buf = new char[1024], la dernière ligne de votre cycle).

OriginalL'auteur Roman Mazur

Réponse courte, ce faire:

public static String readFile( String filePath ) throws IOException
{
    Reader reader = new FileReader( filePath );
    StringBuilder sb = new StringBuilder(); 
    char buffer[] = new char[16384];  //read 16k blocks
    int len; //how much content was read? 
    while( ( len = reader.read( buffer ) ) > 0 ){
        sb.append( buffer, 0, len ); 
    }
    reader.close();
    return sb.toString();
}

C'est très simple, très rapide, et fonctionne bien pour les déraisonnable de gros fichiers texte (+de 100 MO)

---

Réponse longue:

(Code à la fin)

À plusieurs reprises, il n'a pas d'importance, mais cette méthode est assez rapide et tout à fait lisible. En fait, c'est un ordre de complexité plus vite que @Raceimation réponse -- O(n) au lieu de O(n^2).

J'ai testé six méthodes (de lent à rapide):

• concat: la lecture ligne par ligne, concat avec str += ... *Ce est longue, très lente, même pour les petits fichiers (~70 secondes pour un fichier de 3 mo) *
• strbuilder deviner longueur: StringBuilder, initialisé avec la taille des fichiers. je devine que sa lente parce qu'il essaie vraiment de trouver de telles une grande partie de la mémoire linéaire.
• strbuilder avec tampon de ligne: StringBuilder, le fichier est lu ligne par ligne
• strbuffer avec char[] tampon: Concat avec StringBuffer, de lire le fichier dans 16k blocs
• strbuilder avec char[] tampon: Concat avec StringBuilder, de lire le fichier dans 16k blocs
• préallouer byte[filesize] tampon: l'allocation d'un byte[] buffer de la taille du fichier et de laisser l'api java de décider de la façon de tampon de blocs individuels.

Conclusion:

Preallocating le tampon entièrement est le plus rapide sur de très gros fichiers, mais la méthode n'est pas très polyvalent, car le total de la taille du fichier doit être connu à l'avance. C'est pourquoi je suggère d'utiliser strBuilder avec char[] tampons, il est toujours simple et, si nécessaire, facilement changable à accepter tout flux d'entrée au lieu de simplement les fichiers. Pourtant, c'est certainement assez rapide pour toutes les mesures raisonnables cas.

Résultats Du Test + Code

import java.io.*; 
public class Test
{
static final int N = 5; 
public final static void main( String args[] ) throws IOException{
test( "1k.txt", true ); 
test( "10k.txt", true ); 
//concat with += would take ages here, so we skip it
test( "100k.txt", false ); 
test( "2142k.txt", false ); 
test( "pruned-names.csv", false ); 
//ah, what the heck, why not try a binary file
test( "/Users/hansi/Downloads/xcode46graphicstools6938140a.dmg", false );
}
public static void test( String file, boolean includeConcat ) throws IOException{
System.out.println( "Reading " + file + " (~" + (new File(file).length()/1024) + "Kbytes)" ); 
strbuilderwithchars( file ); 
strbuilderwithchars( file ); 
strbuilderwithchars( file ); 
tick( "Warm up... " ); 
if( includeConcat ){
for( int i = 0; i < N; i++ )
concat( file ); 
tick( "> Concat with +=                  " ); 
}
else{
tick( "> Concat with +=   **skipped**    " ); 
}
for( int i = 0; i < N; i++ )
strbuilderguess( file ); 
tick( "> StringBuilder init with length  " ); 
for( int i = 0; i < N; i++ )
strbuilder( file ); 
tick( "> StringBuilder with line buffer  " );
for( int i = 0; i < N; i++ )
strbuilderwithchars( file ); 
tick( "> StringBuilder with char[] buffer" );
for( int i = 0; i < N; i++ )
strbufferwithchars( file ); 
tick( "> StringBuffer with char[] buffer " );
for( int i = 0; i < N; i++ )
singleBuffer( file ); 
tick( "> Allocate byte[filesize]         " );
System.out.println(); 
}
public static long now = System.currentTimeMillis(); 
public static void tick( String message ){
long t = System.currentTimeMillis(); 
System.out.println( message + ": " + ( t - now )/N + " ms" ); 
now = t; 
}
//StringBuilder with char[] buffer
//+ works if filesize is unknown
//+ pretty fast 
public static String strbuilderwithchars( String filePath ) throws IOException
{
Reader reader = new FileReader( filePath );
StringBuilder sb = new StringBuilder(); 
char buffer[] = new char[16384];  //read 16k blocks
int len; //how much content was read? 
while( ( len = reader.read( buffer ) ) > 0 ){
sb.append( buffer, 0, len ); 
}
reader.close();
return sb.toString();
}
//StringBuffer with char[] buffer
//+ works if filesize is unknown
//+ faster than stringbuilder on my computer
//- should be slower than stringbuilder, which confuses me 
public static String strbufferwithchars( String filePath ) throws IOException
{
Reader reader = new FileReader( filePath );
StringBuffer sb = new StringBuffer(); 
char buffer[] = new char[16384];  //read 16k blocks
int len; //how much content was read? 
while( ( len = reader.read( buffer ) ) > 0 ){
sb.append( buffer, 0, len ); 
}
reader.close();
return sb.toString();
}
//StringBuilder init with length
//+ works if filesize is unknown
//- not faster than any of the other methods, but more complicated
public static String strbuilderguess(String filePath) throws IOException
{
File file = new File( filePath ); 
BufferedReader reader = new BufferedReader(new FileReader(file));
String line;
StringBuilder sb = new StringBuilder( (int)file.length() ); 
while( ( line = reader.readLine() ) != null)
{
sb.append( line ); 
}
reader.close();
return sb.toString();
}
//StringBuilder with line buffer
//+ works if filesize is unknown
//+ pretty fast 
//- speed may (!) vary with line length
public static String strbuilder(String filePath) throws IOException
{
BufferedReader reader = new BufferedReader(new FileReader(filePath));
String line;
StringBuilder sb = new StringBuilder(); 
while( ( line = reader.readLine() ) != null)
{
sb.append( line ); 
}
reader.close();
return sb.toString();
}
//Concat with += 
//- slow
//- slow
//- really slow
public static String concat(String filePath) throws IOException
{
BufferedReader reader = new BufferedReader(new FileReader(filePath));
String line, results = "";
int i = 0; 
while( ( line = reader.readLine() ) != null)
{
results += line;
i++; 
}
reader.close();
return results;
}
//Allocate byte[filesize]
//+ seems to be the fastest for large files
//- only works if filesize is known in advance, so less versatile for a not significant performance gain
//+ shortest code
public static String singleBuffer(String filePath ) throws IOException{
FileInputStream in = new FileInputStream( filePath );
byte buffer[] = new byte[(int) new File( filePath).length()];  //buffer for the entire file
int len = in.read( buffer ); 
return new String( buffer, 0, len ); 
}
}
/**
*** RESULTS ***
Reading 1k.txt (~31Kbytes)
Warm up... : 0 ms
> Concat with +=                  : 37 ms
> StringBuilder init with length  : 0 ms
> StringBuilder with line buffer  : 0 ms
> StringBuilder with char[] buffer: 0 ms
> StringBuffer with char[] buffer : 0 ms
> Allocate byte[filesize]         : 1 ms
Reading 10k.txt (~313Kbytes)
Warm up... : 0 ms
> Concat with +=                  : 708 ms
> StringBuilder init with length  : 2 ms
> StringBuilder with line buffer  : 2 ms
> StringBuilder with char[] buffer: 1 ms
> StringBuffer with char[] buffer : 1 ms
> Allocate byte[filesize]         : 1 ms
Reading 100k.txt (~3136Kbytes)
Warm up... : 7 ms
> Concat with +=   **skipped**    : 0 ms
> StringBuilder init with length  : 19 ms
> StringBuilder with line buffer  : 21 ms
> StringBuilder with char[] buffer: 9 ms
> StringBuffer with char[] buffer : 9 ms
> Allocate byte[filesize]         : 8 ms
Reading 2142k.txt (~67204Kbytes)
Warm up... : 181 ms
> Concat with +=   **skipped**    : 0 ms
> StringBuilder init with length  : 367 ms
> StringBuilder with line buffer  : 372 ms
> StringBuilder with char[] buffer: 208 ms
> StringBuffer with char[] buffer : 202 ms
> Allocate byte[filesize]         : 199 ms
Reading pruned-names.csv (~11200Kbytes)
Warm up... : 23 ms
> Concat with +=   **skipped**    : 0 ms
> StringBuilder init with length  : 54 ms
> StringBuilder with line buffer  : 57 ms
> StringBuilder with char[] buffer: 32 ms
> StringBuffer with char[] buffer : 31 ms
> Allocate byte[filesize]         : 32 ms
Reading /Users/hansi/Downloads/xcode46graphicstools6938140a.dmg (~123429Kbytes)
Warm up... : 1665 ms
> Concat with +=   **skipped**    : 0 ms
> StringBuilder init with length  : 2899 ms
> StringBuilder with line buffer  : 2978 ms
> StringBuilder with char[] buffer: 2702 ms
> StringBuffer with char[] buffer : 2684 ms
> Allocate byte[filesize]         : 1567 ms
**/

Ps. Vous avez peut-être remarqué que StringBuffer est légèrement plus rapide que le StringBuilder. C'est un peu un non-sens car les classes sont les mêmes, à l'exception de StringBuilder n'est pas synchronisé. Si quelqu'un peut (ou ne peut pas reproduire ça... je suis plus curieux 🙂

OriginalL'auteur kritzikratzi

Vous devriez essayer org.appache.commons.io.IOUtils.toString(InputStream is) à obtenir un contenu de fichier en tant que chaîne de caractères. De là, vous pouvez passer InputStream objet qui vous permettra d'obtenir de

getAssets().open("xml2json.txt")

dans votre Activity.

Pour obtenir String utiliser ceci:

String xml = IOUtils.toString((getAssets().open("xml2json.txt")));

OriginalL'auteur Sanket Patel