Android Lesen aus einem Eingabestream effizient

Ich mache eine HTTP-Get-Anfrage an eine Website für eine Android-Anwendung, die ich mache.

Ich verwende einen DefaultHttpClient und HttpGet, um die Anforderung auszugeben. Ich erhalte die Entitätsantwort und erhalte daraus ein InputStream-Objekt zum Abrufen des HTML-Codes der Seite.

Ich gehe dann die Antwort wie folgt durch:

BufferedReader r = new BufferedReader(new InputStreamReader(inputStream));
String x = "";
x = r.readLine();
String total = "";

while(x!= null){
total += x;
x = r.readLine();
}

Dies ist jedoch schrecklich langsam.

Ist das ineffizient? Ich lade keine große Webseite - www.cokezone.co.uk, daher ist die Dateigröße nicht groß. Gibt es einen besseren Weg, dies zu tun?

Vielen Dank

Andy

Das Problem in Ihrem Code besteht darin, dass viele schwere StringObjekte erstellt, deren Inhalt kopiert und Operationen an ihnen ausgeführt werden. Verwenden Sie stattdessen, um StringBuilderzu vermeiden, dass Stringan jedem Anhang neue Objekte erstellt werden, und um zu vermeiden, dass die char-Arrays kopiert werden. Die Implementierung für Ihren Fall wäre ungefähr so:

BufferedReader r = new BufferedReader(new InputStreamReader(inputStream));
StringBuilder total = new StringBuilder();
for (String line; (line = r.readLine()) != null; ) {
    total.append(line).append('\n');
}

Sie können es jetzt verwenden, totalohne es zu konvertieren. StringWenn Sie das Ergebnis jedoch als benötigen String, fügen Sie einfach Folgendes hinzu:

String result = total.toString ();

Ich werde versuchen, es besser zu erklären ...

• a += b(oder a = a + b), wobei aund bZeichenfolgen sind, kopiert den Inhalt von beiden a und b in ein neues Objekt (beachten Sie, dass Sie auch kopieren a, das die akkumulierten enthält String), und Sie kopieren diese bei jeder Iteration.
• a.append(b), wo aist ein StringBuilder, hängt den bInhalt direkt an a, sodass Sie die akkumulierte Zeichenfolge nicht bei jeder Iteration kopieren.

Haben Sie die integrierte Methode zum Konvertieren eines Streams in einen String ausprobiert? Es ist Teil der Apache Commons-Bibliothek (org.apache.commons.io.IOUtils).

Dann wäre Ihr Code diese eine Zeile:

String total = IOUtils.toString(inputStream);

Die Dokumentation dazu finden Sie hier: http://commons.apache.org/io/api-1.4/org/apache/commons/io/IOUtils.html#toString%28java.io.InputStream%29

Die Apache Commons IO-Bibliothek kann hier heruntergeladen werden: http://commons.apache.org/io/download_io.cgi

Eine andere Möglichkeit mit Guave:

Abhängigkeit: compile 'com.google.guava:guava:11.0.2'

import com.google.common.io.ByteStreams;
...

String total = new String(ByteStreams.toByteArray(inputStream ));

Ich glaube, das ist effizient genug ... Um einen String aus einem InputStream zu erhalten, würde ich die folgende Methode aufrufen:

public static String getStringFromInputStream(InputStream stream) throws IOException
{
    int n = 0;
    char[] buffer = new char[1024 * 4];
    InputStreamReader reader = new InputStreamReader(stream, "UTF8");
    StringWriter writer = new StringWriter();
    while (-1 != (n = reader.read(buffer))) writer.write(buffer, 0, n);
    return writer.toString();
}

Ich benutze immer UTF-8. Neben InputStream können Sie natürlich auch den Zeichensatz als Argument festlegen.

Was ist damit? Scheint eine bessere Leistung zu geben.

byte[] bytes = new byte[1000];

StringBuilder x = new StringBuilder();

int numRead = 0;
while ((numRead = is.read(bytes)) >= 0) {
    x.append(new String(bytes, 0, numRead));
}

Bearbeiten: Eigentlich umfasst diese Art sowohl Steelbytes als auch Maurice Perrys

Möglicherweise etwas schneller als Jaime Sorianos Antwort, und ohne die Multi-Byte-Codierungsprobleme von Adrians Antwort schlage ich vor:

File file = new File("/tmp/myfile");
try {
    FileInputStream stream = new FileInputStream(file);

    int count;
    byte[] buffer = new byte[1024];
    ByteArrayOutputStream byteStream =
        new ByteArrayOutputStream(stream.available());

    while (true) {
        count = stream.read(buffer);
        if (count <= 0)
            break;
        byteStream.write(buffer, 0, count);
    }

    String string = byteStream.toString();
    System.out.format("%d bytes: \"%s\"%n", string.length(), string);
} catch (IOException e) {
    e.printStackTrace();
}

