printf funcionalidade () em Java combinado com um CharBuffer ou algo parecido

Question

Estou um pouco confuso aqui.

Eu gostaria de fazer algo parecido com isto:

1. criar algum tipo de tampão eu posso escrever em
2. limpar o buffer
3. usar um printf () - como função várias vezes para acrescentar um monte de coisas para o buffer com base em alguns cálculos complicados Eu só quero fazer uma vez
4. usar o conteúdo do buffer e imprimi-lo a vários objetos PrintStream
5. repita os passos 2-4 conforme necessário

por exemplo:.

SuperBuffer sb = new SuperBuffer();
  /* SuperBuffer is not a real class, so I don't know what to use here */
PrintStream[] streams = new PrintStream[N];
/* ... initialize this array to several streams ... */

while (!done)
{
    sb.clear();
    sb.printf("something %d something %d something %d", 
        value1, value2, value3);
    if (some_complicated_condition())
        sb.printf("something else %d something else %d", value4, value5);
    /* ... more printfs to sb ... */
    for (PrintStream ps : streams)
        ps.println(sb.getBuffer());
}

Parece que embrulho um PrintWriter StringWriter vai fazer o que eu quero para o objeto sb acima, exceto que não há método clear(). Acho que eu poderia criar uma nova PrintWriter e StringWriter objeto cada vez através do loop, mas que parece ser uma dor. (No meu código real eu fazer isso em vários lugares, não apenas uma vez em um circuito ...)

Eu também tenho java.nio.CharBuffer usadas e outro NIO buffers muito, e que parece ser uma abordagem promissora, mas eu não sei como eu pode envolvê-los com um objeto que me dará printf() funcionalidade.

algum conselho?

Answer 1

ah: Eu acho que eu tenho. A Formatter classe tem um format() método que é como printf(), e pode ser construído para envolver qualquer tipo de objeto que implementa Appendable. CharBuffer implementos Appendable, e eu pode clear() ou ler o conteúdo do CharBuffer conforme necessário.

Answer 2

Por que é uma dor para criar um novo tampão no circuito? Isso é o que o coletor de lixo está lá para. Não seria necessário uma nova alocação sob as cobertas de qualquer maneira clara ().

Se você realmente deseja implementar seu superbuffer, não seria tão difícil em tudo. Basta criar uma subclasse de OutputStream com uma função clear (), e em seguida, enrole uma PrintStream em torno disso. Você poderia usar um CharBuffer em seu buffer de super se você queria.

Answer 3

Considere a criação de uma subclasse, TeeOutputStream, de OutputStream (ou Writer) que mantém sua matriz de córregos e delegados para eles. Em seguida, enrole o seu fluxo com um PrintStream (ou PrintWriter) e printf chamada apenas () sobre ele. Não há necessidade de um buffer temporário ou qualquer coisa:

PrintStream[] streams = new PrintStream[N]; // any output streams really
PrintStream ps = new PrintStream(new TeeOutputStream(streams));

while (!done)
{
    ps.printf("something %d something %d something %d",
              value1, value2, value3);    
    if (some_complicated_condition())
        ps.printf("something else %d something else %d", value4, value5);
    ps.println();
}