I am in daze suddenly by this simple question

Question

warning: [deprecation]readLine() in java.io.DataInputStream has been deprecated.
How to modify it?
Thanks
void inputscan( fileInfo pinfo ) throws IOException
       String linebuffer;
       pinfo.maxLine = 0;
       while ((linebuffer = pinfo.file.readLine()) != null) // this line gets a warning
          storeline( linebuffer, pinfo );
import java.io.*;
/** This is the info kept per-file.     */
class fileInfo {   
  static final int MAXLINECOUNT = 20000;
  DataInputStream file;  /* File handle that is open for read.  */
  public int maxLine;  /* After input done, # lines in file.  */
  node symbol[]; /* The symtab handle of each line. */
  int other[]; /* Map of line# to line# in other file */
                                /* ( -1 means don't-know ).            */
        /* Allocated AFTER the lines are read. */
   * Normal constructor with one filename; file is opened and saved.
  fileInfo( String filename, DataOutputStream  out) {
    symbol = new node [ MAXLINECOUNT+2 ];
    symbol[0].setbufferwriter(out);
    other  = null;    // allocated later!
    try {
      file = new DataInputStream(
        new FileInputStream( filename));
    } catch (IOException e) {
        System.err.println("Diff can't read file " +
        filename );
        System.err.println("Error Exception was:" + e );
        System.exit(1);
class node{                       /* the tree is made up of these nodes */
  node pleft, pright;
  int linenum;
  static final int freshnode = 0,
  oldonce = 1, newonce = 2, bothonce = 3, other = 4;
  static DataOutputStream out;
  int /* enum linestates */ linestate;
  String line;
  static node panchor = null;    /* symtab is a tree hung from this */
   * Construct a new symbol table node and fill in its fields.
   * @param        string  A line of the text file
  node( String pline )
       pleft = pright = null;
       linestate = freshnode;
       /* linenum field is not always valid */    
       line = pline;
   * matchsymbol       Searches tree for a match to the line.
   * @param  String  pline, a line of text
   * If node's linestate == freshnode, then created the node.
  static void setbufferwriter(DataOutputStream  x)
       out = x;
  static node matchsymbol( String pline )
       int comparison;
       node pnode = panchor;
       if ( panchor == null ) return panchor = new node( pline);
       for(;;) {
      comparison = pnode.line.compareTo(pline);
      if ( comparison == 0 ) return pnode;          /* found */
      if ( comparison < 0 ) {
           if ( pnode.pleft == null ) {
          pnode.pleft = new node( pline);
          return pnode.pleft;
           pnode = pnode.pleft;
      if ( comparison > 0 ) {
           if ( pnode.pright == null ) {
          pnode.pright = new node( pline);
          return pnode.pright;
           pnode = pnode.pright;
       /* NOTE: There are return stmts, so control does not get here. */
   * addSymbol(String pline) - Saves line into the symbol table.
   * Returns a handle to the symtab entry for that unique line.
   * If inoldfile nonzero, then linenum is remembered.
  static node addSymbol( String pline, boolean inoldfile, int linenum )
    node pnode;
    pnode = matchsymbol( pline );  /* find the node in the tree */
    if ( pnode.linestate == freshnode ) {
      pnode.linestate = inoldfile ? oldonce : newonce;
    } else {
      if (( pnode.linestate == oldonce && !inoldfile ) ||
          ( pnode.linestate == newonce &&  inoldfile ))
           pnode.linestate = bothonce;
      else pnode.linestate = other;
    if (inoldfile) pnode.linenum = linenum;
    return pnode;
  }

Answer 1

If you read the docs for that method, you'll see this:
As of JDK 1.1, the preferred way to read lines of text is via the BufferedReader.readLine() method. Programs that use the DataInputStream class to read lines can be converted to use the BufferedReader class by replacing code of the form:
DataInputStream d = new DataInputStream(in);
with:
BufferedReader d
= new BufferedReader(new InputStreamReader(in));