我可以偷看一BufferedReader?

Question

有没有办法检查，如果在 BufferedReader 对象是一些阅读？像C++ cin.peek().谢谢。

Answer 1

您可以尝试“布尔就绪（）”方法。 从Java API 6文档：“A缓冲字符流准备好，如果缓冲器不是空的，或者如果基础字符流已准备就绪。”

BufferedReader r = new BufferedReader(reader);
if(r.ready())
{
   r.read();
}

Answer 2

可以使用 PushbackReader 。使用您可以读取一个字符，然后未读它。这基本上可以让你将其推回。

PushbackReader pr = new PushbackReader(reader);
char c = (char)pr.read();
// do something to look at c
pr.unread((int)c); //pushes the character back into the buffer

Answer 3

下面的代码将着眼于在流的第一个字节。应当成为你偷看。

BufferedReader bReader = new BufferedReader(inputStream);
bReader.mark(1);
int byte1 = bReader.read();
bReader.reset();

Answer 4

通常的惯用语是检查一循环，如果 BufferedReader#readLine() 不返回 null.如果结束流达到(例如文件结尾处，插座封闭，等等)，然后返回 null.

E.g。

BufferedReader reader = new BufferedReader(someReaderSource);
String line = null;
while ((line = reader.readLine()) != null) {
    // ...
}

如果你不想读线(这是通过方式的主要原因 BufferedReader 是被选中)，那么使用 BufferedReader#ready() 取而代之的是：

BufferedReader reader = new BufferedReader(someReaderSource);
while (reader.ready()) {
    int data = reader.read();
    // ...
}

Answer 5

BufferedReader br = new BufferedReader(reader);
br.mark(1);
int firstByte = br.read();
br.reset();

Answer 6

您可以使用 PushBackReader 读取一个字符，然后“推回”。你肯定知道的东西在那里，不影响其整体状态的方式 - 一个“窥视”

Answer 7

这pgmura答案（依托就绪（）方法）是简单和作品。 但请记住，这是因为Sun的实施方法;它并没有真正与文档一致。我不会依赖，如果这种行为是至关重要的。 看到这里 http://bugs.sun.com/bugdatabase/view_bug.do？ bug_id = 4090471 我宁愿去与PushbackReader选项。

Answer 8

我的解决办法是..延伸的BufferedReader和使用队列作为BUF，那么您可以在队列使用PEEK方法。

public class PeekBufferedReader extends BufferedReader{

    private Queue<String>       buf;
    private int                 bufSize;

    public PeekBufferedReader(Reader reader, int bufSize) throws IOException {
        super(reader);
        this.bufSize = bufSize;
        buf = Queues.newArrayBlockingQueue(bufSize);
    }

    /**
     * readAheadLimit is set to 1048576. Line which has length over readAheadLimit 
     * will cause IOException.
     * @throws IOException 
     **/
    //public String peekLine() throws IOException {
    //  super.mark(1048576);
    //  String peekedLine = super.readLine();
    //  super.reset();
    //  return peekedLine;
    //}

    /**
     * This method can be implemented by mark and reset methods. But performance of 
     * this implementation is better ( about 2times) than using mark and reset  
     **/
    public String peekLine() throws IOException {
        if (buf.isEmpty()) {
            while (buf.size() < bufSize) {
                String readLine = super.readLine();
                if (readLine == null) {
                    break;
                } else {
                    buf.add(readLine);
                }
            }
        } else {
            return buf.peek();
        }
        if (buf.isEmpty()) {
            return null;
        } else {
            return buf.peek();
        }
    }

    public String readLine() throws IOException {
        if (buf.isEmpty()) {
            while (buf.size() < bufSize) {
                String readLine = super.readLine();
                if (readLine == null) {
                    break;
                } else {
                    buf.add(readLine);
                }
            }
        } else {
            return buf.poll();
        }
        if (buf.isEmpty()) {
            return null;
        } else {
            return buf.poll();
        }
    }
    public boolean isEmpty() throws IOException {
        if (buf.isEmpty()) {
            while (buf.size() < bufSize) {
                String readLine = super.readLine();
                if (readLine == null) {
                    break;
                } else {
                    buf.add(readLine);
                }
            }
        } else {
            return false;
        }
        if (buf.isEmpty()) {
            return true;
        } else {
            return false;
        }
    }
}