Welcome to Experts Exchange

Add your voice to the tech community where 5M+ people, just like you, are talking about what matters.

  • Help others & share knowledge
  • Earn cash & points
  • Learn & ask questions
Solved

Xerces parsing problem

Posted on 2004-10-11
9
173 Views
Last Modified: 2013-11-23
I am programmatically parsing xml files using xerces.
I created the schema and the xml files.
I am getting an error in that the setTagValue(String value) method is sometimes being passed only a part of the string as the parameter.
The parameter is a string representing a date.
It is defined in the schema as a string:

<xsd:element name="day_date" minOccurs="1" maxOccurs="1">
   <xsd:simpleType base="xsd:string"/>
</xsd:element>

As an example, I would expect "value" parameter to be  "01x18x1999" but it is "01x"
The error is consistent in that the same dates show up as errors each run.
I have checked the xml files, they are fine, e.g:

<day>
    <day_date>01x18x1988</day_date>
    <max_air_temp>10.89</max_air_temp>
    <min_air_temp>1.39</min_air_temp>
    <average_air_temp>5.03</average_air_temp>
</day>

It repeats the same errors each run, so they are not random, seemingly.
In a total of about 7800 of these dates, the error occurs 20 times.

What can i do?

btw, the reason i have 01x18x1988 instead of 01/18/1988 is that i was checking to see if the / was causing the problem
0
Comment
Question by:allelopath
  • 5
  • 3
9 Comments
 
LVL 5

Expert Comment

by:Naeemg
ID: 12284211
First convert your date to String then pass it to etValue method. can you show your code please?

Naeem Shehzad Ghuman
0
 
LVL 86

Expert Comment

by:CEHJ
ID: 12284987
This could be a SAX-related issue. Please post your 'collecting' code
0
 
LVL 1

Author Comment

by:allelopath
ID: 12286691
Naeemg,
As I stated previously, the date is already a string (xsd:string)

CEHJ,
by collecting code...do you mean the code with methods like setTagValue, startElement, endElement?
0
Free Tool: Site Down Detector

Helpful to verify reports of your own downtime, or to double check a downed website you are trying to access.

One of a set of tools we are providing to everyone as a way of saying thank you for being a part of the community.

 
LVL 1

Author Comment

by:allelopath
ID: 12288267

public class Parser2 extends DefaultHandler implements Runnable
{

StringBuffer errorMessage;
String[] filenames;
boolean fileValid = true;
Stack stack;

Weibull weibull;

Vector yearVector; // # of elements = # of XML files
Vector dayVector; // # of elements = 365

Year year;  
Day day;
Latitude latitude;
Longitude longitude;
UTM utm;
Elevation elevation;

DatabaseInfo databaseInfo;
DocumentationInfo documentationInfo;

// true if in a state where we are ready to accept a value
// (for the parameter at the top of the stack)
boolean lookingForValue = false;

// true if the associated tag has been set for this species object
// false if it has not yet been set

boolean setOriginalFilename = false;
boolean setDescription = false;
boolean setSite = false;

boolean setLatitudeDegrees  = false;
boolean setLatitudeMinutes  = false;
boolean setLatitudeSeconds  = false;
boolean setLongitudeDegrees  = false;
boolean setLongitudeMinutes  = false;
boolean setLongitudeSeconds  = false;

boolean setUTMNorthing = false;
boolean setUTMEasting = false;
boolean setUTMElevation = false;

boolean setElevationMeters = false;
boolean setElevationFeet = false;

boolean setDatabaseInfo_Filename = false;
boolean setDatabaseInfo_Date = false;
boolean setDatabaseInfo_Name = false;

boolean setDocumentationInfo_Date = false;
boolean setDocumentationInfo_Name = false;

boolean setDataAcknowledgement = false;
boolean setVariableDescription = false;

boolean setStartDay = false;
// day
boolean[] setDay; // array of 365

boolean setDate = false; // String
boolean setMaxAirTemp = false; // float
boolean setMinAirTemp = false; // float
boolean setAvgAirTemp = false; // float
boolean setMaxRelativeHumidity = false; // float
boolean setMinRelativeHumidity = false; // float
boolean setPrecipitation = false; // float
boolean setAvgWindSpeed = false; // float
boolean setMaxWindSpeed = false; // float
boolean setAvgWindVectorMagnitude = false; // float;
boolean setAvgWindVectorDirection = false; // int
boolean setTotalSolarRadiation = false; // float
boolean setSoilTemp = false; // float
boolean setAvgDayWindSpeed = false; // float
boolean setAvgNightWindSpeed = false; // float
boolean setDewTemp = false; // float
boolean setHourCountExceptAir = false; // int
boolean setHourCountAir = false; // int
boolean setRainGaugeType = false; // String
// end day

// true if we have added the current day to the dayVector
boolean addedDayToVector = false;

/**
 *  constructor
 *
 */
public Parser2(String[] s)
{
  super();

  weibull = Weibull_Wrapper.instance();
 
  filenames = s; // get the filenames

  stack = new Stack();// implement a stack to get values

  dayVector = new Vector(); // # of elements = # of XML files

  setDay = new boolean[Constants.DAYS_PER_YEAR];
 
  resetTagMarkers();
 
} // end constructor


////////////////////////////////////////////////////////////////////
// Event handlers.
////////////////////////////////////////////////////////////////////


/**
 *   startDocument
 *
 */
public void startDocument ()
{
}


/**
 *  endDocument
 *
 */
public void endDocument ()
{  
  errorMessage.append(" is valid"); // file is valid
}


/**
 *  
 *
 */public void startElement (String uri,
                                       String name,
                                       String qName,
                                       Attributes atts)
{

  if ("".equals (uri))
  {
    stack.push (qName); // push  this element onto stack
    lookingForValue = true;
  }
  else
  {
    //System.out.println("Start element: {" + uri + "}" + name);
  }
 
  if (qName.equals(XML.DAY) && (setStartDay == false))
  {
    // instantiate new day object since start DAY tag has been found
    day = new Day();
    resetTagMarkers();
    setStartDay = true; // will set it to false again when </day> is found
    addedDayToVector = false;

  }

}


