[RESOLVIDO] Como ler cadeia de caracteres maior que 8kb com BufferedInputStream?

Evite ao máximo usar bis.available porque ele só funciona direito para arquivos em disco. Encontre uma outra forma para montar sua string. Além disso, ler um byte de cada vez (como você fez) não é “kosher”.

Bom, eu leio Streams assim:

InputStream inputStream; // Vem de algum canto a stream
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
byte [] buffer = new byte[8192]; // 8192 eh a quantidade de bytes que 'tentara' ser lida por vez
int len = -1;
do {
  len = inputStream.read(buffer); // len tera a quantidade de bytes lidos do buffer
  if(len != -1) { // se foi lido bytes da stream
    outputStream.write(buffer, 0, len); // escreve os bytes lidos
  }
} while(len != -1);

byte [] content = outputStream.toByteArray(); // a stream lida
String s = new String(content); // Os bytes em forma de texto

Um exemplo;

import java.net.*;
import java.io.*;

class TestePegarURL {
    public static void main (String[] args) throws Exception {
	    String baseURL = args[0];
		URL url = new URL (baseURL);
		URLConnection conn = url.openConnection();
		InputStream is = conn.getInputStream();
		BufferedInputStream bis = new BufferedInputStream (is);
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		byte[] buffer = new byte[1024];
		int nBytesLidos;
		while ((nBytesLidos = bis.read (buffer)) >= 0) {
		    baos.write (buffer, 0, nBytesLidos);
		}
		bis.close();
		// Digamos que o web service forneça os dados em UTF-8
		byte[] bytes = baos.toByteArray();
		baos.close();
		String lido = new String (bytes, "UTF-8");
		System.out.println (lido);
		System.out.println (bytes.length);
	}
}

Oi!

Sei que foi apenas um exemplo, mas e se por acaso superar os 1024?
Como foi comentado anteriormente, não é recomendavél utilizar o avaible(), qual seria a recomendação para alocar o tamanho correto do buffer?

Eu testei com uma página bem grande, de 300KB. Pus um buffer de 1 KB mas isso é irrelevante (o BufferedInputStream tem um buffer interno de 8 KB por padrão).

Certo, confesso que entendo um pouco apenas da api IO.
Então, uma pergunta, porque alocando apenas 1KB para o buffer e o BufferInputStream tendo um padrão interno de 8KB, é possível realizar a leitura de uma página de 300KB? Que tipo de alocação ele faz?

Pois, se não aloca, entendo que não seria o contéudo de 300KB que é apresentado no console, mas somente o que foi possível alocar no InputStream.
E para finalizar, o mesmo tamanho de buffer padrão do BufferedInputStream é o do BufferOutputStream?

Grato.

Você olhou o ByteArrayOutputStream? É lá que guardamos os bytes que já foram lidos. (O lsjunior deu exatamente a mesma solução).

A mudança do tamanho do buffer impacta no desempenho. Faz um teste com o buffer de 1024, outro com 8192 e um lendo byte a byte, usando read() e veja o tempo que cada um demora. Dependendo da situação um buffer muito grande pode ficar mais lento.

Era a isso que eu me referia. A leitura que eu realizo de buffer é igual ao que o entanglement demonstrou.
Dificilmente aloco mais que 1KB quando realizo a leitura, mas agora consegui entender melhor essa questão

nel:

Oi!

Sei que foi apenas um exemplo, mas e se por acaso superar os 1024?
Como foi comentado anteriormente, não é recomendavél utilizar o avaible(), qual seria a recomendação para alocar o tamanho correto do buffer?

Em uma requisição HTTP vc pode saber o tamanho da resposta usando o cabecalho ‘Content-Lengh’, mas mesmo assim não e aconselhavel ler o arquivo todo de uma vez, por que o servidor provavelmente enviara alguns bytes e o cliente pensará qiue a requisição terminou.

Veja os gerenciadores de download, que vão baixando o arquivo pedaco por pedaco, o buffer faz exatamente a mesma coisa.

Estava com o mesmo problema, mas usando o array de byte como os exemplos acima, deu tudo certo.

Agradeço a todos pelas respostas.
Tentei a dica do lsjunior e deu certo.