Java中代码的时间复杂度
四个场景，分别对应了程序中最常见的四种执行方式：
场景1
T（n） = 3n，执行次数是线性的


场景2：
T（n） = 5logn，执行次数是对数的


场景3：
T（n） = 2，执行次数是常量的


场景4：
T（n） = 0.5n^2 + 0.5n，执行次数是一个多项式



有了基本操作执行次数的函数 T（n），是否就可以分析和比较一段代码的运行时间了呢？还是有一定的困难。
比如算法A的相对时间是T（n）= 100n，算法B的相对时间是T（n）= 5n^2，这两个到底谁的运行时间更长一些？这就要看n的取值了。
所以，这时候有了渐进时间复杂度（asymptotic time complectiy）的概念，官方的定义如下：
若存在函数 f（n），使得当n趋近于无穷大时，T（n）/ f（n）的极限值为不等于零的常数，则称 f（n）是T（n）的同数量级函数。
记作 T（n）= O（f（n）），称O（f（n）） 为算法的渐进时间复杂度，简称时间复杂度。
渐进时间复杂度用大写O来表示，所以也被称为大O表示法。
如何推导出时间复杂度呢？有如下几个原则：
如果运行时间是常数量级，用常数1表示。
只保留时间函数中的最高阶项
如果最高阶项存在，则省去最高阶项前面的系数。
让我们回头看看刚才的四个场景。

场景1：
T（n） = 3n
最高阶项为3n，省去系数3，转化的时间复杂度为：
T（n） = O（n）
场景2：
T（n） = 5logn
最高阶项为5logn，省去系数5，转化的时间复杂度为：
T（n） = O（logn）

场景3：
T（n） = 2
只有常数量级，转化的时间复杂度为：
T（n） = O（1）

场景4：
T（n） = 0.5n^2 + 0.5n
最高阶项为0.5n^2，省去系数0.5，转化的时间复杂度为：
T（n） = O（n^2）
我们来举过一个例子：
算法A的相对时间规模是T（n）= 100n，时间复杂度是O(n)
算法B的相对时间规模是T（n）= 5n2，时间复杂度是O(n2)，
算法A运行在小灰家里的老旧电脑上，算法B运行在某台超级计算机上，运行速度是老旧电脑的100倍。
那么，随着输入规模 n 的增长，两种算法谁运行更快呢？


从表格中可以看出，当n的值很小的时候，算法A的运行用时要远大于算法B；当n的值达到1000左右，算法A和算法B的运行时间已经接近；当n的值越来越大，达到十万、百万时，算法A的优势开始显现，算法B则越来越慢，差距越来越明显。
这就是不同时间复杂度带来的差距。

输出日期和时间的Java代码-java.util.Date用法


文章目录
输出日期和时间的Java代码-java.util.Date用法
System.out.println(new java.util.Date());
代码
图
结果
System.out.println(new java.util.Date().toLocaleString());
代码
图
结果
DateFormat.format()【重要】
代码
图
结果
注意
从基础学起的注意一下
给个建议




System.out.println(new java.util.Date());
代码
System.out.println(new java.util.Date());  

图



结果
Wed Oct 17 21:06:51 CST 2018




System.out.println(new java.util.Date().toLocaleString());
代码
System.out.println(new java.util.Date().toLocaleString());

图


会有提示（但是不用管）



结果
2018-10-17 21:06:32




前两个的区别可以看出来吧，第一个的输出结果多了很多英文，有时候不必要的话就可以换成第二个。
前两个已过时，接下来介绍第三个。




DateFormat.format()【重要】
代码
public class Xx1 {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
	//日期
	    //方法1
			DateFormat d1 =java.text.DateFormat.getDateInstance();
			Date date = new Date();  
			System.out.println(d1.format(date));
		//方法2
		    DateFormat df = DateFormat.getDateInstance();
//		    Date date = new Date();  
//注释掉这一行，如果单独的话取消注释，因为局部变量重复了。
			System.out.println("日期：" + df.format(date));  
	//时间
			DateFormat tf = DateFormat.getTimeInstance(); 
//		    Date date = new Date(); 
			System.out.println("时间：" + tf.format(date));  

	//日期时间
		//方法1
			DateFormat dtf = DateFormat.getDateTimeInstance(); 			
//		    Date date = new Date();
			System.out.println("日期时间：" + dtf.format(date));  
		//方法2
			SimpleDateFormat sdf = (SimpleDateFormat) DateFormat.getDateTimeInstance();  
//		    Date date = new Date();
			System.out.println("日期时间：" + sdf.format(date));  

	}
}