 /**
  *  endElement
  *
  * @param uri
  * @param name
  * @param qName name of element
  *
  *
  */public void endElement (String uri, String name, String qName)
{
//   System.out.println ("Parser.endElement(): uri = " + uri + ",  name = " + name + ", qName = " + qName);

  if ("".equals (uri))
  {
    //System.out.println("End element: " + qName);
    lookingForValue = false;
    String topName = (String) stack.pop(); // pop element from stack
    if (! topName.equals(qName) )
    {
      System.out.println ("Parser.endElement(): Stack error on pop:  topName = " + topName + "  qName = " + qName);
    }

    // if we just popped the end day tag then
    // add the current Day object to the list
    // and start over
    // don't add one day at a time to year object
    // build the dayVector then add it to the year object
    //
    // will instantiate new day object when start DAY tag is found
    if (topName.equals(XML.DAY))
    {
      //System.out.println ("Parser.endElement(): uri = " + uri + ",  name = " + name + ", qName = " + qName);
      //System.out.println ("Date:  " + day.getDate());
      //System.out.println();
     
      // it appears that this method is being called for start and end tags, at least in the case of <day> </day>
      // and hence each day is being added twice
      // check if date of current day and date of previous day are the same,
      // if not, then add day to vector
      // previous day is last element of day vector      
      // if date of current day not equal to date of previous day then
     
      if (dayVector.size() > 0) // if dayVector not empty
      {
        Day prevDay = (Day) dayVector.lastElement();
        if (day.getDate() != prevDay.getDate())
        {
          dayVector.add(day);    
//          System.out.println ("Date:  " + day.getDate());
        }
      }
      else // day vector is empty
      {
        dayVector.add(day);    
//        System.out.println ("Date:  " + day.getDate());
       
      }
      // only necessary to reset day tags here
      resetTagMarkersDay();
    }
    // if end of year then add dayVector to Year
    // add Year to Weibull
    else if (topName.equals(XML.DAILY_DATA))
    {
//      System.out.println ("Parser.endElement(): uri = " + uri + ",  name = " + name + ", qName = " + qName);
//      System.out.println ("Daily Data:  " + dayVector.hashCode());
//      System.out.println();

      // must do new Vector because it is passed by reference and the the dayVector.clear() clears the one in year
      year.setDayVector(new Vector(dayVector));
      weibull.addYear(year);

      resetTagMarkers();
      dayVector.clear(); // erase all entries in the dayVector (for this year)
    }
  }
  else
  {
    // System.out.println("End element:   {" + uri + "}" + name);
  }
}


