code: public Stream<String> lines() {
          Iterator<String> iter = new Iterator<String>() {
              String nextLine = null;
  
              @Override
              public boolean hasNext() {
                  if (nextLine != null) {
                      return true;
                  } else {
                      try {
                          nextLine = readLine(true);
                          return (nextLine != null);
                      } catch (IOException e) {
                          throw new UncheckedIOException(e);
                      }
                  }
              }
  
              @Override
              public String next() {
                  if (nextLine != null || hasNext()) {
                      String line = nextLine;
                      nextLine = null;
                      return line;
                  } else {
                      throw new NoSuchElementException();
                  }
              }
          };
          return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
                  iter, Spliterator.ORDERED | Spliterator.NONNULL), false);
      }
docs: Returns a {@code Stream}, the elements of which are lines read from
  this {@code BufferedReader}.  The {@link Stream} is lazily populated,
  i.e., read only occurs during the
  <a href="../util/stream/package-summary.html#StreamOps">terminal
  stream operation</a>.
  
  <p> The reader must not be operated on during the execution of the
  terminal stream operation. Otherwise, the result of the terminal stream
  operation is undefined.
  
  <p> After execution of the terminal stream operation there are no
  guarantees that the reader will be at a specific position from which to
  read the next character or line.
  
  <p> If an {@link IOException} is thrown when accessing the underlying
  {@code BufferedReader}, it is wrapped in an {@link
  UncheckedIOException} which will be thrown from the {@code Stream}
  method that caused the read to take place. This method will return a
  Stream if invoked on a BufferedReader that is closed. Any operation on
  that stream that requires reading from the BufferedReader after it is
  closed, will cause an UncheckedIOException to be thrown.
  
  @return a {@code Stream<String>} providing the lines of text
  described by this {@code BufferedReader}
  
  @since 1.8