提示：源代码下载请看文末


图



结果
2018-10-18
日期：2018-10-18
时间：20:57:01
日期时间：2018-10-18 20:57:01
日期时间：2018-10-18 20:57:01




注意
从基础学起的注意一下
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

这三行要注意检查一下。（需要导入类）


步骤（只以一个为例，剩下的都一样）：

输入SimpleDateFormat sdf = (SimpleDateFormat) DateFormat.getDateTimeInstance();
出现报错图标后点击：
 

然后双击出现的第一行，
也就是出现java.text的提示的那一行。


import java.text.SimpleDateFormat;会在上方【public class的上方、package的下方】出现。




给个建议
每个方法都试一遍，更有助于理解。
可以先注释掉不运行的代码，然后尝试运行，查看运行结果。




//end



【赞赏&支持&福利】
【赞赏】  │  支持&福利（+每日领红包）  │  备用链


其他说明可以点击 简 介 说 明 查看。
转载请注明原文章链接，并标注作者amosC。


转载格式如下：

来源：（此处附上原文链接）


作者：amosC（amoscey）




简书主页   | CSDN主页  | 赞赏说明  | 简    介   |






源代码（备注：用TXT文件保存的，直接复制着用就行）【点击此处下载】 ↩︎

通常在进行代码测试和代码优化的时候，会想要知道代码执行时每段代码的执行时间，以便进行代码优化和调整。
下面封装的类是利用代码段标记和执行时间差进行统计。使用时，仅需要在代码段中加入CodeTimer.set("标记");就可以了，打印 时调用CodeTimer.print();统计字段有代码段、总时间（纳秒）、执行次数、平均时间。
封装类：
/**
 * 统计代码段执行时间。
 * 在需要进行统计的代码段调用CodeTimer.set()方法进行标记。
 * 打印时调用CodeTimer.print()方法
 */
public class CodeTimer {
    private static String lastMark = "start";
    private static long lastTime = System.nanoTime();
    private static final Map<String, Long> timeMap = new LinkedHashMap<String, Long>();
    private static final Map<String, Long> timeHappenCount = new LinkedHashMap<String, Long>();

    public static void set(int mark) {
        set("" + mark);
    };

    public static void set(String mark) {
        long thisTime = System.nanoTime();
        String key = "[" + lastMark + "]->[" + mark + "]";
        Long lastSummary = timeMap.get(key);
        if (lastSummary == null)
            lastSummary = 0L;

        timeMap.put(key, System.nanoTime() - lastTime + lastSummary);
        Long lastCount = timeHappenCount.get(key);
        if (lastCount == null)
            lastCount = 0L;

        timeHappenCount.put(key, ++lastCount);
        lastTime = thisTime;
        lastMark = mark;
    };

    public static void print() {
        Integer a = 0;
        System.out.println(
                String.format("%25s %18s %18s %18s",
                    "PROCESS", "TOTAL_TIME", "REPEAT_TIMES", "AVG_TIME"));
        for (Entry<String, Long> entry : timeMap.entrySet()) {
            System.out.println(
                String.format("%25s %18s %18s %18s", entry.getKey(),
                    String.format("%,d", entry.getValue()), timeHappenCount.get(entry.getKey()),
                    String.format("%,d", entry.getValue() / timeHappenCount.get(entry.getKey()))));
        }
    }
}

打印出的效果形如：
                  PROCESS         TOTAL_TIME       REPEAT_TIMES           AVG_TIME
             [start]->[0]            152,312                  1            152,312
                 [0]->[4]         12,223,365                  1         12,223,365
                [4]->[10]            101,838                  6             16,973
                [10]->[8]          1,246,189                 34             36,652
                 [8]->[5]        489,096,299                 34         14,385,185
                 [5]->[6]        122,247,497                 34          3,595,514
                 [6]->[7]      2,686,057,029                 34         79,001,677
                 [7]->[1]             22,334                  1             22,334
                 [1]->[9]            911,191                  1            911,191

java计算代码执行时间：

long startMili=System.currentTimeMillis();// 当前时间对应的毫秒数
System.out.println("/**开始 "+startMili);
//这里加入需要测试的代码
long endMili=System.currentTimeMillis();//结束时间
System.out.println("/**结束 s"+endMili);
System.out.println("/**总耗时为："+(endMili-startMili)+"毫秒");

第二种是以纳秒为单位计算的。

long startTime=System.nanoTime();   //获取开始时间  

doSomeThing(); //测试的代码段  

long endTime=System.nanoTime(); //获取结束时间  

System.out.println("程序运行时间： "+(endTime-startTime)+"ns");