Reihenfolge der Klassen zur Verbesserung der Leistung Zugriff auf eine Datei mit gepufferten Lesegeräten

Question

Ich habe einen Eingabedatenstrom von einem http-Aufruf zurückgegeben. Ich muss es als json analysieren und ich benutze die Bibliothek "simplejson".

Da der JSON-Parser als Eingabe einen Reader akzeptiert, muss ich den Input-Stream transformieren. Ich habe die folgenden zwei Optionen und ich würde gerne wissen, ob es offensichtliche Gründe gibt, eines der anderen vorzuziehen.

Option 1: Wickeln des Eingangsstroms mit einer Instanz von Input und dann wickeln den Leser mit einer BufferedReader:

jsonObject = (JSONObject)new JSONParser().parse(
     new BufferedReader(new InputStreamReader(method.getResponseBodyAsStream(), "UTF-8"))); 

Option 2: Wickeln des Eingangsstroms mit einem BufferedInputStream und dann wickeln mit einem Input:

jsonObject = (JSONObject)new JSONParser().parse(
     new InputStreamReader(new BufferedInputStream(method.getResponseBodyAsStream()), "UTF-8")); 

die erste Option scheint besser, aber ich frage mich, ob ich die Antwort Pufferung zweimal am Ende kann: sowohl die BufferedReader und der InputStreamReader verfügen über Methoden zum Lesen aus einem Puffer.

checkte ich besser den Code in dem JSON-Parser und es sieht aus wie die Methode in Reader wird mit einer Reihe von Zeichen zu erhalten:

/** 
    * Refills the input buffer. 
    * 
    * @return  <code>false</code>, iff there was new input. 
    * 
    * @exception java.io.IOException if any I/O-Error occurs 
    */ 
    private boolean zzRefill() throws java.io.IOException { 

    /* first: make room (if you can) */ 
    if (zzStartRead > 0) { 
     System.arraycopy(zzBuffer, zzStartRead, 
         zzBuffer, 0, 
         zzEndRead-zzStartRead); 

     /* translate stored positions */ 
     zzEndRead-= zzStartRead; 
     zzCurrentPos-= zzStartRead; 
     zzMarkedPos-= zzStartRead; 
     zzStartRead = 0; 
    } 

    /* is the buffer big enough? */ 
    if (zzCurrentPos >= zzBuffer.length) { 
     /* if not: blow it up */ 
     char newBuffer[] = new char[zzCurrentPos*2]; 
     System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length); 
     zzBuffer = newBuffer; 
    } 

    /* finally: fill the buffer with new input */ 
    int numRead = zzReader.read(zzBuffer, zzEndRead, 
              zzBuffer.length-zzEndRead); 

    if (numRead > 0) { 
     zzEndRead+= numRead; 
     return false; 
    } 
    // unlikely but not impossible: read 0 characters, but not at end of stream  
    if (numRead == 0) { 
     int c = zzReader.read(); 
     if (c == -1) { 
     return true; 
     } else { 
     zzBuffer[zzEndRead++] = (char) c; 
     return false; 
     }  
    } 

    // numRead < 0 
    return true; 
    } 

Ich denke, die Antwort ist, dass die BufferedReader nicht notwendig sind, überhaupt und dass es einen Unterschied macht, es zu benutzen, weil wir es zweimal puffern würden.

Answer 1

BufferedReader ist etwas schwer, da es Linientrenner verstehen und handhaben muss. Ihr Fall scheint das nicht zu verlangen, also können Sie mit InputStreamReader auf BufferedInputStream gehen.