Solved

Xerces parsing problem

Posted on 2004-10-11
9
164 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
 
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
What Is Threat Intelligence?

Threat intelligence is often discussed, but rarely understood. Starting with a precise definition, along with clear business goals, is essential.

 
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

How to run any project with ease

Manage projects of all sizes how you want. Great for personal to-do lists, project milestones, team priorities and launch plans.
- Combine task lists, docs, spreadsheets, and chat in one
- View and edit from mobile/offline
- Cut down on emails

Join & Write a Comment

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 functions are among the best things for programmers to work with as Java sites can be very easy to read and prepare. Java especially simplifies many processes in the coding industry as it helps integrate many forms of technology and different d…
Video by: Michael
Viewers learn about how to reduce the potential repetitiveness of coding in main by developing methods to perform specific tasks for their program. Additionally, objects are introduced for the purpose of learning how to call methods in Java. Define …
Viewers learn about the scanner class in this video and are introduced to receiving user input for their programs. Additionally, objects, conditional statements, and loops are used to help reinforce the concepts. Introduce Scanner class: Importing…

707 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

Need Help in Real-Time?

Connect with top rated Experts

13 Experts available now in Live!

Get 1:1 Help Now