Why it is throwing null at last whenever i am running this program

Question

public static void main(String args[])
          String str;                    
          try     
          FileReader fis = new FileReader(C:\\src\\vinaysingh\\xmlreq.xml");
          BufferedReader br= new BufferedReader(fis);
          do
               str=br.readLine();
               System.out.println(str);
          while(!str.equals(null));
why it is throwing null on last if i am reading any xml file

Answer 1

get the value of string as the value which u
had collected from the string instead of nullWhat? That just doesn't make any sense. At all.
I presume what you're asking is:
How do I read lines from a text file, ignoring empty lines. Especially how do I know when I've reached the end of the file so that I can stop trying to read more lines.
this might help some ...
package krc.utilz.io;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.io.File;
import java.io.Reader;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.Closeable;
import java.io.IOException;
import java.io.FileNotFoundException;
* @class: krc.utilz.io.Filez
* A collection of static "file handling" helper methods.
public abstract class Filez
  public static final int BFRSIZE = 4096;
   * reads the given file into one big string.<p>
   * Warning: don't use this on big files. It uses too much RAM!
   * @param String filename - the name of the file to read
   * @return the contents filename
  public static String read(String filename)
    throws FileNotFoundException
    return Filez.read(new FileReader(filename));
   * Reads the contents of the given reader into one big string, and closes
   * the reader.
   * Warning: don't use this on big files. It uses too much RAM!
   * @param java.io.Reader reader - a subclass of Reader to read from.
   * @return the whole contents of the given reader.
  public static String read(Reader in)
    try {
      StringBuffer out = new StringBuffer();
      try {
        char[] bfr = new char[BFRSIZE];
        int n = 0;
        while( (n=in.read(bfr,0,BFRSIZE)) > 0 ) {
          out.append(bfr,0,n);
      } finally {
        if(in!=null)in.close();
      return out.toString();
    } catch (IOException e) {
      throw new RuntimeIOException(e.getMessage(), e);
   * (re)writes the given content to the given filename
   * @param String content - the new contents of the fil
   * @param String filename - the name of the file to write.
  public static void write(String content, String filename) {
    try {
      PrintWriter out = null;
      try {
        out = new PrintWriter(new FileWriter(filename));
        out.write(content);
      } finally {
        if(out!=null)out.close();
    } catch (IOException e) {
      throw new RuntimeIOException(e.getMessage(), e);
   * Appends the given content to the given filename.
   * @param String content - the string to write to the file.
   * @param String filename - the name of the file to write to.
  public static void append(String content, String filename) {
    try {
      PrintWriter out = null;
      try {
        out = new PrintWriter(new FileWriter(filename, true)); //true=append
        out.write(content);
      } finally {
        if(out!=null)out.close();
    } catch (IOException e) {
      throw new RuntimeIOException(e.getMessage(), e);
   * reads each line of the given file into an array of strings.
   * @param String filename - the name of the file to read
   * @return a fixed length array of strings containing file contents.
  public  static String[] readArray(String filename)
    throws FileNotFoundException
    return readList(filename).toArray(new String[0]);
   * reads each line of the given file into an ArrayList of strings.
   * @param String filename - the name of the file to read
   * @return an ArrayList of strings containing file contents.
  public static ArrayList<String> readArrayList(String filename)
    throws FileNotFoundException
    return (ArrayList<String>)readList(filename);
   * reads each line of the given file into a List of strings.
   * @param String filename - the name of the file to read
   * @return an List handle ArrayList of strings containing file contents.
  public static List<String> readList(String filename)
    throws FileNotFoundException
    try {
      BufferedReader in = null;
      List<String> out = new ArrayList<String>();
      try {
        in = new BufferedReader(new FileReader(filename));
        String line = null;
        while ( (line = in.readLine()) != null ) {
          out.add(line);
      } finally {
        if(in!=null)in.close();
      return out;
    } catch (IOException e) {
      throw new RuntimeIOException(e.getMessage(), e);
   * reads the whole of the given file into an array of bytes.
   * @param String filename - the name of the file to read
   * @return an array of bytes containing the file contents.
  public static byte[] readBytes(String filename)
    throws FileNotFoundException
    return( readBytes(new File(filename)) );
   * reads the whole of the given file into an array of bytes.
   * @param File file - the file to read
   * @return an array of bytes containing the file contents.
  public static byte[] readBytes(File file)
    throws FileNotFoundException
    try {
      byte[] out = null;
      InputStream in = null;
      try {
        in = new FileInputStream(file);
        out = new byte[(int)file.length()];
        int size = in.read(out);
      } finally {
        if(in!=null)in.close();
      return out;
    } catch (IOException e) {
      throw new RuntimeIOException(e.getMessage(), e);
   * do files A & B have the same contents
   * @param String filenameA - the first file to compare
   * @param String filenameA - the second file to compare
   * @return boolean do-these-two-files-have-the-same-contents?
  public static boolean isSame(String filenameA, String filenameB)
    throws FileNotFoundException
    try {
      File fileA = new File(filenameA);
      File fileB = new File(filenameB);
      //check for same physical file
      if( fileA.equals(fileB) ) return(true);
      //compare sizes
      if( fileA.length() != fileB.length() ) return(false);
      //compare contents (buffer by buffer)
      boolean same=true;
      InputStream inA = null;
      InputStream inB = null;
      try {
        inA = new FileInputStream(fileA);
        inB = new FileInputStream(fileB);
        byte[] bfrA = new byte[BFRSIZE];
        byte[] bfrB = new byte[BFRSIZE];
        int sizeA=0, sizeB=0;
        do {
          sizeA = inA.read(bfrA);
          sizeB = inA.read(bfrB);
          if ( sizeA != sizeB ) {
            same = false;
          } else if ( sizeA == 0 ) {
            //do nothing
          } else if ( !Arrays.equals(bfrA,bfrB) ) {
            same = false;
        } while (same && sizeA != -1);
      } finally {
        Clozer.close(inA, inB);
      return(same);
    } catch (IOException e) {
      throw new RuntimeIOException(e.getMessage(), e);
   * checks the given filename exists and is readable
   * @param String filename = the name of the file to "open".
   * @param OPTIONAL String type = a short name for the file used to identify
   *  the file in any exception messages.
   *  For example: "input", "input data", "DTD", "XML", or whatever.
   * @return a File object for the given filename.
   * @throw FileNotFoundException if the given file does not exist.
   * @throw IOException if the given file is unreadable (usually permits).
  public static File open(String filename)
    throws FileNotFoundException
    return(open(filename,"input"));
  public static File open(String filename, String type)
    throws FileNotFoundException
    try {
      File file = new File(filename);
      String fullname = file.getCanonicalPath();
      if(!file.exists()) throw new FileNotFoundException(type+" file does not exist: "+fullname);
      if(!file.canRead()) throw new RuntimeIOException(type+" file is not readable: "+fullname);
      return(file);
    } catch (IOException e) {
      throw new RuntimeIOException(e.getMessage(), e);
   * gets the filename-only portion of a canonical-filename, with or without
   * the extension.
   * @param String path - the full name of the file.
   * OPTIONAL @param boolean cutExtension - if true then remove any .ext
   * @return String the filename-only (with or without extension)
  public static String basename(String path) {
    return(basename(path,false));
  public static String basename(String path, boolean cutExtension)
    String fname = (new File(path)).getName();
    if (cutExtension) {
      int i = fname.lastIndexOf(".");
      if(i>0) fname = fname.substring(0,i);
    return(fname);
}You'll probably want to remove all references to RuntimeIOException... just throw the standard checked IOException instead.