Vielleicht lesen Sie lieber "eine Zeile nach der anderen" und verbinden Sie die Zeichenfolgen. Versuchen Sie "Alle verfügbaren lesen", um das Scannen nach Zeilenende und das Verknüpfen von Zeichenfolgen zu vermeiden.

dh InputStream.available()undInputStream.read(byte[] b), int offset, int length)

Das Lesen von jeweils einer Textzeile und das Anhängen dieser Zeile an eine Zeichenfolge ist sowohl beim Extrahieren jeder Zeile als auch beim Overhead so vieler Methodenaufrufe zeitaufwändig.

Ich konnte eine bessere Leistung erzielen, indem ich ein Byte-Array mit angemessener Größe für die Stream-Daten zuordnete, das bei Bedarf iterativ durch ein größeres Array ersetzt wird, und versuchte, so viel zu lesen, wie das Array aufnehmen konnte.

Aus irgendeinem Grund konnte Android wiederholt nicht die gesamte Datei herunterladen, wenn der Code den von HTTPUrlConnection zurückgegebenen InputStream verwendete. Daher musste ich sowohl einen BufferedReader als auch einen handgerollten Timeout-Mechanismus verwenden, um sicherzustellen, dass ich entweder die gesamte Datei erhalten oder abbrechen würde die Übertragung.

private static  final   int         kBufferExpansionSize        = 32 * 1024;
private static  final   int         kBufferInitialSize          = kBufferExpansionSize;
private static  final   int         kMillisecondsFactor         = 1000;
private static  final   int         kNetworkActionPeriod        = 12 * kMillisecondsFactor;

private String loadContentsOfReader(Reader aReader)
{
    BufferedReader  br = null;
    char[]          array = new char[kBufferInitialSize];
    int             bytesRead;
    int             totalLength = 0;
    String          resourceContent = "";
    long            stopTime;
    long            nowTime;

    try
    {
        br = new BufferedReader(aReader);

        nowTime = System.nanoTime();
        stopTime = nowTime + ((long)kNetworkActionPeriod * kMillisecondsFactor * kMillisecondsFactor);
        while(((bytesRead = br.read(array, totalLength, array.length - totalLength)) != -1)
        && (nowTime < stopTime))
        {
            totalLength += bytesRead;
            if(totalLength == array.length)
                array = Arrays.copyOf(array, array.length + kBufferExpansionSize);
            nowTime = System.nanoTime();
        }

        if(bytesRead == -1)
            resourceContent = new String(array, 0, totalLength);
    }
    catch(Exception e)
    {
        e.printStackTrace();
    }

    try
    {
        if(br != null)
            br.close();
    }
    catch(IOException e)
    {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

EDIT: Es stellt sich heraus , dass , wenn Sie nicht den Inhalt neucodierte haben müssen (dh der Inhalt wollen AS IS ) Sie sollten keine der Reader - Subklassen verwenden. Verwenden Sie einfach die entsprechende Stream-Unterklasse.

Ersetzen Sie den Anfang der vorhergehenden Methode durch die entsprechenden Zeilen der folgenden, um sie zwei- bis dreimal zu beschleunigen .

String  loadContentsFromStream(Stream aStream)
{
    BufferedInputStream br = null;
    byte[]              array;
    int                 bytesRead;
    int                 totalLength = 0;
    String              resourceContent;
    long                stopTime;
    long                nowTime;

    resourceContent = "";
    try
    {
        br = new BufferedInputStream(aStream);
        array = new byte[kBufferInitialSize];

Wenn die Datei lang ist, können Sie Ihren Code optimieren, indem Sie ihn an einen StringBuilder anhängen, anstatt für jede Zeile eine String-Verkettung zu verwenden.

    byte[] buffer = new byte[1024];  // buffer store for the stream
    int bytes; // bytes returned from read()

    // Keep listening to the InputStream until an exception occurs
    while (true) {
        try {
            // Read from the InputStream
            bytes = mmInStream.read(buffer);

            String TOKEN_ = new String(buffer, "UTF-8");

            String xx = TOKEN_.substring(0, bytes);

Um den InputStream in String zu konvertieren, verwenden wir die BufferedReader.readLine () -Methode. Wir iterieren, bis der BufferedReader null zurückgibt , was bedeutet, dass keine Daten mehr zu lesen sind. Jede Zeile wird an einen StringBuilder angehängt und als String zurückgegeben.

 public static String convertStreamToString(InputStream is) {

        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder sb = new StringBuilder();

        String line = null;
        try {
            while ((line = reader.readLine()) != null) {
                sb.append(line + "\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }
}`

Und schließlich rufen Sie aus jeder Klasse, in die Sie konvertieren möchten, die Funktion auf

String dataString = Utils.convertStreamToString(in);

Komplett

Ich bin es gewohnt, vollständige Daten zu lesen:

// inputStream is one instance InputStream
byte[] data = new byte[inputStream.available()];
inputStream.read(data);
String dataString = new String(data);