Date Formatting, Converting from String to Timestamp

Question

I am trying to convert a string date to timestamp.
I have tried a couple of different ways to arrive at the end result.
I am basically trying to convert a date in the "dd-MM-yyyy" format to a timestamp.
If I use the following code, I get a date like this "18-May-2004 12:00:00 AM".
SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy);
Date dContractDate = sdf.parse("18-05-2004");
long dateInMilli = dContractDate.getTime();
bHelp.bcontractdate = new Timestamp(dateInMilli);
How can I make this code display the current time not midnight or some defaulted value?
Thanks.

Answer 1

I think a clever person would reuse their Date.classObject and call Date.setTime() as opposed to always
rolling out a new Date()
Not really a question of cleverness. Your code wins
nothing. Objects are not magically created and garbage collected in the ether.
The cost of creating a Date is nothing
compared to the cost of a format() call. True, but not valid a valid statement pertaining to the issue which is
"does always rolling dates suffer a performance hit?"
Plus you lost clarity Maybe you loose track of your code if you don't make new Objects all the time,
but I have never suffered from this.
Why do you think Sun provided the setDate() method?
and thread-safety.I have only had Thread issues when I didn't program them properly.
Luckilly I always program the correctly ;) (Touch wood)
The facts as I seem are thus:
Rolling new dates on a 1.83 GHZ PC incurrs on average
a 19% penalty. Here is the proof.
Save this program and save it as DateTest.java
If you don't want to waste the time here are the results of running it
through the default 10 iterations.
Running 10 iterations.
Reuse of dates is 27% more efficient
Reuse of dates is 17% more efficient
Reuse of dates is 18% more efficient
Reuse of dates is 20% more efficient
Reuse of dates is 20% more efficient
Reuse of dates is 17% more efficient
Reuse of dates is 17% more efficient
Reuse of dates is 20% more efficient
Reuse of dates is 20% more efficient
Reuse of dates is 18% more efficient
Gaining "nothing " actually = 19% on average
Low percent diff = 17 High percent diff = 27
Run it 100 times and it should still be around 19%
With the hi time being about 47% (Probably the result of garbage collecting)
//////////////////////////////////// <PROOF> ///////////////////////////////////////
import java.util.Date;
public class DateTest
DateTest()
public int run()
int percent = 0;
int loopCount = 0;
Date date = null;
int z=0;
long start1=0,end1=0,start2=0,end2=0,now=0;
int time1 = 0,time2 = 0;
   now = System.currentTimeMillis();
   date = new Date(now);
   loopCount = 10000000;
   start1    = System.currentTimeMillis();
   for(z=0;z<loopCount;z++)
      now = System.currentTimeMillis();
      date.setTime(now);
   end1 = System.currentTimeMillis();
   start2    = System.currentTimeMillis();
   for(z=0;z<loopCount;z++)
      now   = System.currentTimeMillis();
      date  = new Date(now); // use 'now' so test loops are =.
   end2 = System.currentTimeMillis();
   time1 = (int)(end1 - start1);
   time2 = (int)(end2 - start2);
   percent = ((time2-time1)*100/time2);
   System.out.println("Reuse of dates is "+percent+"% more efficient");
   return percent;
public static void main(String args[])
int z=0;
int lowP=100,hiP = 0;  // lowpercent/highpercent
DateTest d = new DateTest();
int loopCount = 0;
long totals   = 0;
int average   = 0;
int values[];
int retVal = 0;
   try // Yea olde Lazy person's command line handler :)
      loopCount = Integer.parseInt(args[0]);
   catch(Exception any)
      loopCount = 10;
   if(loopCount == 0)
      loopCount = 10;
   values = new int[loopCount];
   System.out.println("Running "+loopCount+" iterations.");
   for(z=0;z<loopCount;z++)  //
      retVal = d.run();
      if(lowP > retVal)
         lowP = retVal;
      if(hiP < retVal)
         hiP = retVal;
      values[z] = retVal;
   for(z=0;z<loopCount;z++)
      totals += (long)values[z];
   average = (int)(totals/loopCount);
   System.out.println(" Gaining \"nothing \" actually = "+average+"% on average");
   System.out.println("Low percent diff = "+lowP+" High percent diff = "+hiP);
}////////////////////////////////// </PROOF> /////////////////////////////////////////
Your "nothing" is in fact on average about a 19% performance hit. per call.
These inefficiencies build up and java is infested with the,
Was it not so the java would run much more efficiently than it now does.
Ask yourself; why did Sun supply the setDate() method???
(T)