读取输入流的 N 行并以相反的顺序打印而不使用数组或列表类型结构？

Question

使用 BufferedReader 的 readLine() 方法，可以在不使用列表或数组的情况下以相反的顺序打印流的前 N ​​行吗？

Answer 1

我认为你可以通过递归来做到这一点，例如：

void printReversed(int n)
{
   String line = reader.readLine();

   if (n > 0)
     printReversed(n-1);

   System.out.println(line);
}

Answer 2

这里你有另一种选择，基于 BufferedReader & StringBuilder 操作。就所需的计算机资源而言更易于管理。

public void reversePrint(BufferedReader bufReader, int lines) throws IOException {
    BufferedReader resultBufferReader = null;
    {
        String line;
        StringBuilder sb = new StringBuilder();
        int count = 0;
        while (count++<lines && (line = bufReader.readLine())!=null) {
            sb.append('\n'); // restore new line marker for BufferedReader to consume.
            sb.append(new StringBuilder(line).reverse());
        }
        resultBufferReader = new BufferedReader(new StringReader(sb.reverse().toString()));
    }
    {           
        String line;
        while ((line = resultBufferReader.readLine())!=null) {
            System.out.println(line);
        }
    }
}

Answer 3

怎样用递归来颠倒顺序呢？

伪代码：

reverse(int linesLeft)
   if (linesLeft == 0)
      return;
   String line = readLine();
   reverse(linesLeft - 1);
   System.out.println(line);

Answer 4

好问题。这里您有一种基于协调线程的解决方案。尽管它占用大量资源（1 个线程/缓冲区行），但它可以在给定的限制内解决您的问题。我很好奇看到其他解决方案。

public class ReversedBufferPrinter {

    class Worker implements Runnable {
           private final CountDownLatch trigger;
           private final CountDownLatch release;
           private final String  line;

           Worker(String line, CountDownLatch release) {
              this.trigger = new CountDownLatch(1);
              this.release = release;
              this.line = line;
           }

           public CountDownLatch getTriggerLatch() {
               return trigger;
           }

           public void run() {
              try {
                  trigger.await();
              } catch (InterruptedException ex) { } // handle 
              work();
              release.countDown();  
           }

           void work() { 
               System.out.println(line);
           }
    } 

    public void reversePrint(BufferedReader reader, int lines) throws IOException {
        CountDownLatch initialLatch = new CountDownLatch(1);
        CountDownLatch triggerLatch = initialLatch; 
        int count=0;
        String line;
        while (count++<lines && (line = reader.readLine())!=null) {
            Worker worker = new Worker(line, triggerLatch);
            triggerLatch = worker.getTriggerLatch();
            new Thread(worker).start();
        }
        triggerLatch.countDown();
        try {
            initialLatch.await();
        } catch (InterruptedException iex) {
            // handle
        }
    }

    public static void main(String [] params) throws Exception {
        if (params.length<2) { 
            System.out.println("usage: ReversedBufferPrinter <file to reverse> <#lines>");
        }
        String filename = params[0];
        int lines = Integer.parseInt(params[1]);
        File file = new File(filename);
        BufferedReader reader = new BufferedReader(new FileReader(file));
        ReversedBufferPrinter printer = new ReversedBufferPrinter();
        printer.reversePrint(reader, lines);
    }
}

Answer 5

它还需要隐式数据结构，但您可以生成线程，按顺序运行它们，并使每个线程读取一行并等待较短的时间。结果将是：最后一个线程将首先运行，第一个线程将最后运行，每个线程都打印其行。 （它们之间的间隔必须足够大，以确保大的“安全裕度”）

我不知道如何（如果有的话）在没有显式/隐式数据存储的情况下完成这一点。

Answer 6

将您读取的每一行添加到一个字符串中，然后打印该字符串。如果您读完了所有行，只需打印您所拥有的内容即可。

或者，如果您确定拥有的行数，并且不希望使用字符串：

void printReversed(int n, BufferedReader reader)
{
   LineNumberReader lineReader = new LineNumberReader(reader);

   while (--i >= 0)
   {
      lineReader.setLineNumber(i); 
      System.out.println(lineReader.readLine());    
   }
}