  /**
   *  characters
   *
   * @param ch[]
   * @param start
   * @param length
   *
   */
public void characters (char ch[], int start, int length)
{
//  System.out.println ("Parser.characters(): ch[0] = " + ch[0] + ",  start = " + start + ", length = " + length);
  for (int i = start; i < start + length; i++)
  {
    switch (ch[i])
    {
    case '\\':
//      System.out.print("\\\\");
      break;
    case '"':
//      System.out.print("\\\"");
      break;
    case '\n':
//      System.out.print("\\n");
      break;
    case '\r':
//      System.out.print("\\r");
      break;
    case '\t':
//      System.out.print("\\t");
      break;
    case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j':
    case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't':
    case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
    case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J':
    case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T':
    case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':

      String value = new String (ch, start, length);
      setTagValue(value.trim());
      break;

    default:
//      System.out.print(ch[i]);
//      String value = new String (ch, start, length);
//      setTagValue(value);

      break;
    }
}

//System.out.print("\"\n");
}


/**
 *  getErrorMessage
 *
 */
public String getErrorMessage()
{
  return errorMessage.toString();
}


/**
 *  getErrorMessageBuffer
 *
 */
public StringBuffer getErrorMessageBuffer()
{
  return errorMessage;
}


/**
 *  getFileIsvalid
 *
 */
public boolean getFileIsvalid()
{
  return fileValid;
}


/**
 *  run
 *
 * called as thread, from LTERClimatePanel.parse()
 */
public void run()
{
  // The error message starts with the filename

  XMLReader xr = null;
  try
  {
    xr = XMLReaderFactory.createXMLReader();
  }
  catch (SAXException e)
  {
    System.out.println(" ***** Error ***** " + e);  
    errorMessage.append(" ***** Error ***** " + e);
    fileValid = false;
  }
 
  xr.setContentHandler(this);
  xr.setErrorHandler(this);

  // this will loop once for each year of data
  for (int i=0; i < filenames.length; i++)
  {

    String currentFile = filenames[i];
    // if the file is valid, append words saying so
    // if not valid, exceptions are appended
    errorMessage = new StringBuffer (currentFile);

    // new object for each year
    year = new Year();
   

    // Parse each file provided on the command line.
    try
    {
      FileReader r = new FileReader(currentFile);
      xr.parse(new InputSource(r));
    }
    catch (FileNotFoundException e)
    {
      System.out.println(" ***** Error ***** " + e);  
      errorMessage.append(" ***** Error ***** " + e);
      fileValid = false;
    }
    catch (IOException e)
    {
      System.out.println(" ***** Error ***** " + e);  
      errorMessage.append(" ***** Error ***** " + e);
      fileValid = false;
    }
    catch (SAXException e)
    {
      System.out.println(" ***** Error ***** " + e);  
      errorMessage.append(" ***** Error ***** " + e);
      fileValid = false;
    }
    System.out.println(errorMessage.toString()); // prints 'filename' is valid (one hopes)
  }
  System.out.println();
  System.out.println("All XML files have been read and stored in memory");

 
  Vector v = weibull.getYearVector();

}


/**
 * set the value specified for the appropriate tag
 *
 * this method is called once for each character in a tag
 * e.g. <mytag>sevench</mytag> would cause it to be called 7 times
 * the setMytag boolean prevents from setting it 7 times,
 * but still this is not very efficient
 *
 *  topOfStack will be some tag value, e.g. mytag where as
 *  value will be the value in that tag, e.g. sevench
 *
 * @param value the value to set (not the tag)
 */
public void setTagValue(String value)
{

//  System.out.println("Parser.setTagValue(): value = " + value);  
  String topOfStack = (String) stack.peek();
//  System.out.println("Parser.setTagValue(): topOfStack = " + topOfStack);  
 
  try
  {    
   
    Integer i = new Integer(-9999);  
    Float f = new Float(-9999.99);

    // use either Integer or Float based on topOfStack
    // if this is a float then
    if ( (topOfStack.equals(XML.MAXIMUM_AIR_TEMP))   ||
         (topOfStack.equals(XML.MINIMUM_AIR_TEMP)) ||
         (topOfStack.equals(XML.AVERAGE_AIR_TEMP)) ||
         (topOfStack.equals(XML.MAX_RELATIVE_HUMIDITY)) ||
         (topOfStack.equals(XML.MIN_RELATIVE_HUMIDITY)) ||
         (topOfStack.equals(XML.PRECIPITATION)) ||
         (topOfStack.equals(XML.AVG_WINDSPEED)) ||
         (topOfStack.equals(XML.MAX_WINDSPEED)) ||
         (topOfStack.equals(XML.AVG_WIND_VECTOR_MAGNITUDE)) ||
         (topOfStack.equals(XML.TOTAL_SOLAR_RADIATION)) ||
         (topOfStack.equals(XML.SOIL_TEMP)) ||
         (topOfStack.equals(XML.AVG_DAY_WIND_SPEED)) ||
         (topOfStack.equals(XML.AVG_NIGHT_WIND_SPEED)) ||
         (topOfStack.equals(XML.DEW_TEMP)) )
    {
      f = Float.valueOf(value); // convert String to Float
    }
    // else if this is an integer then
    else if ( (topOfStack.equals(XML.LAT_DEGREES))   ||
                (topOfStack.equals(XML.LAT_MINUTES))   ||
                (topOfStack.equals(XML.LAT_SECONDS))   ||
                (topOfStack.equals(XML.LON_DEGREES))   ||
                (topOfStack.equals(XML.LON_MINUTES))   ||
                (topOfStack.equals(XML.LON_SECONDS))   ||
                (topOfStack.equals(XML.AVG_WIND_VECTOR_DIRECTION))   ||
                (topOfStack.equals(XML.HOUR_COUNT_EXCEPT_AIR)) ||
                (topOfStack.equals(XML.HOUR_COUNT_AIR)) )
    {
      i = Integer.valueOf(value);  // convert String to Integer
    }
    else // not int or float, must be string
    {
       // System.out.println ("Parser.setTagValue(): String value = " + value);
    }

    // int
      if ( topOfStack.equals(XML.LAT_DEGREES) && (setLatitudeDegrees == false))
      {
        year.getLatitude().setDegrees(i.intValue());
        setLatitudeDegrees = true;
      }
      else if ( topOfStack.equals(XML.LAT_MINUTES) && (setLatitudeMinutes == false))
      {
        year.getLatitude().setMinutes(i.intValue());
        setLatitudeMinutes = true;
      }
      else if ( topOfStack.equals(XML.LAT_SECONDS) && (setLatitudeSeconds == false))
      {
        year.getLatitude().setSeconds(i.intValue());
        setLatitudeSeconds = true;
      }
      if ( topOfStack.equals(XML.LON_DEGREES) && (setLongitudeDegrees == false))
      {
        year.getLongitude().setDegrees(i.intValue());
        setLongitudeDegrees = true;
      }
      else if ( topOfStack.equals(XML.LON_MINUTES) && (setLongitudeMinutes == false))
      {
        year.getLongitude().setMinutes(i.intValue());
        setLongitudeMinutes = true;
      }
      else if ( topOfStack.equals(XML.LON_SECONDS) && (setLongitudeSeconds == false))
      {
        year.getLongitude().setSeconds(i.intValue());
        setLongitudeSeconds = true;
      }    
// which day are we getting here...this is not correct ------------------------
      else if ( topOfStack.equals(XML.AVG_WIND_VECTOR_DIRECTION) && (setAvgWindVectorDirection == false))
      {
        day.setAvgWindVectorDirection(i.intValue());
        setAvgWindVectorDirection = true;
      }    
      else if ( topOfStack.equals(XML.HOUR_COUNT_EXCEPT_AIR) && (setHourCountExceptAir == false))
      {
        day.setHourCountExceptAir(i.intValue());
        setHourCountExceptAir = true;
      }    
      else if ( topOfStack.equals(XML.HOUR_COUNT_AIR) && (setHourCountAir == false))
      {
        day.setHourCountAir(i.intValue());
        setHourCountAir = true;
      }    

      // float
      else if ( topOfStack.equals(XML.MAXIMUM_AIR_TEMP) && (setMaxAirTemp == false))
      {
        day.setMaxAirTemp(f.floatValue());
        setMaxAirTemp = true;
      }
      else if ( topOfStack.equals(XML.MINIMUM_AIR_TEMP) && (setMinAirTemp == false))
      {
        day.setMinAirTemp(f.floatValue());
        setMinAirTemp = true;
      }
      else if ( topOfStack.equals(XML.AVERAGE_AIR_TEMP) && (setAvgAirTemp == false))
      {
        day.setAvgAirTemp(f.floatValue());
        setAvgAirTemp = true;
      }
      else if ( topOfStack.equals(XML.MAX_RELATIVE_HUMIDITY) && (setMaxRelativeHumidity == false))
      {
        day.setMaxRelativeHumidity(f.floatValue());
        setMaxRelativeHumidity = true;
      }
      else if ( topOfStack.equals(XML.MIN_RELATIVE_HUMIDITY) && (setMinRelativeHumidity == false))
      {
        day.setMinRelativeHumidity(f.floatValue());
        setMinRelativeHumidity = true;
      }
      else if ( topOfStack.equals(XML.PRECIPITATION) && (setPrecipitation == false))
      {
        day.setPrecipitation(f.floatValue());
        setPrecipitation = true;
      }
      else if ( topOfStack.equals(XML.AVG_WINDSPEED) && (setAvgWindSpeed == false))
      {
        day.setAvgWindSpeed(f.floatValue());
        setAvgWindSpeed = true;
      }
      else if ( topOfStack.equals(XML.MAX_WINDSPEED) && (setMaxWindSpeed == false))
      {
        day.setMaxWindSpeed(f.floatValue());
        setMaxWindSpeed = true;
      }
      else if ( topOfStack.equals(XML.AVG_WIND_VECTOR_MAGNITUDE) && (setAvgWindVectorMagnitude == false))
      {
        day.setAvgWindVectorMagnitude(f.floatValue());
        setAvgWindVectorMagnitude = true;
      }
      else if ( topOfStack.equals(XML.TOTAL_SOLAR_RADIATION) && (setTotalSolarRadiation == false))
      {
        day.setTotalSolarRadiation(f.floatValue());
        setTotalSolarRadiation = true;
      }
      else if ( topOfStack.equals(XML.SOIL_TEMP) && (setSoilTemp == false))
      {
        day.setSoilTemp(f.floatValue());
        setSoilTemp = true;
      }
      else if ( topOfStack.equals(XML.AVG_DAY_WIND_SPEED) && (setAvgDayWindSpeed == false))
      {
        day.setAvgDayWindSpeed(f.floatValue());
        setAvgDayWindSpeed = true;
      }
      else if ( topOfStack.equals(XML.AVG_NIGHT_WIND_SPEED) && (setAvgNightWindSpeed == false))
      {
        day.setAvgNightWindSpeed(f.floatValue());
        setAvgNightWindSpeed = true;
      }
      else if ( topOfStack.equals(XML.DEW_TEMP) && (setDewTemp == false))
      {
        day.setDewTemp(f.floatValue());
        setDewTemp = true;
      }
      // strings
      else if (topOfStack.equals(XML.ORIGINAL_FILENAME))
      {
        year.setOriginalFilename(value);
        setOriginalFilename = true;
      }
      else if (topOfStack.equals(XML.DESCRIPTION))
      {
        year.setDescription(value);
        setDescription = true;
      }
      else if (topOfStack.equals(XML.SITE))
      {
        year.setSite(value);
        setSite = true;
      }
      else if (topOfStack.equals(XML.DB_FILENAME))
      {
        year.setDatabaseInfo_Filename (value);
        setDatabaseInfo_Filename = true;
      }
      else if (topOfStack.equals(XML.DB_DATE))
      {
        year.setDatabaseInfo_Date(value);
        setDatabaseInfo_Date = true;
      }
      else if (topOfStack.equals(XML.DB_NAME))
      {
        year.setDatabaseInfo_Name(value);
        setDatabaseInfo_Name = true;
      }
      else if (topOfStack.equals(XML.DOC_DATE))
      {
        year.setDocumentationInfo_Date(value);
        setDocumentationInfo_Date = true;
      }
      else if (topOfStack.equals(XML.DOC_NAME))
      {
        year.setDocumentationInfo_Name(value);
        setDocumentationInfo_Name = true;
      }

      else if (topOfStack.equals(XML.DAY_DATE) && (setDate == false))
      {
        if (value.equalsIgnoreCase("01x17x1988")) // debug
        {
          int x = 0;
        }
        day.setDate(value);
        setDate = true;
      }
      // no action, at least for now
      else if (topOfStack.equals(XML.LTER_CLIMATE_CONNECTION))
      {
        // nothing to do
      }
      else if (topOfStack.equals(XML.YEARLY_CLIMATE_DATA))
      {
        // nothing to do
      }
  }
  catch(Exception e)
  {
    System.out.println ("Parser: setTagValue(): Exception" + e);
  }    
     
} // end setTagValue


/**
 * reset _all_ the tag markers to false
 *
 */
private void resetTagMarkers()
{

   setOriginalFilename = false;
   setDescription = false;
   setSite = false;

   setLatitudeDegrees  = false;
   setLatitudeMinutes  = false;
   setLatitudeSeconds  = false;
   setLongitudeDegrees  = false;
   setLongitudeMinutes  = false;
   setLongitudeSeconds  = false;

   setUTMNorthing = false;
   setUTMEasting = false;
   setUTMElevation = false;

   setElevationMeters = false;
   setElevationFeet = false;

   setDatabaseInfo_Filename  = false;
   setDatabaseInfo_Date  = false;
   setDatabaseInfo_Name  = false;

   setDocumentationInfo_Date  = false;
   setDocumentationInfo_Name  = false;

   setDataAcknowledgement = false;
   setVariableDescription = false;

    for (int d = 0; d < Constants.DAYS_PER_YEAR; d++)
    {
      setDay[d] = false; // array of 365
    }
   
  resetTagMarkersDay();
 }


/**
 * reset tag markers for Day to false
 *
 */
private void resetTagMarkersDay()
{
   setStartDay = false;
   
   setDate = false; // String
   setMaxAirTemp = false; // float
   setMinAirTemp = false; // float
   setAvgAirTemp = false; // float
   setMaxRelativeHumidity = false; // float
   setMinRelativeHumidity = false; // float
   setPrecipitation = false; // float
   setAvgWindSpeed = false; // float
   setMaxWindSpeed = false; // float
   setAvgWindVectorMagnitude = false; // float;
   setAvgWindVectorDirection = false; // int
   setTotalSolarRadiation = false; // float
   setSoilTemp = false; // float
   setAvgDayWindSpeed = false; // float
   setAvgNightWindSpeed = false; // float
   setDewTemp = false; // float
   setHourCountExceptAir = false; // int
   setHourCountAir = false; // int
   setRainGaugeType = false; // String
   
   addedDayToVector = false;

}


/**
 * getDayVector
 *
 * @return speciesVector that was read in
 */
 public Vector getDayVector()
 {
   return dayVector;
 }

 
 /**
  * getYearVector
  *
  * @return yearVector that was read in
  */
  public Vector getYearVector()
  {
    return yearVector;
  }
 
}
0
 
