/*
* Copyright 2001-2005 Stephen Colebourne
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.joda.example.time;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.joda.time.DateTime;
import org.joda.time.MutableDateTime;
import org.joda.time.chrono.GJChronology;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
/**
* DateTimePerformance provides various comparisons between the Java supplied
* Date classes and the Joda ones.
*
* @author Stephen Colebourne
*/
public class DateTimePerformance {
private static class Result {
String object = null;
String name = null;
long time = 0;
long avg = 0;
int runs = 0;
}
private static int AVERAGE = 3;
private static int COUNT_VERY_FAST = 5000000;
private static int COUNT_FAST = 200000;
private static int COUNT_SLOW = 20000;
private Map results = new HashMap();
private List resultList = new ArrayList();
private Result result = null;
private long start = 0;
private long end = 0;
/**
* Constructor
*/
public static void main(String[] args) {
try {
new DateTimePerformance();
} catch (Throwable th) {
th.printStackTrace();
}
}
/**
* Constructor
*/
public DateTimePerformance() throws Exception {
checkJodaConstructor1();
checkJISOConstructor1();
checkGCalConstructor1();
checkDateConstructor1();
checkJodaConstructor2();
checkJISOConstructor2();
checkGCalConstructor2();
checkDateConstructor2();
checkJodaConstructor3();
checkJISOConstructor3();
checkGCalConstructor3();
checkDateConstructor3();
checkJodaGetYear();
checkJISOGetYear();
checkGCalGetYear();
checkDateGetYear();
// checkJodaGetMonth();
// checkJISOGetMonth();
// checkGCalGetMonth();
// checkDateGetMonth();
// checkJodaGetDay();
// checkJISOGetDay();
// checkGCalGetDay();
// checkDateGetDay();
checkJodaGetHour();
checkJISOGetHour();
checkGCalGetHour();
checkDateGetHour();
checkJodaSetYear();
checkJISOSetYear();
checkGCalSetYear();
checkDateSetYear();
checkJodaSetGetYear();
checkJISOSetGetYear();
checkGCalSetGetYear();
checkDateSetGetYear();
checkJodaSetHour();
checkJISOSetHour();
checkGCalSetHour();
checkDateSetHour();
checkJodaSetGetHour();
checkJISOSetGetHour();
checkGCalSetGetHour();
checkDateSetGetHour();
checkJodaToString();
checkJISOToString();
checkGCalToString();
checkDateToString();
System.out.println("");
long jodaTotal = 0;
long jisoTotal = 0;
long gcalTotal = 0;
long dateTotal = 0;
for (Iterator it = resultList.iterator(); it.hasNext();) {
Result res = (Result) it.next();
System.out.println(res.object + "." + res.name + ": " + res.avg + "ns");
if (res.object.equals("Joda")) {
jodaTotal += res.avg;
} else if (res.object.equals("JISO")) {
jisoTotal += res.avg;
} else if (res.object.equals("GCal")) {
gcalTotal += res.avg;
} else if (res.object.equals("Date")) {
dateTotal += res.avg;
System.out.println("");
}
}
System.out.println("Joda: " + jodaTotal);
System.out.println("JISO: " + jisoTotal);
System.out.println("GCal: " + gcalTotal);
System.out.println("Date: " + dateTotal);
}
// Constructor using currentTimeMillis()
//------------------------------------------------------------------------
private void checkJodaConstructor1() {
int COUNT = COUNT_SLOW;
DateTime dt = new DateTime(GJChronology.getInstance());
int count = 0;
for (int i = 0; i < AVERAGE; i++) {
start("Joda", "new()");
for (int j = 0; j < COUNT; j++) {
dt = new DateTime(GJChronology.getInstance());
if (count++ < 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkJISOConstructor1() {
int COUNT = COUNT_SLOW;
DateTime dt = new DateTime();
int count = 0;
for (int i = 0; i < AVERAGE; i++) {
start("JISO", "new()");
for (int j = 0; j < COUNT; j++) {
dt = new DateTime();
if (count++ < 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkGCalConstructor1() {
int COUNT = COUNT_SLOW;
GregorianCalendar dt = new GregorianCalendar();
int count = 0;
for (int i = 0; i < AVERAGE; i++) {
start("GCal", "new()");
for (int j = 0; j < COUNT; j++) {
dt = new GregorianCalendar();
if (count++ < 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkDateConstructor1() {
int COUNT = COUNT_SLOW;
Date dt = new Date();
int count = 0;
for (int i = 0; i < AVERAGE; i++) {
start("Date", "new()");
for (int j = 0; j < COUNT; j++) {
dt = new Date();
if (count++ < 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
// Constructor using long millis
//------------------------------------------------------------------------
private void checkJodaConstructor2() {
int COUNT = COUNT_VERY_FAST;
DateTime dt = new DateTime(12345L, GJChronology.getInstance());
for (int i = 0; i < AVERAGE; i++) {
start("Joda", "new(millis)");
for (int j = 0; j < COUNT; j++) {
dt = new DateTime(12345L, GJChronology.getInstance());
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkJISOConstructor2() {
int COUNT = COUNT_VERY_FAST;
DateTime dt = new DateTime(12345L);
for (int i = 0; i < AVERAGE; i++) {
start("JISO", "new(millis)");
for (int j = 0; j < COUNT; j++) {
dt = new DateTime(12345L);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkGCalConstructor2() {
int COUNT = COUNT_SLOW;
GregorianCalendar dt = new GregorianCalendar();
for (int i = 0; i < AVERAGE; i++) {
start("GCal", "new(millis)");
for (int j = 0; j < COUNT; j++) {
dt = new GregorianCalendar();
dt.setTime(new Date(12345L));
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkDateConstructor2() {
int COUNT = COUNT_VERY_FAST;
Date dt = new Date();
for (int i = 0; i < AVERAGE; i++) {
start("Date", "new(millis)");
for (int j = 0; j < COUNT; j++) {
dt = new Date(12345L);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
// Constructor using year month and day
//------------------------------------------------------------------------
private void checkJodaConstructor3() {
int COUNT = COUNT_SLOW;
DateTime dt = new DateTime(1972, 10, 1, 0, 0, 0, 0,
GJChronology.getInstance());
for (int i = 0; i < AVERAGE; i++) {
start("Joda", "new(YMD)");
for (int j = 0; j < COUNT; j++) {
dt = new DateTime(1972, 10, 1, 0, 0, 0, 0,
GJChronology.getInstance());
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkJISOConstructor3() {
int COUNT = COUNT_SLOW;
DateTime dt = new DateTime(1972, 10, 1, 0, 0, 0, 0);
for (int i = 0; i < AVERAGE; i++) {
start("JISO", "new(YMD)");
for (int j = 0; j < COUNT; j++) {
dt = new DateTime(1972, 10, 1, 0, 0, 0, 0);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkGCalConstructor3() {
int COUNT = COUNT_SLOW;
GregorianCalendar dt = new GregorianCalendar(1972, 10, 1);
for (int i = 0; i < AVERAGE; i++) {
start("GCal", "new(YMD)");
for (int j = 0; j < COUNT; j++) {
dt = new GregorianCalendar(1972, 10, 1);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkDateConstructor3() {
int COUNT = COUNT_SLOW;
Date dt = new Date();
for (int i = 0; i < AVERAGE; i++) {
start("Date", "new(YMD)");
for (int j = 0; j < COUNT; j++) {
dt = new Date(1972, 10, 1);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
// Get year
//------------------------------------------------------------------------
private void checkJodaGetYear() {
int COUNT = COUNT_VERY_FAST;
DateTime dt = new DateTime(GJChronology.getInstance());
for (int i = 0; i < AVERAGE; i++) {
start("Joda", "getYear");
for (int j = 0; j < COUNT; j++) {
int val = dt.getYear();
if (val == 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkJISOGetYear() {
int COUNT = COUNT_VERY_FAST;
DateTime dt = new DateTime();
for (int i = 0; i < AVERAGE; i++) {
start("JISO", "getYear");
for (int j = 0; j < COUNT; j++) {
int val = dt.getYear();
if (val == 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkGCalGetYear() {
int COUNT = COUNT_VERY_FAST;
GregorianCalendar dt = new GregorianCalendar();
for (int i = 0; i < AVERAGE; i++) {
start("GCal", "getYear");
for (int j = 0; j < COUNT; j++) {
int val = dt.get(GregorianCalendar.YEAR);
if (val == 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkDateGetYear() {
int COUNT = COUNT_FAST;
Date dt = new Date();
for (int i = 0; i < AVERAGE; i++) {
start("Date", "getYear");
for (int j = 0; j < COUNT; j++) {
int val = dt.getYear();
if (val == 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
// Get month
//------------------------------------------------------------------------
private void checkJodaGetMonth() {
int COUNT = COUNT_VERY_FAST;
DateTime dt = new DateTime(GJChronology.getInstance());
for (int i = 0; i < AVERAGE; i++) {
start("Joda", "getMonth");
for (int j = 0; j < COUNT; j++) {
int val = dt.getMonthOfYear();
if (val == 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkJISOGetMonth() {
int COUNT = COUNT_VERY_FAST;
DateTime dt = new DateTime();
for (int i = 0; i < AVERAGE; i++) {
start("JISO", "getMonth");
for (int j = 0; j < COUNT; j++) {
int val = dt.getMonthOfYear();
if (val == 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkGCalGetMonth() {
int COUNT = COUNT_VERY_FAST;
GregorianCalendar dt = new GregorianCalendar();
for (int i = 0; i < AVERAGE; i++) {
start("GCal", "getMonth");
for (int j = 0; j < COUNT; j++) {
int val = dt.get(GregorianCalendar.MONTH);
if (val == 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkDateGetMonth() {
int COUNT = COUNT_FAST;
Date dt = new Date();
for (int i = 0; i < AVERAGE; i++) {
start("Date", "getMonth");
for (int j = 0; j < COUNT; j++) {
int val = dt.getMonth();
if (val == 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
// Get day
//------------------------------------------------------------------------
private void checkJodaGetDay() {
int COUNT = COUNT_VERY_FAST;
DateTime dt = new DateTime(GJChronology.getInstance());
for (int i = 0; i < AVERAGE; i++) {
start("Joda", "getDay");
for (int j = 0; j < COUNT; j++) {
int val = dt.getDayOfMonth();
if (val == 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkJISOGetDay() {
int COUNT = COUNT_VERY_FAST;
DateTime dt = new DateTime();
for (int i = 0; i < AVERAGE; i++) {
start("JISO", "getDay");
for (int j = 0; j < COUNT; j++) {
int val = dt.getDayOfMonth();
if (val == 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkGCalGetDay() {
int COUNT = COUNT_VERY_FAST;
GregorianCalendar dt = new GregorianCalendar();
for (int i = 0; i < AVERAGE; i++) {
start("GCal", "getDay");
for (int j = 0; j < COUNT; j++) {
int val = dt.get(GregorianCalendar.DAY_OF_MONTH);
if (val == 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkDateGetDay() {
int COUNT = COUNT_FAST;
Date dt = new Date();
for (int i = 0; i < AVERAGE; i++) {
start("Date", "getDay");
for (int j = 0; j < COUNT; j++) {
int val = dt.getDate();
if (val == 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
// Get hour
//------------------------------------------------------------------------
private void checkJodaGetHour() {
int COUNT = COUNT_VERY_FAST;
DateTime dt = new DateTime(GJChronology.getInstance());
for (int i = 0; i < AVERAGE; i++) {
start("Joda", "getHour");
for (int j = 0; j < COUNT; j++) {
int val = dt.getHourOfDay();
if (val == -1) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkJISOGetHour() {
int COUNT = COUNT_VERY_FAST;
DateTime dt = new DateTime();
for (int i = 0; i < AVERAGE; i++) {
start("JISO", "getHour");
for (int j = 0; j < COUNT; j++) {
int val = dt.getHourOfDay();
if (val == -1) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkGCalGetHour() {
int COUNT = COUNT_VERY_FAST;
GregorianCalendar dt = new GregorianCalendar();
for (int i = 0; i < AVERAGE; i++) {
start("GCal", "getHour");
for (int j = 0; j < COUNT; j++) {
int val = dt.get(GregorianCalendar.HOUR_OF_DAY);
if (val == -1) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkDateGetHour() {
int COUNT = COUNT_FAST;
Date dt = new Date();
for (int i = 0; i < AVERAGE; i++) {
start("Date", "getHour");
for (int j = 0; j < COUNT; j++) {
int val = dt.getHours();
if (val == -1) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
// Set year
//------------------------------------------------------------------------
private void checkJodaSetYear() {
int COUNT = COUNT_FAST;
// Is it fair to use only MutableDateTime here? You decide.
MutableDateTime dt = new MutableDateTime(GJChronology.getInstance());
for (int i = 0; i < AVERAGE; i++) {
start("Joda", "setYear");
for (int j = 0; j < COUNT; j++) {
dt.setYear(1972);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkJISOSetYear() {
int COUNT = COUNT_FAST;
// Is it fair to use only MutableDateTime here? You decide.
MutableDateTime dt = new MutableDateTime();
for (int i = 0; i < AVERAGE; i++) {
start("JISO", "setYear");
for (int j = 0; j < COUNT; j++) {
dt.setYear(1972);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkGCalSetYear() {
int COUNT = COUNT_VERY_FAST;
GregorianCalendar dt = new GregorianCalendar();
for (int i = 0; i < AVERAGE; i++) {
start("GCal", "setYear");
for (int j = 0; j < COUNT; j++) {
dt.set(GregorianCalendar.YEAR, 1972);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkDateSetYear() {
int COUNT = COUNT_FAST;
Date dt = new Date();
for (int i = 0; i < AVERAGE; i++) {
start("Date", "setYear");
for (int j = 0; j < COUNT; j++) {
dt.setYear(1972);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
// Set then get year
//------------------------------------------------------------------------
private void checkJodaSetGetYear() {
int COUNT = COUNT_FAST;
// Is it fair to use only MutableDateTime here? You decide.
// MutableDateTime dt = new MutableDateTime(GJChronology.getInstance());
// for (int i = 0; i < AVERAGE; i++) {
// start("Joda", "setGetYear");
// for (int j = 0; j < COUNT; j++) {
// dt.setYear(1972);
// int val = dt.getYear();
// if (val < 0) {System.out.println("Anti optimise");}
// }
// end(COUNT);
// }
DateTime dt = new DateTime(GJChronology.getInstance());
for (int i = 0; i < AVERAGE; i++) {
start("Joda", "setGetYear");
for (int j = 0; j < COUNT; j++) {
dt = dt.year().setCopy(1972);
int val = dt.getYear();
if (val < 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkJISOSetGetYear() {
int COUNT = COUNT_FAST;
// Is it fair to use only MutableDateTime here? You decide.
// MutableDateTime dt = new MutableDateTime();
// for (int i = 0; i < AVERAGE; i++) {
// start("JISO", "setGetYear");
// for (int j = 0; j < COUNT; j++) {
// dt.setYear(1972);
// int val = dt.getYear();
// if (val < 0) {System.out.println("Anti optimise");}
// }
// end(COUNT);
// }
DateTime dt = new DateTime();
for (int i = 0; i < AVERAGE; i++) {
start("JISO", "setGetYear");
for (int j = 0; j < COUNT; j++) {
dt = dt.year().setCopy(1972);
int val = dt.getYear();
if (val < 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkGCalSetGetYear() {
int COUNT = COUNT_FAST;
GregorianCalendar dt = new GregorianCalendar();
for (int i = 0; i < AVERAGE; i++) {
start("GCal", "setGetYear");
for (int j = 0; j < COUNT; j++) {
dt.set(GregorianCalendar.YEAR, 1972);
int val = dt.get(GregorianCalendar.YEAR);
if (val < 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkDateSetGetYear() {
int COUNT = COUNT_FAST;
Date dt = new Date();
for (int i = 0; i < AVERAGE; i++) {
start("Date", "setGetYear");
for (int j = 0; j < COUNT; j++) {
dt.setYear(1972);
int val = dt.getYear();
if (val < 0) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
// Set hour
//------------------------------------------------------------------------
private void checkJodaSetHour() {
int COUNT = COUNT_VERY_FAST;
// Is it fair to use only MutableDateTime here? You decide.
MutableDateTime dt = new MutableDateTime(GJChronology.getInstance());
for (int i = 0; i < AVERAGE; i++) {
start("Joda", "setHour");
for (int j = 0; j < COUNT; j++) {
dt.setHourOfDay(13);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkJISOSetHour() {
int COUNT = COUNT_VERY_FAST;
// Is it fair to use only MutableDateTime here? You decide.
MutableDateTime dt = new MutableDateTime();
for (int i = 0; i < AVERAGE; i++) {
start("JISO", "setHour");
for (int j = 0; j < COUNT; j++) {
dt.setHourOfDay(13);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkGCalSetHour() {
int COUNT = COUNT_VERY_FAST;
GregorianCalendar dt = new GregorianCalendar();
for (int i = 0; i < AVERAGE; i++) {
start("GCal", "setHour");
for (int j = 0; j < COUNT; j++) {
dt.set(GregorianCalendar.HOUR_OF_DAY, 13);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkDateSetHour() {
int COUNT = COUNT_FAST;
Date dt = new Date();
for (int i = 0; i < AVERAGE; i++) {
start("Date", "setHour");
for (int j = 0; j < COUNT; j++) {
dt.setHours(13);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
// Set hour
//------------------------------------------------------------------------
private void checkJodaSetGetHour() {
int COUNT = COUNT_VERY_FAST;
// Is it fair to use only MutableDateTime here? You decide.
MutableDateTime dt = new MutableDateTime(GJChronology.getInstance());
for (int i = 0; i < AVERAGE; i++) {
start("Joda", "setGetHour");
for (int j = 0; j < COUNT; j++) {
dt.setHourOfDay(13);
int val = dt.getHourOfDay();
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkJISOSetGetHour() {
int COUNT = COUNT_VERY_FAST;
// Is it fair to use only MutableDateTime here? You decide.
MutableDateTime dt = new MutableDateTime();
for (int i = 0; i < AVERAGE; i++) {
start("JISO", "setGetHour");
for (int j = 0; j < COUNT; j++) {
dt.setHourOfDay(13);
int val = dt.getHourOfDay();
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkGCalSetGetHour() {
int COUNT = COUNT_VERY_FAST;
GregorianCalendar dt = new GregorianCalendar();
for (int i = 0; i < AVERAGE; i++) {
start("GCal", "setGetHour");
for (int j = 0; j < COUNT; j++) {
dt.set(GregorianCalendar.HOUR_OF_DAY, 13);
int val = dt.get(GregorianCalendar.HOUR_OF_DAY);
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkDateSetGetHour() {
int COUNT = COUNT_FAST;
Date dt = new Date();
for (int i = 0; i < AVERAGE; i++) {
start("Date", "setGetHour");
for (int j = 0; j < COUNT; j++) {
dt.setHours(13);
int val = dt.getHours();
if (dt == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
// To formatted string
//------------------------------------------------------------------------
private void checkJodaToString() {
int COUNT = COUNT_SLOW;
DateTime dt = new DateTime(GJChronology.getInstance());
DateTimeFormatter f = DateTimeFormat.forPattern("dd MMM yyyy");
for (int i = 0; i < AVERAGE; i++) {
start("Joda", "toString");
for (int j = 0; j < COUNT; j++) {
String str = dt.toString("dd MMM yyyy");
// String str = dt.toString(f);
if (str == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkJISOToString() {
int COUNT = COUNT_SLOW;
DateTime dt = new DateTime();
DateTimeFormatter f = DateTimeFormat.forPattern("dd MMM yyyy");
for (int i = 0; i < AVERAGE; i++) {
start("JISO", "toString");
for (int j = 0; j < COUNT; j++) {
String str = dt.toString("dd MMM yyyy");
// String str = dt.toString(f);
if (str == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkGCalToString() {
int COUNT = COUNT_SLOW;
GregorianCalendar dt = new GregorianCalendar();
for (int i = 0; i < AVERAGE; i++) {
start("GCal", "toString");
for (int j = 0; j < COUNT; j++) {
SimpleDateFormat sdf = new SimpleDateFormat("dd MMM yyyy");
String str = sdf.format(dt.getTime());
if (str == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
private void checkDateToString() {
int COUNT = COUNT_SLOW;
Date dt = new Date();
for (int i = 0; i < AVERAGE; i++) {
start("Date", "toString");
for (int j = 0; j < COUNT; j++) {
SimpleDateFormat sdf = new SimpleDateFormat("dd MMM yyyy");
String str = sdf.format(dt);
if (str == null) {System.out.println("Anti optimise");}
}
end(COUNT);
}
}
//------------------------------------------------------------------------
/**
* Start the stopwatch.
*/
private void start(String str1, String str2) {
result = (Result) results.get(str1 + str2);
if (result == null) {
result = new Result();
result.object = str1;
result.name = str2;
results.put(str1 + str2, result);
resultList.add(result);
}
start = System.currentTimeMillis();
}
/**
* End the stopwatch and print the result.
*/
private void end(int count) {
end = System.currentTimeMillis();
long time = (end - start);
result.time = result.time + time;
result.runs = result.runs + count;
result.avg = (result.time * 1000000) / result.runs;
System.out.print(".");
}
}