Giriş akışından verimli bir şekilde Android Okuma

Yaptığım bir android uygulaması için bir web sitesine bir HTTP alma isteği yapıyorum.

Bir DefaultHttpClient ve isteği vermek için HttpGet kullanıyorum. Varlık yanıtı almak ve bu sayfanın html almak için bir InputStream nesnesi elde.

Daha sonra aşağıdaki gibi cevap verme döngüsü:

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

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

Ancak bu çok yavaş.

Bu verimsiz mi? Büyük bir web sayfası yüklemiyorum - www.cokezone.co.uk, böylece dosya boyutu büyük değil. Bunu yapmanın daha iyi bir yolu var mı?

Teşekkürler

Andy

Kodunuzdaki sorun, çok sayıda ağır Stringnesne oluşturması , içeriklerini kopyalaması ve üzerlerinde işlemler gerçekleştirmesidir. Bunun yerine, her ekte StringBuilderyeni Stringnesneler oluşturmaktan ve karakter dizilerini kopyalamaktan kaçınmak için kullanmalısınız. Davanız için uygulama şu şekilde olacaktır:

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

Artık totaldönüştürmeden kullanabilirsiniz String, ancak sonuca a olarak ihtiyacınız varsa şunları Stringeklemeniz yeterlidir:

Dize sonucu = total.toString ();

Daha iyi açıklamaya çalışacağım ...

• a += b(veya a = a + b), nerede ave bDizeleri, kopyalar içeriği olan hem a ve b (siz de kopyalama o notta Yeni bir nesneye aiçeren, birikmiş String ) ve her tekrarında bu kopyaları yapıyoruz.
• a.append(b), nerede abir StringBuilder, biçeriği doğrudan ekler a, böylece her yinelemede biriken dizeyi kopyalamazsınız.

Bir akışı bir dizeye dönüştürmek için yerleşik yöntemi denediniz mi? Apache Commons kütüphanesinin (org.apache.commons.io.IOUtils) bir parçasıdır.

O zaman kodunuz şu tek satır olur:

String total = IOUtils.toString(inputStream);

Bununla ilgili belgeleri burada bulabilirsiniz: http://commons.apache.org/io/api-1.4/org/apache/commons/io/IOUtils.html#toString%28java.io.InputStream%29

Apache Commons IO kütüphanesi buradan indirilebilir: http://commons.apache.org/io/download_io.cgi

Guava ile başka bir olasılık:

bağımlılık: compile 'com.google.guava:guava:11.0.2'

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

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

Bu yeterince verimli olduğuna inanıyorum ... Bir InputStream bir dize almak için aşağıdaki yöntemi çağırır:

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

Her zaman UTF-8 kullanıyorum. Elbette, InputStream öğesinin yanında karakter kümesini bağımsız değişken olarak ayarlayabilirsiniz.

Peki buna ne dersin. Daha iyi performans veriyor gibi görünüyor.

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

Edit: Aslında bu tür hem çelikbytes hem de Maurice Perry's kapsar

Muhtemelen Jaime Soriano'nun cevabından biraz daha hızlı ve Adrian'ın cevabının çok baytlı kodlama problemleri olmadan şunları öneririm:

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

Belki daha sonra 'bir seferde bir satır' okuyun ve dizelere katılın, satır sonu taramasından kaçınmak ve dize birleştirmelerinden kaçınmak için 'mevcut olanları oku' seçeneğini deneyin.

yani InputStream.available()veInputStream.read(byte[] b), int offset, int length)

Bir kerede bir metin satırı okumak ve adı geçen satırı bir dizeye ayrı ayrı eklemek, her satırı ayıklamak ve çok sayıda yöntem çağrısının ek yükü için zaman alıcıdır.

Akış verilerini tutmak için düzgün boyutlu bir bayt dizisi ayırarak ve gerektiğinde yinelemeli olarak daha büyük bir dizi ile değiştirilerek ve dizi tutabildiği kadar okumaya çalışarak daha iyi performans elde etmeyi başardım.

Bazı nedenlerden dolayı, kod HTTPUrlConnection tarafından döndürülen InputStream'i kullandığında Android tekrar tekrar tüm dosyayı indiremedi, bu yüzden tüm dosyayı alacağımı veya iptal edeceğimden emin olmak için hem BufferedReader hem de elle yuvarlanan bir zaman aşımı mekanizması kullanmak zorunda kaldım transfer.

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: İçeriğin yeniden kodlanması gerekmiyorsa (yani içeriği OLDUĞUNU istiyorsanız) Reader alt sınıflarından hiçbirini kullanmamanız gerektiği ortaya çıkıyor. Uygun Stream alt sınıfını kullanmanız yeterlidir.

2 ila 3 kat fazla hızlandırmak için önceki yöntemin başlangıcını aşağıdaki satırlarla değiştirin .

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

Dosya uzunsa, her satır için bir String birleştirme kullanmak yerine bir StringBuilder ekleyerek kodunuzu optimize edebilirsiniz.

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

InputStream öğesini String'e dönüştürmek için BufferedReader.readLine () yöntemini kullanırız. BufferedReader null değerine dönene kadar yineliyoruz , yani okunacak başka veri yok. Her satır bir StringBuilder öğesine eklenir ve String olarak döndürülür.

 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();
    }
}`

Ve son olarak dönüştürmek istediğiniz herhangi bir sınıftan işlevi çağırın

String dataString = Utils.convertStreamToString(in);

tamamlayınız

Tüm verileri okumak için kullanıyorum:

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