LVL 86

Accepted Solution

by:
CEHJ earned 125 total points
ID: 12290383
That's not the right way of implementing characters. You should add them to a String buffer created (or cleared) in startElement, add to the buffer during characters and collect from and clear the buffer in endElement:

startElement:

buffer.setLength(0);

characters:

buffer.append(ch, start, length);

endElement:

text = buffer.toString(); // where 'text' is a String instance variable
buffer.setLength(0);

0
 
LVL 1

Author Comment

by:allelopath
ID: 12292993
I've attempted to implement your suggestions, but it is not working.
characters() is called x numbers of times for each element, where x is the number of characters in the element
and so, as an example, if the element were 'four', buffer ends up being 'fourfourfourfour'
0
 
LVL 1

Author Comment

by:allelopath
ID: 12293009
never mind about that...
0
 
LVL 1

Author Comment

by:allelopath
ID: 12293024
thanks!
0
 
LVL 86

Expert Comment

by:CEHJ
ID: 12293047
8-)
0

Featured Post

Free Tool: Postgres Monitoring System

A PHP and Perl based system to collect and display usage statistics from PostgreSQL databases.

One of a set of tools we are providing to everyone as a way of saying thank you for being a part of the community.

Question has a verified solution.

If you are experiencing a similar issue, please ask a related question

Suggested Solutions

INTRODUCTION Working with files is a moderately common task in Java.  For most projects hard coding the file names, using parameters in configuration files, or using command-line arguments is sufficient.   However, when your application has vi…
Java contains several comparison operators (e.g., <, <=, >, >=, ==, !=) that allow you to compare primitive values. However, these operators cannot be used to compare the contents of objects. Interface Comparable is used to allow objects of a cl…
Viewers will learn about the different types of variables in Java and how to declare them. Decide the type of variable desired: Put the keyword corresponding to the type of variable in front of the variable name: Use the equal sign to assign a v…
This theoretical tutorial explains exceptions, reasons for exceptions, different categories of exception and exception hierarchy.

856 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question