Java Tutorial/Development/Timing

Compute and display elapsed time of an operation

public class Main {
  public static void main(String[] args) throws Exception{
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 10; i++) {
        Thread.sleep(60);
    }
    long endTime = System.currentTimeMillis();
    float seconds = (endTime - startTime) / 1000F;
    System.out.println(Float.toString(seconds) + " seconds.");
  }
}
//0.625 seconds.

Convert milliseconds to readable string

/*
    GNU LESSER GENERAL PUBLIC LICENSE
    Copyright (C) 2006 The Lobo Project
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    Contact info: lobochief@users.sourceforge.net
*/
public class Timing {
  public static double round1(double value) {
    return Math.round(value * 10.0) / 10.0;
  }
  
  public static String getElapsedText(long elapsedMillis) {
    if(elapsedMillis < 60000) {
      double unit = round1(elapsedMillis / 1000.0); 
      return unit + (unit == 1 ? " second" : " seconds");
    }
    else if(elapsedMillis < 60000 * 60) {
      double unit = round1(elapsedMillis / 60000.0); 
      return unit + (unit == 1 ? " minute" : " minutes");
    }
    else if(elapsedMillis < 60000 * 60 * 24) {
      double unit = round1(elapsedMillis / (60000.0 * 60)); 
      return unit + (unit == 1 ? " hour" : " hours");
    }
    else {
      double unit = round1(elapsedMillis / (60000.0 * 60 * 24)); 
      return unit + (unit == 1 ? " day" : " days");
    }
  }
}

Get elapsed time in days

public class Main {
  public static void main(String[] argv) throws Exception {
    long start = System.currentTimeMillis();
    Thread.sleep(2000);
    // Get elapsed time in milliseconds
    long elapsedTimeMillis = System.currentTimeMillis() - start;
    float elapsedTimeDay = elapsedTimeMillis/(24*60*60*1000F);
    System.out.println(elapsedTimeDay);
  }
}

Get elapsed time in hours

public class Main {
  public static void main(String[] argv) throws Exception {
    long start = System.currentTimeMillis();
    Thread.sleep(2000);
    // Get elapsed time in milliseconds
    long elapsedTimeMillis = System.currentTimeMillis() - start;
    // Get elapsed time in hours
    float elapsedTimeHour = elapsedTimeMillis/(60*60*1000F);
    System.out.println(elapsedTimeHour);
  }
}

Get elapsed time in milliseconds

public class Main {
  public static void main(String[] argv) throws Exception {
    long start = System.currentTimeMillis();
    Thread.sleep(2000);
    // 
    long elapsedTimeMillis = System.currentTimeMillis() - start;
    System.out.println(elapsedTimeMillis);
  }
}

Get elapsed time in minutes

public class Main {
  public static void main(String[] argv) throws Exception {
    long start = System.currentTimeMillis();
    Thread.sleep(2000);
    // Get elapsed time in milliseconds
    long elapsedTimeMillis = System.currentTimeMillis() - start;
    // Get elapsed time in minutes
    float elapsedTimeMin = elapsedTimeMillis/(60*1000F);
    System.out.println(elapsedTimeMin);
  }
}

Get elapsed time in seconds

public class Main {
  public static void main(String[] argv) throws Exception {
    long start = System.currentTimeMillis();
    Thread.sleep(2000);
    // Get elapsed time in milliseconds
    long elapsedTimeMillis = System.currentTimeMillis() - start;
    // 
    float elapsedTimeSec = elapsedTimeMillis/1000F;
    System.out.println(elapsedTimeSec);
  }
}

Get system time using System class

public class Main {
  public static void main(String[] args) {
    long lnSystemTime = System.currentTimeMillis();
    System.out.println("Milliseconds since midnight, January 1, 1970 UTC : " + lnSystemTime);
  }
}

Returns a formatted String from time

/**
 * $Revision: 10205 $
 * $Date: 2008-04-11 15:48:27 -0700 (Fri, 11 Apr 2008) $
 *
 * Copyright (C) 2004-2008 Jive Software. All rights reserved.
 *
 * This software is published under the terms of the GNU Public License (GPL),
 * a copy of which is included in this distribution, or a commercial license
 * agreement with Jive.
 */
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.BreakIterator;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
/**
 * Utility class to peform common String manipulation algorithms.
 */
public class StringUtils {
    // Constants used by escapeHTMLTags
    private static final char[] QUOTE_ENCODE = """.toCharArray();
    private static final char[] AMP_ENCODE = "&".toCharArray();
    private static final char[] LT_ENCODE = "<".toCharArray();
    private static final char[] GT_ENCODE = ">".toCharArray();
    private StringUtils() {
        // Not instantiable.
    }
    /**
     * Returns a formatted String from time.
     *
     * @param diff the amount of elapsed time.
     * @return the formatte String.
     */
    public static String getTimeFromLong(long diff) {
        final String HOURS = "h";
        final String MINUTES = "min";
        final String SECONDS = "sec";
        final long MS_IN_A_DAY = 1000 * 60 * 60 * 24;
        final long MS_IN_AN_HOUR = 1000 * 60 * 60;
        final long MS_IN_A_MINUTE = 1000 * 60;
        final long MS_IN_A_SECOND = 1000;
        Date currentTime = new Date();
        long numDays = diff / MS_IN_A_DAY;
        diff = diff % MS_IN_A_DAY;
        long numHours = diff / MS_IN_AN_HOUR;
        diff = diff % MS_IN_AN_HOUR;
        long numMinutes = diff / MS_IN_A_MINUTE;
        diff = diff % MS_IN_A_MINUTE;
        long numSeconds = diff / MS_IN_A_SECOND;
        diff = diff % MS_IN_A_SECOND;
        long numMilliseconds = diff;
        StringBuffer buf = new StringBuffer();
        if (numHours > 0) {
            buf.append(numHours + " " + HOURS + ", ");
        }
        if (numMinutes > 0) {
            buf.append(numMinutes + " " + MINUTES);
        }
        //buf.append(numSeconds + " " + SECONDS);
        String result = buf.toString();
        if (numMinutes < 1) {
            result = "< 1 minute";
        }
        return result;
    }
}

Returns a String in the format Xhrs, Ymins, Z sec, for the time difference between two times

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */

import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.InetAddress;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.UnknownHostException;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Collection;

/**
 * General string utils
 */
public class StringUtils {
  final public static char COMMA = ",";
  final public static String COMMA_STR = ",";
  final public static char ESCAPE_CHAR = "\\";
  private static DecimalFormat oneDecimal = new DecimalFormat("0.0");
  
  /**
   * 
   * Given a finish and start time in long milliseconds, returns a 
   * String in the format Xhrs, Ymins, Z sec, for the time difference between two times. 
   * If finish time comes before start time then negative valeus of X, Y and Z wil return. 
   * 
   * @param finishTime finish time
   * @param startTime start time
   */
  public static String formatTimeDiff(long finishTime, long startTime){
    StringBuffer buf = new StringBuffer();
    
    long timeDiff = finishTime - startTime; 
    long hours = timeDiff / (60*60*1000);
    long rem = (timeDiff % (60*60*1000));
    long minutes =  rem / (60*1000);
    rem = rem % (60*1000);
    long seconds = rem / 1000;
    
    if (hours != 0){
      buf.append(hours);
      buf.append("hrs, ");
    }
    if (minutes != 0){
      buf.append(minutes);
      buf.append("mins, ");
    }
    // return "0sec if no difference
    buf.append(seconds);
    buf.append("sec");
    return buf.toString(); 
  }
}