Java和jni(获得指定文件创建时间)
Java中的日期和时间操作
Java中的日期和时间操作Java中提供了丰富的日期和时间操作的类和方法，方便我们对日期和时间进行处理和计算。
本文将介绍Java中常用的日期和时间操作。
一、日期和时间类在Java中，日期和时间相关的类主要包括以下几个：1. java.util.Date：表示日期和时间的类，常用的构造方法有无参构造方法、接收毫秒数的构造方法和接收年月日的构造方法。
2. java.util.Calendar：提供了对日期和时间进行操作的类，可以进行日期的加减、获取年月日等操作。
3. java.time.LocalDate：表示日期的类，提供了对年月日的操作和计算。
4. java.time.LocalTime：表示时间的类，提供了对时分秒的操作和计算。
5. java.time.LocalDateTime：表示日期和时间的类，提供了对日期时间的操作和计算。
6. java.time.format.DateTimeFormatter：用于日期和时间的格式化，可以将日期时间对象格式化为指定的字符串，或者将字符串解析为对应的日期时间对象。
二、日期和时间操作示例下面分别介绍一些常用的日期和时间操作示例。
1. 获取当前日期和时间：```javaimport java.time.LocalDateTime;public class DateTimeExample {public static void main(String[] args) {LocalDateTime now = LocalDateTime.now(); System.out.println(now);}}```2. 格式化日期和时间：```javaimport java.time.LocalDateTime;import java.time.format.DateTimeFormatter; public class DateTimeExample {public static void main(String[] args) {LocalDateTime now = LocalDateTime.now();DateTimeFormatter formatter =DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");String formattedDateTime = now.format(formatter);System.out.println(formattedDateTime);}}```3. 计算两个日期之间的差值：```javaimport java.time.LocalDate;import java.time.temporal.ChronoUnit;public class DateTimeExample {public static void main(String[] args) {LocalDate date1 = LocalDate.of(2022, 1, 1);LocalDate date2 = LocalDate.of(2022, 12, 31);long daysBetween = ChronoUnit.DAYS.between(date1, date2);System.out.println("Days between: " + daysBetween);}}```4. 日期的加减操作：```javaimport java.time.LocalDate;import java.time.temporal.ChronoUnit;public class DateTimeExample {public static void main(String[] args) {LocalDate now = LocalDate.now();LocalDate oneWeekLater = now.plus(1, ChronoUnit.WEEKS);LocalDate oneMonthEarlier = now.minus(1,ChronoUnit.MONTHS);System.out.println("One week later: " + oneWeekLater);System.out.println("One month earlier: " + oneMonthEarlier);}}```5. 判断某个日期是否在另一个日期之前或之后：```javaimport java.time.LocalDate;public class DateTimeExample {public static void main(String[] args) {LocalDate date1 = LocalDate.of(2022, 1, 1);LocalDate date2 = LocalDate.of(2022, 12, 31);boolean isBefore = date1.isBefore(date2);boolean isAfter = date1.isAfter(date2);System.out.println("Is date1 before date2? " + isBefore); System.out.println("Is date1 after date2? " + isAfter);}}```6. 获取特定日期的年、月、日信息：```javaimport java.time.LocalDate;public class DateTimeExample {public static void main(String[] args) {LocalDate now = LocalDate.now();int year = now.getYear();int month = now.getMonthValue();int day = now.getDayOfMonth();System.out.println("Year: " + year);System.out.println("Month: " + month);System.out.println("Day: " + day);}}```三、总结本文介绍了Java中常用的日期和时间操作，包括日期和时间的类、日期和时间的格式化、日期和时间的计算等内容。
Android中JNI的使用之一：Java原生JNI的使用、javah指令的使用以及图解教材
Android中JNI的使用之一：Java原生JNI的使用、javah指令的使用以及图解教材Java Nativie Interface(JNI,中文名称Java本地接口)标准时Java平台的一部分，它允许Java代码和其他语言写得代码进行交互。
JNI是本地编程接口，它使得Java虚拟机(VM)内部运行的Java代码能够用其他编程语言(如C、C++和汇编语言)编写的应用程序和库进行交互操作。
JNI的主要用途是为了对硬件进行访问以及追求高效率或可重用C/C++库。
Android系统中采用了JNI的方式来调用C/C++方法，然而，在Android系统里进一步加强了Java JNI的使用，使JNI的调用更具有效率。
因此，总的来说，Android 系统里可以采用两种方式来使用JNI。
第一种:Java原生JNI，使用dll等动态链接库；第二种，Android加强版JNI，通过动态加载*.so链接库来进行JNI调用。
今天，我们分析第一种JNI使用方式，也称得上是JNI入门。
由于Java与其他编程语言采用的语法不同，为了让Java与C/C++库函数能进行通信，约定的一个参数类型映射如下：Java类型C/C++类型void voidjboolean booleanjint intjlong longjdouble doublejfloat floatjbyte jbytejchar charjshort shor上面的只是简单类型的一个映射，后面我们会完善其他参数类型的映射。
开发环境介绍(Windows下)：Eclipse：主要用来创建Java工程MicrosoftVC++6.0：生成动态链接库供相应的Java文件加载一、使用Eclipse创建Java工程本例中，我们简单的创建了一个Java工程HelloBabyJNI，工程绝对路径位于E:\MyCode\AndroidCode\HelloBabyJNI路径下，主文件路径位于\src\lover\hellojni路径下(路径对后面的javah编译很重要)HelloBabyJNI.java文件如下：[java] view plaincopyprint?1.package com.lover.hellojni;2.3./**4. * 一个简单的Java JNI实例5. *6. */7.public class HelloBabyJNI {8.9./*10. * 静态构造函数，动态加载HelloBabyJNI动态库，其dll文件名为：HelloBabyJNI.dll --->由MSVC6.0软件创建11. */12.static {13. System.load("E:/HelloBabyJNI.dll"); // 可能需要 dll链接库的绝对存放路径14. }15.16./*17. * 在Java中注册需要调用的C/C++本地方法(native method)，也就是需要C/C++来实现的方法18. */19.public native int add(int a, int b);20.21.// main方法，加载动态库来调用C/C++本地方法22.public static void main(String[] args) {23. HelloBabyJNI helloBabyJNI = new HelloBabyJNI();24.// 调用注册的add方法来得到返回值25.int result = helloBabyJNI.add(2, 3);26.// 输出27. System.out.println("after invoke the native method,the result is "+ result);28. }29.}2，编译HelloBabyJNI.java文件，生成HelloBabyJNI.class文件，位于路径\src\lover\hellojni\HelloBabyJNI.class3，使用javah指令编译HelloBabyJNI.class文件，生成Java与C/C++之间进行通信的约定接口，它规定了Java中nativemethod在C/C++的具体接口。
JNI
这里以在Windows中为例，需要生成dll文件。在保存HelloWorldImpl.c文件夹下面，使用VC的编译器cl成。 cl -I%java_home%\include -I%java_home%\include\win32 -LD HelloWorldImp.c -Fehello.dll 注意：生成的dll文件名在选项-Fe后面配置，这里是hello，因为在HelloWorld.java文件中我们loadLibary的时候使用的名字是hello。当然这里修改之后那里也需要修改。另外需要将-I%java_home%\include -I%java_home%\include\win32参数加上，因为在第四步里面编写本地方法的时候引入了jni.h文件。
class weiqiong { static { System.loadLibrary("testjni");//载入静态库，test函数在其中实现 } private native void testjni(); //声明本地调用 public void test() { testjni(); } public static void main(String args[]) { weiqiong haha = new weiqiong(); haha.test(); } }
}
}
声明native方法：如果你想将一个方法做为一个本地方法的话，那么你就必须声明改方法为native的，并且不能实现。其中方法的参数和返回值在后面讲述。 Load动态库：System.loadLibrary("hello");加载动态库（我们可以这样理解：我们的方法 displayHelloWorld()没有实现，但是我们在下面就直接使用了，所以必须在使用之前对它进行初始化）这里一般是以static块进行加载的。同时需要注意的是System.loadLibrary();的参数“hello”是动态库的名字。
Java和jni（获得指定文件创建时间）
前言：在我写这篇文章之前，我说说我的碰到这个问题的起因。
公司让我写一个jar包，需要获得指定文件的创建日期（日期必须是完整地年月日时分秒）。
对于java jdk1.7来说很容易，因为1.7给了我们获得创建日期的接口。
但是对于jd k1.6来说，那就是一个老大难，没有提供，只提供了获得最后修改日期的接口。
对于jdk1.6，当然我也查过，请教过好多人，给出了解决办法，那就是使用J ava的R untim e 去调用当前操作系统的指令获得文件的创建日期：例如在win dows下，public String getFil eCrea teDat e(File _file) {File file = _file;try {Proces s ls_pro c = Runtim e.getRun time().exec("cmd.exe /c dir " + file.getAbs olute Path() + " /tc");Buffer edRea der br = new Buffer edRea der(new InputS tream Reade r( ls_pro c.getInp ut Str eam()));for (int i = 0; i < 5; i++) {br.readLi ne();}String stuff= br.readLi ne();String Token izerst = new String Token izer(stuff);String dateC= st.nextTo ken();String time = st.nextTo ken();String dateti me = dateC.concat(time);Simple DateF ormat format ter1= new Simple DateF ormat( "yyyy-MM-dd hh:mm:ss ");Simple DateF ormat format ter2= new Simple DateF ormat("yyyy/MM/ddHH:mm");dateti me = format ter1.format(format ter2.parse(dateti me));br.close();return dateti me;} catch(Except ion e) {return null;}}引用：http://zhidao.baidu.com/questi on/535215288.html但是这个方法只能或得到文件的年月日时分，不能获得到秒。
Java获取日期和时间方法总结
在写Java程序的时候总免不了与日期和时间打交道，特别是在做项目的时候，要按照各种各样的需求显示不同格式的日期和时间，这时候就需要快速的决定到底用哪一种好，下面对日期和时间的格式化进行了总结。
方法一：用java.util.Date类来实现，并结合ja va.te xt.Da teFor mat类来实现时间的格式化p ackag e net.sing lex.j avada te;/** * 以下默认时间日期显示方式都是汉语方式* 一般语言就默认汉语就可以了，时间日期的格式默认为MEDI UM风格，*比如：2013-6-10 13:14:41 * 以下显示的日期时间都是在Date类的基础上的来的，还可以利用Ca lenda r类来实现见类Tes tDate2.jav a* * @a uthor Sing leX * */im portjava.util.*; impor t jav a.tex t.*;p ublic clas s Tes tDate { p ublic stat ic vo id ma in(St ring[] arg s) { Dat e now = ne w Dat e();Calen dar c al =Calen dar.g etIns tance(); Date Forma t d1= Dat eForm at.ge tDate Insta nce(); //默认语言（汉语）下的默认风格（MEDIU M风格，比如：2013-6-10 13:14:41） Str ing s tr1 = d1.f ormat(now); Dat eForm at d2 = Da teFor mat.g etDat eTime Insta nce(); Str ing s tr2 = d2.f ormat(now); Dat eForm at d3 = Da teFor mat.g etTim eInst ance(); St ringstr3= d3.forma t(now); Da teFor mat d4 = D ateFo rmat.getIn stanc e();// 使用SHORT风格显示日期和时间Strin g str4 = d4.for mat(n ow);DateF ormat d5 =Date Forma t.get DateT imeIn stanc e(Dat eForm at.FU LL, D ateFo rmat.FULL); //显示日期，周，时间（精确到秒） Stri ng st r5 =d5.fo rmat(now); Date Forma t d6= Dat eForm at.ge tDate TimeI nstan ce(Da teFor mat.L ONG,DateF ormat.LONG); //显示日期。
java 获取标准时间
java 获取标准时间在Java编程中，获取标准时间是一个常见的需求。
Java提供了多种方式来获取标准时间，包括使用系统当前时间、获取特定时区的时间、以及格式化时间等操作。
本文将介绍如何在Java中获取标准时间的几种常用方法。
首先，我们可以使用Java中的Date类来获取系统当前时间。
Date类提供了获取系统当前时间的方法，如下所示：```java。
Date now = new Date();```。
通过这种方式，我们可以获取到系统当前的标准时间。
但需要注意的是，Date类在Java 8之后已经被弃用，推荐使用java.time包中的新日期时间API来替代。
下面我们将介绍如何使用新的日期时间API来获取标准时间。
在新的日期时间API中，我们可以使用Instant类来表示时间戳，通过调用now()方法来获取当前的时间戳，如下所示：```java。
Instant now = Instant.now();```。
通过Instant类，我们同样可以获取到系统当前的标准时间。
与Date类不同，Instant类是不可变且线程安全的，更适合在多线程环境下使用。
除了获取系统当前时间外，我们还可以获取特定时区的标准时间。
在新的日期时间API中，提供了ZoneId和ZonedDateTime类来表示时区和带时区的日期时间。
我们可以通过指定时区来获取对应时区的标准时间，如下所示：```java。
ZoneId zoneId = ZoneId.of("Asia/Shanghai");ZonedDateTime now = ZonedDateTime.now(zoneId);```。
通过这种方式，我们可以获取到指定时区的标准时间。
这在处理跨时区的应用中尤为重要。
除了获取系统当前时间和特定时区的时间外，我们还经常需要对时间进行格式化。
在新的日期时间API中，提供了DateTimeFormatter类来进行时间格式化。
JNI编程指南
JNI编程指南JNI（Java Native Interface）是一个Java编程接口，它允许Java 代码与本地代码（如C、C++）进行交互。
它为Java开发人员提供了访问本机操作系统和硬件的能力，同时也可以利用现有的本地库和代码。
在本文中，我们将提供一个详细的JNI编程指南，包括如何设置JNI环境、如何声明本地方法、如何实现本地方法和JNI安全。
###1.设置JNI环境在开始编写JNI代码之前，你需要设置JNI环境。
首先，你需要安装Java Development Kit（JDK），并确保Java运行时环境（JRE）也已正确安装。
然后，你需要在系统路径中添加JDK的路径，以便在命令行中可以访问到Java和Javac。
最后，你需要设置Java的编译和运行时环境变量，以便在编译和运行时可以找到JNI的头文件和库。
###2.声明本地方法在Java代码中，你需要使用`native`关键字来声明本地方法。
本地方法是一个在Java代码中声明但在本地代码中实现的方法。
例如，以下是一个声明本地方法的示例：```javapublic class HelloWorldpublic native void sayHello(;```###3.实现本地方法要实现本地方法，你需要编写本地代码（如C、C++），并使用JNI提供的函数来与Java代码交互。
首先，你需要使用`javah`命令生成JNI头文件，该头文件包含了你声明的所有本地方法。
然后，你需要使用C/C++编译器将本地代码编译为本地库。
最后，在Java代码中加载本地库。
以下是一个实现本地方法的示例：```c#include <jni.h>#include <stdio.h>#include "HelloWorld.h"JNIEXPORT void JNICALL Java_HelloWorld_sayHello(JNIEnv *env, jobject obj)printf("Hello World!\n");```###4.加载本地库要加载本地库，你需要使用`System.loadLibrary(`方法。
Java中计算时间和日期的方式
Java中计算时间和⽇期的⽅式Java 中计算时间和⽇期的⽅式简要： Java中计算⽇期时间的有 Date类加 SimpleDateFormat类和 System类中的 currentTimeMillis ⽅法，还有专门⽤于⽇期的 Calendar类。
这⾥就介绍如何使⽤这三种⽅式获取当前时间，以及⼀些注意点。
注意：当前计算机时间是跟你的计算机所在时区是有关的所以会有时差GMT时间(格林威治时间)1970年1⽉1号0时0分0秒中国东⼋区相差8⼩时(北京时间)1970年1⽉1号8时0分0秒⼀、Date 类加 SimpleDateFormat 类// 注意使⽤的是 java.util 包下的Date date = new Date();/*常⽤的：yyyy 年（年份四位数）MM ⽉（两位数 12个⽉）dd ⽇两位数不确定）HH 时 24制 / hh 12制mm 分（两位数 60进制）ss 秒（两位数 60进制）SSS 毫秒（1000 毫秒 == 1 秒）*/// java.text 包下的，⽤于⽇期格式化// 其它符号如（- : .）就是连接符，原样输出，也可以是中⽂SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM⽉dd⽇ hh时mm分ss秒");System.out.println(date);// Thu Nov 26 10:43:47 CST 2020System.out.println(sdf1.format(date));// 2020-11-26 10:43:47.999System.out.println(sdf2.format(date));// 2020年11⽉26⽇ 10时51分02秒// String 转 Date 使⽤ SimpleDateFormat 的 parse ⽅法// 格式需要相同，否则会解析异常抛出 ParseExceptiontry {String time = "2008-08-08 08:08:08.888";Date parse = sdf1.parse(time);System.out.println(parse);// Fri Aug 08 08:08:08 CST 2008} catch (ParseException e) {e.printStackTrace();}// 参数是毫秒，从1970年1⽉1⽇00:00:00开始的总毫秒数。
JAVA中的时间操作
JAVA中的时间操作java中的时间操作不外乎这四种情况：1、获取当前时间2、获取某个时间的某种格式3、设置时间4、时间的运算好，下面就针对这四种情况，一个一个搞定。
一、获取当前时间有两种方式可以获得，第一种，使用Date类。
j2SE的包里有两个Date类，一个是java.sql.Date,一个是java.util.Date这里，要使用java.util.Date。
获取当前时间的代码如下Date date = new Date();date.getTime();还有一种方式，使用System.currentTimeMillis();这两种方式获得的结果是一样的，都是得到一个当前的时间的long型的时间的毫秒值，这个值实际上是当前时间值与1970年一月一号零时零分零秒相差的毫秒数。
当前的时间得到了，但实际的应用中最后往往不是要用这个long型的东西，用户希望得到的往往是一个时间的字符串，比如“2006年6月18号”，或“2006-06-18”，老外可能希望得到的是“06-18-2006”，诸如此类等等。
这就是下一个要解决的问题二、获取某个时间的某种格式获取时间的格式，需要用到一个专门用于时间格式的类java.text.SimpleDateFormat。
首先，定义一个SimpleDateFormat变量SimpleDateFormat sdf = new SimpleDateFormat("",Locale.SIMPLIFIED_CHINESE);这个构造函数的定义如下：SimpleDateFormat(String pattern, Locale locale)第一个参数pattern，我们后面再解释，这里我们使用一个"",第二个参数，是用来设置时区的，这里用到了java.util.Locale这个类，这个类了面定义了很多静态变量，直接拿过来用就OK，我们把时区设置为Locale.SIMPLIFIED_CHINESE，只看名字，这个静态变量的意义已经很清楚了。
Java获取指定日期的实现方法总结
Java获取指定⽇期的实现⽅法总结格式化⽇期 String-->Date 或者 Data-->StringSimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");Date date = sdf.parse("2009-11-04");//String-->DateString sdate = sdf.format(date );// Data-->String =============================================================== package com.hefeng.test;import java.text.DateFormat;import java.text.ParsePosition;import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date;import java.util.GregorianCalendar;public class TimeTest {//⽤来全局控制上⼀周，本周，下⼀周的周数变化private int weeks = 0;private int MaxDate;//⼀⽉最⼤天数private int MaxYear;//⼀年最⼤天数/*** @param args*/public static void main(String[] args) {TimeTest tt = new TimeTest();System.out.println("得到6个⽉后的⽇期:"+tt .getAfterMonth(6);System.out.println("获取当天⽇期:"+tt.getNowTime("yyyy-MM-dd"));System.out.println("获取本周⼀⽇期:"+tt.getMondayOFWeek());System.out.println("获取本周⽇的⽇期~:"+tt.getCurrentWeekday());System.out.println("获取上周⼀⽇期:"+tt.getPreviousWeekday());System.out.println("获取上周⽇⽇期:"+tt.getPreviousWeekSunday());System.out.println("获取下周⼀⽇期:"+tt.getNextMonday());System.out.println("获取下周⽇⽇期:"+tt.getNextSunday());System.out.println("获得相应周的周六:"+tt.getNowTime("yyyy-MM-dd"));System.out.println("获取本⽉第⼀天⽇期:"+tt.getFirstDayOfMonth());System.out.println("获取本⽉最后⼀天⽇期:"+tt.getDefaultDay());System.out.println("获取上⽉第⼀天⽇期:"+tt.getPreviousMonthFirst());System.out.println("获取上⽉最后⼀天的⽇期:"+tt.getPreviousMonthEnd());System.out.println("获取下⽉第⼀天⽇期:"+tt.getNextMonthFirst());System.out.println("获取下⽉最后⼀天⽇期:"+tt.getNextMonthEnd());System.out.println("获取本年的第⼀天⽇期:"+tt.getCurrentYearFirst());System.out.println("获取本年最后⼀天⽇期:"+tt.getCurrentYearEnd());System.out.println("获取去年的第⼀天⽇期:"+tt.getPreviousYearFirst());System.out.println("获取去年的最后⼀天⽇期:"+tt.getPreviousYearEnd());System.out.println("获取明年第⼀天⽇期:"+tt.getNextYearFirst());System.out.println("获取明年最后⼀天⽇期:"+tt.getNextYearEnd());System.out.println("获取本季度第⼀天到最后⼀天:"+tt.getThisSeasonTime(11));System.out.println("获取两个⽇期之间间隔天数2008-12-1~2008-.29:"+TimeTest.getTwoDay("2008-12-1","2008-9-29"));}/*** 得到指定⽉后（前）的⽇期参数传负数即可*/public static String getAfterMonth(int month) {Calendar c = Calendar.getInstance();//获得⼀个⽇历的实例SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");Date date = null;try{date = sdf.parse("2009-11-04");//初始⽇期}catch(Exception e){}c.setTime(date);//设置⽇历时间c.add(Calendar.MONTH,month);//在⽇历的⽉份上增加6个⽉String strDate = sdf.format(c.getTime()));//的到你想要得6个⽉后的⽇期return strDate;}/*** 得到⼆个⽇期间的间隔天数*/public static String getTwoDay(String sj1, String sj2) { SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd"); long day = 0;try {java.util.Date date = myFormatter.parse(sj1);java.util.Date mydate = myFormatter.parse(sj2);day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);} catch (Exception e) {return "";}return day + "";}/*** 根据⼀个⽇期，返回是星期⼏的字符串*/public static String getWeek(String sdate) {// 再转换为时间Date date = TimeTest.strToDate(sdate);Calendar c = Calendar.getInstance();c.setTime(date);// int hour=c.get(Calendar.DAY_OF_WEEK);// hour 中存的就是星期⼏了，其范围 1~7// 1=星期⽇ 7=星期六，其他类推return new SimpleDateFormat("EEEE").format(c.getTime());}/*** 将短时间格式字符串转换为时间 yyyy-MM-dd*/public static Date strToDate(String strDate) {SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd"); ParsePosition pos = new ParsePosition(0);Date strtodate = formatter.parse(strDate, pos);return strtodate;}/*** 两个时间之间的天数** @param date1* @param date2* @return*/public static long getDays(String date1, String date2) {if (date1 == null || date1.equals(""))return 0;if (date2 == null || date2.equals(""))return 0;// 转换为标准时间SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd"); java.util.Date date = null;java.util.Date mydate = null;try {date = myFormatter.parse(date1);mydate = myFormatter.parse(date2);} catch (Exception e) {}long day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000); return day;}// 计算当⽉最后⼀天,返回字符串public String getDefaultDay(){String str = "";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); Calendar lastDate = Calendar.getInstance();lastDate.set(Calendar.DATE,1);//设为当前⽉的1 号lastDate.add(Calendar.MONTH,1);//加⼀个⽉，变为下⽉的1 号lastDate.add(Calendar.DATE,-1);//减去⼀天，变为当⽉最后⼀天str=sdf.format(lastDate.getTime());return str;}// 上⽉第⼀天public String getPreviousMonthFirst(){String str = "";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); Calendar lastDate = Calendar.getInstance();lastDate.set(Calendar.DATE,1);//设为当前⽉的1 号lastDate.add(Calendar.MONTH,-1);//减⼀个⽉，变为下⽉的1 号//lastDate.add(Calendar.DATE,-1);//减去⼀天，变为当⽉最后⼀天str=sdf.format(lastDate.getTime());return str;}//获取当⽉第⼀天public String getFirstDayOfMonth(){String str = "";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); Calendar lastDate = Calendar.getInstance();lastDate.set(Calendar.DATE,1);//设为当前⽉的1 号str=sdf.format(lastDate.getTime());return str;}// 获得本周星期⽇的⽇期public String getCurrentWeekday() {weeks = 0;int mondayPlus = this.getMondayPlus();GregorianCalendar currentDate = new GregorianCalendar(); currentDate.add(GregorianCalendar.DATE, mondayPlus+6);Date monday = currentDate.getTime();DateFormat df = DateFormat.getDateInstance();String preMonday = df.format(monday);return preMonday;}//获取当天时间public String getNowTime(String dateformat){Date now = new Date();SimpleDateFormat dateFormat = new SimpleDateFormat(dateformat);//可以⽅便地修改⽇期格式String hehe = dateFormat.format(now);return hehe;}// 获得当前⽇期与本周⽇相差的天数private int getMondayPlus() {Calendar cd = Calendar.getInstance();// 获得今天是⼀周的第⼏天，星期⽇是第⼀天，星期⼆是第⼆天......int dayOfWeek = cd.get(Calendar.DAY_OF_WEEK)-1; //因为按中国礼拜⼀作为第⼀天所以这⾥减1if (dayOfWeek == 1) {return 0;} else {return 1 - dayOfWeek;}}//获得本周⼀的⽇期public String getMondayOFWeek(){weeks = 0;int mondayPlus = this.getMondayPlus();GregorianCalendar currentDate = new GregorianCalendar(); currentDate.add(GregorianCalendar.DATE, mondayPlus);Date monday = currentDate.getTime();DateFormat df = DateFormat.getDateInstance();String preMonday = df.format(monday);return preMonday;}//获得相应周的周六的⽇期public String getSaturday() {int mondayPlus = this.getMondayPlus();GregorianCalendar currentDate = new GregorianCalendar(); currentDate.add(GregorianCalendar.DATE, mondayPlus + 7 * weeks + 6); Date monday = currentDate.getTime();DateFormat df = DateFormat.getDateInstance();String preMonday = df.format(monday);return preMonday;}// 获得上周星期⽇的⽇期public String getPreviousWeekSunday() {weeks=0;weeks--;int mondayPlus = this.getMondayPlus();GregorianCalendar currentDate = new GregorianCalendar(); currentDate.add(GregorianCalendar.DATE, mondayPlus+weeks);Date monday = currentDate.getTime();DateFormat df = DateFormat.getDateInstance();String preMonday = df.format(monday);return preMonday;}// 获得上周星期⼀的⽇期public String getPreviousWeekday() {weeks--;int mondayPlus = this.getMondayPlus();GregorianCalendar currentDate = new GregorianCalendar(); currentDate.add(GregorianCalendar.DATE, mondayPlus + 7 * weeks); Date monday = currentDate.getTime();DateFormat df = DateFormat.getDateInstance();String preMonday = df.format(monday);return preMonday;}// 获得下周星期⼀的⽇期public String getNextMonday() {weeks++;int mondayPlus = this.getMondayPlus();GregorianCalendar currentDate = new GregorianCalendar(); currentDate.add(GregorianCalendar.DATE, mondayPlus + 7);Date monday = currentDate.getTime();DateFormat df = DateFormat.getDateInstance();String preMonday = df.format(monday);return preMonday;}// 获得下周星期⽇的⽇期public String getNextSunday() {int mondayPlus = this.getMondayPlus();GregorianCalendar currentDate = new GregorianCalendar(); currentDate.add(GregorianCalendar.DATE, mondayPlus + 7+6); Date monday = currentDate.getTime();DateFormat df = DateFormat.getDateInstance();String preMonday = df.format(monday);return preMonday;}private int getMonthPlus(){Calendar cd = Calendar.getInstance();int monthOfNumber = cd.get(Calendar.DAY_OF_MONTH);cd.set(Calendar.DATE, 1);//把⽇期设置为当⽉第⼀天cd.roll(Calendar.DATE, -1);//⽇期回滚⼀天，也就是最后⼀天MaxDate=cd.get(Calendar.DATE);if(monthOfNumber == 1){return -MaxDate;}else{return 1-monthOfNumber;}}//获得上⽉最后⼀天的⽇期public String getPreviousMonthEnd(){String str = "";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); Calendar lastDate = Calendar.getInstance();lastDate.add(Calendar.MONTH,-1);//减⼀个⽉lastDate.set(Calendar.DATE, 1);//把⽇期设置为当⽉第⼀天lastDate.roll(Calendar.DATE, -1);//⽇期回滚⼀天，也就是本⽉最后⼀天str=sdf.format(lastDate.getTime());return str;}//获得下个⽉第⼀天的⽇期public String getNextMonthFirst(){String str = "";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); Calendar lastDate = Calendar.getInstance();lastDate.add(Calendar.MONTH,1);//减⼀个⽉lastDate.set(Calendar.DATE, 1);//把⽇期设置为当⽉第⼀天str=sdf.format(lastDate.getTime());return str;}//获得下个⽉最后⼀天的⽇期public String getNextMonthEnd(){String str = "";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); Calendar lastDate = Calendar.getInstance();lastDate.add(Calendar.MONTH,1);//加⼀个⽉lastDate.set(Calendar.DATE, 1);//把⽇期设置为当⽉第⼀天lastDate.roll(Calendar.DATE, -1);//⽇期回滚⼀天，也就是本⽉最后⼀天str=sdf.format(lastDate.getTime());return str;}//获得明年最后⼀天的⽇期public String getNextYearEnd(){String str = "";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");Calendar lastDate = Calendar.getInstance();lastDate.add(Calendar.YEAR,1);//加⼀个年lastDate.set(Calendar.DAY_OF_YEAR, 1);lastDate.roll(Calendar.DAY_OF_YEAR, -1);str=sdf.format(lastDate.getTime());return str;}//获得明年第⼀天的⽇期public String getNextYearFirst(){String str = "";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");Calendar lastDate = Calendar.getInstance();lastDate.add(Calendar.YEAR,1);//加⼀个年lastDate.set(Calendar.DAY_OF_YEAR, 1);str=sdf.format(lastDate.getTime());return str;}//获得本年有多少天private int getMaxYear(){Calendar cd = Calendar.getInstance();cd.set(Calendar.DAY_OF_YEAR,1);//把⽇期设为当年第⼀天cd.roll(Calendar.DAY_OF_YEAR,-1);//把⽇期回滚⼀天。
java获取当前日期和时间的二种方法分享
java获取当前⽇期和时间的⼆种⽅法分享有两种⽅法：⽅法⼀：⽤java.util.Date类来实现，并结合java.text.DateFormat类来实现时间的格式化，看下⾯代码：复制代码代码如下:import java.util.*;import java.text.*;//以下默认时间⽇期显⽰⽅式都是汉语语⾔⽅式//⼀般语⾔就默认汉语就可以了，时间⽇期的格式默认为MEDIUM风格，⽐如：2008-6-16 20:54:53//以下显⽰的⽇期时间都是再Date类的基础上的来的，还可以利⽤Calendar类来实现见类TestDate2.javapublic class TestDate {public static void main(String[] args) {Date now = new Date();Calendar cal = Calendar.getInstance();DateFormat d1 = DateFormat.getDateInstance(); //默认语⾔（汉语）下的默认风格（MEDIUM风格，⽐如：2008-6-16 20:54:53）String str1 = d1.format(now);DateFormat d2 = DateFormat.getDateTimeInstance();String str2 = d2.format(now);DateFormat d3 = DateFormat.getTimeInstance();String str3 = d3.format(now);DateFormat d4 = DateFormat.getInstance(); //使⽤SHORT风格显⽰⽇期和时间String str4 = d4.format(now);DateFormat d5 = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL); //显⽰⽇期，周，时间（精确到秒）String str5 = d5.format(now);DateFormat d6 = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG); //显⽰⽇期。
java中获取日期和时间的方法总结
java中获取⽇期和时间的⽅法总结1、获取当前时间，和某个时间进⾏⽐较。
此时主要拿long型的时间值。
⽅法如下：要使⽤ java.util.Date 。
获取当前时间的代码如下Date date = new Date();date.getTime() ;还有⼀种⽅式，使⽤ System.currentTimeMillis() ;都是得到⼀个当前的时间的long型的时间的毫秒值，这个值实际上是当前时间值与1970年⼀⽉⼀号零时零分零秒相差的毫秒数⼀、获取当前时间, 格式为: yyyy-mm-dd hh-mm-ssDateFormat.getDateTimeInstance(2, 2, Locale.CHINESE).format(new java.util.Date());⼆、获取当前时间, 格式为: yyyy年mm⽉dd⽇上午/下午hh时mm分ss秒1 DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, Locale.CHINESE).format(new java.util.Date());三、获取当前时间(精确到毫秒), 格式为: yyyy-mm-dd hh:mm:ss.nnn1new java.sql.Timestamp(System.currentTimeMillis()).toString();⼀. 获取当前系统时间和⽇期并格式化输出:1import java.util.Date;2import java.text.SimpleDateFormat;3public class NowString {4public static void main(String[] args) {5 SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置⽇期格式6 System.out.println(df.format(new Date()));// new Date()为获取当前系统时间7 }8 }⼆. 在数据库⾥的⽇期只以年-⽉-⽇的⽅式输出，可以⽤下⾯两种⽅法：1、⽤convert()转化函数：String sqlst = "select convert(varchar(10),bookDate,126) as convertBookDate from roomBook where bookDate between '2007-4-10' and '2007-4-25'" System.out.println(rs.getString("convertBookDate"));2、利⽤SimpleDateFormat类：先要输⼊两个java包：import java.util.Date;import java.text.SimpleDateFormat;然后：定义⽇期格式：SimpleDateFormat sdf = new SimpleDateFormat(yy-MM-dd);sql语句为：String sqlStr = "select bookDate from roomBook where bookDate between '2007-4-10' and '2007-4-25'";输出：System.out.println(df.format(rs.getDate("bookDate")));3、java中获取当前⽇期和时间的⽅法1)如何取得年⽉⽇、⼩时分秒？2)如何取得从1970 年到现在的毫秒数？3)如何取得某个⽇期是当⽉的最后⼀天？4)如何格式化⽇期？1import java.sql.Date;2import java.text.SimpleDateFormat;3import java.util.Calendar;45public class Demo12 {67/**8 * @param args9*/10public static void main(String[] args) {11// TODO Auto-generated method stub12 Calendar c = Calendar.getInstance();13 System.out.println("年：" + c.get(Calendar.YEAR));14 System.out.println("⽉：" + (c.get(Calendar.MONTH) + 1));15 System.out.println("⽇：" + c.get(Calendar.DAY_OF_MONTH));16 System.out.println("24时制⼩时：" + c.get(Calendar.HOUR_OF_DAY));17 System.out.println("12时制：" + c.get(Calendar.HOUR));18 System.out.println("分：" + c.get(Calendar.MINUTE));19 System.out.println("秒：" + c.get(Calendar.SECOND));20 System.out.println("今天是⼀年中的第：" + c.get(Calendar.DAY_OF_YEAR) + "天");21//-------毫秒数2223long currentSec = System.currentTimeMillis();24 System.out.println("毫秒数为：" + currentSec);2526//------⽇期最后⼀天2728int maxDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);29 System.out.println("当前⽇期最后⼀天：" + maxDay);3031//-------格式化⽇期3233 String format = "yyyy年MM⽉dd⽇ HH:mm:ss";34 SimpleDateFormat SDF = new SimpleDateFormat(format);35 String timer = SDF.format(new Date(currentSec));36 System.out.println("格式化⽇期后：" + timer);3738 }3940 }⼆1import java.util.Date;2import java.util.Calendar;3import java.text.SimpleDateFormat;4public class TestDate{5public static void main(String[] args){6 Date now = new Date();7 SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//可以⽅便地修改⽇期格式89 String hehe = dateFormat.format( now );10 System.out.println(hehe);11 Calendar c = Calendar.getInstance();//可以对每个时间域单独修改14int year = c.get(Calendar.YEAR);15int month = c.get(Calendar.MONTH);16int date = c.get(Calendar.DATE);17int hour = c.get(Calendar.HOUR_OF_DAY);18int minute = c.get(Calendar.MINUTE);19int second = c.get(Calendar.SECOND);20 System.out.println(year + "/" + month + "/" + date + " " +hour + ":" +minute + ":" + second);21 }22 }23有时候要把String类型的时间转换为Date类型，通过以下的⽅式，就可以将你刚得到的时间字符串转换为Date类型了。
Java各种获取系统当前时间方法和格式
Java各种获取系统当前时间方法和格式想索取更多相关资料请加qq：649085085或登录PS;本文档由北大青鸟广安门收集自互联网，仅作分享之用。
如何利用JA V A快速准确提取当前系统时间方法和格式，我们先来看实现代码：01./**02. * 返回当前日期时间字符串<br>03. * 默认格式：yyyy-mm-dd hh:mm:ss04. *05. * @return String 返回当前字符串型日期时间06. */07. public static String getCurrentTime（）{08. String returnStr = null;09. SimpleDateFormat f = new SimpleDateFormat（"yyyy-MM-dd HH:mm:ss"）；10. Date date = new Date（）；11. returnStr = f.format（date）；12. return returnStr;13. }14.15. /**16. * 返回当前日期时间字符串<br>17. * 默认格式：yyyymmddhhmmss18. *19. * @return String 返回当前字符串型日期时间20. */21. public static BigDecimal getCurrentTimeAsNumber（）{22. String returnStr = null;23. SimpleDateFormat f = new SimpleDateFormat（"yyyyMMddHHmmss"）；24. Date date = new Date（）；25. returnStr = f.format（date）；26. return new BigDecimal（returnStr）；27. }28.29.30. /**31. * 返回自定义格式的当前日期时间字符串32. *33. * @param format34. * 格式规则35. * @return String 返回当前字符串型日期时间36. */37. public static String getCurrentTime（String format）{38. String returnStr = null;39. SimpleDateFormat f = new SimpleDateFormat（format）；40. Date date = new Date（）；41. returnStr = f.format（date）；42. return returnStr;43. }44.45. /**46. * 返回当前字符串型日期47. *48. * @return String 返回的字符串型日期49. */50. public static String getCurDate（）{51. Calendar calendar = Calendar.getInstance（）；52. SimpleDateFormat simpledateformat = new SimpleDateFormat（"yyyy-MM-dd"）；53. String strDate = simpledateformat.format（calendar.getTime（））；54. return strDate;55. }56.57. /**58. * 返回指定格式的字符型日期59. * @param date60. * @param formatString61. * @return62. */63. public static String Date2String（Date date, String formatString）{64. if （G4Utils.isEmpty（date））{65. return null;66. }67. SimpleDateFormat simpledateformat = new SimpleDateFormat（formatString）；68. String strDate = simpledateformat.format（date）；69. return strDate;70. }71.72. /**73. * 返回当前字符串型日期74. *75. * @param format76. * 格式规则77. *78. * @return String 返回的字符串型日期79. */80. public static String getCurDate（String format）{81. Calendar calendar = Calendar.getInstance（）；82. SimpleDateFormat simpledateformat = new SimpleDateFormat（format）；83. String strDate = simpledateformat.format（calendar.getTime（））；84. return strDate;85. }86.87. /**88. * 返回TimeStamp对象89. *90. * @return91. */92. public static Timestamp getCurrentTimestamp（）{93. Object obj = TypeCaseHelper.convert（getCurrentTime（），"Timestamp", "yyyy-MM-dd HH:mm:ss"）；94. if （obj != null）95. return （Timestamp）obj;96. else97. return null;98. }99.100. /**101. * 将字符串型日期转换为日期型102. *103. * @param strDate104. * 字符串型日期105. * @param srcDateFormat106. * 源日期格式107. * @param dstDateFormat108. * 目标日期格式109. * @return Date 返回的util.Date型日期110. */111. public static Date stringToDate（String strDate, String srcDateFormat, String dstDateFormat）{112. Date rtDate = null;113. Date tmpDate = （new SimpleDateFormat（srcDateFormat））。
J2EE核心技术(13种)
J2EE核心技术（13种）在企业级应用中,都有一些通用企业需求模块,如数据库连接,邮件服务,事务处理等.既然很多企业级应用都需要这些模块,一些大公司便开发了自己的通用模块服务,即中间件.这样一来,就避免了重复开发,开发周期长和代码可靠性差等问题.但是,各公司的中间件不兼容的问题就出现了,用户无法将它们组装在一起为自己服务.于是,"标准"就应运而生了.J2EE就是基于Java技术的一系列标准.J2EE是Java2平台企业版(Java 2Platform Enterprise Edition),核心是一组技术规范与指南,其中所包含的各类组件,服务架构和技术层次,都有共同的标准及规格,让各种依云J2EE架构的不同平台之间,存在良好的兼容性.1.JDBC(JavaDatabase Connectivity)JDBC是以统一方式访问数据库的API.它提供了独立于平台的数据库访问,也就是说,有了JDBC API,我们就不必为访问Oracle数据库专门写一个程序,为访问Sybase数据库又专门写一个程序等等,只需要用JDBC API写一个程序就够了,它可以向相应数据库发送SQL调用.JDBC是Java应用程序与各种不同数据库之间进行对话的方法的机制.简单地说,它做了三件事:与数据库建立连接--发送操作数据库的语句--处理结果.2.JNDI(JavaName and Directory Interface)JNDI是一组在Java应用中访问命名和目录服务的API.(命名服务将名称和对象联系起来,我们即可用名称访问对象.JNDI允许把名称同Java对象或资源关联起来,建立逻辑关联,而不必知道对象或资源的物理ID.)JNDI为开发人员提供了查找和访问各种命名和目录服务的通用,统一的接口,可访问的目录及服务如下表:利用JNDI的命名与服务功能可满足企业级API对命名与服务的访问,诸如EJB,JMS,JDBC 2.0以及IIOP上的RMI通过JNDI来使用CORBA的命名服务.JNDI和JDBC类似,都是构建在抽象层上.因为:它提供了标准的独立于命名系统的API,这些API构建在命名系统之上.这一层有助于将应用与实际数据源分离,因此不管是访问的LDAP,RMI还是DNS.也就是说,JNDI独立于目录服务的具体实现,只要有目录的服务提供接口或驱动,就可以使用目录.3.EJB(EnterpriseJavaBean)J2EE将业务逻辑从客户端软件中抽取出来，封装在一个组件中。
【Java】如何获取文件的创建时间、更新时间
【Java】如何获取⽂件的创建时间、更新时间⼀、通过下⾯⽅式 BasicFileAttributes attr = null;try {Path path = file.toPath();attr = Files.readAttributes(path, BasicFileAttributes.class);} catch (IOException e) {e.printStackTrace();}// 创建时间Instant instant = attr.creationTime().toInstant();⼆、完整代码public class ReadFileTimeUtils {public static String file = "/Users/zhangboqing/Downloads/testfileclassify copy/Archives/2020-21-07/11.dmg";public static void main(String[] args) throws IOException {File f = new File(file);System.out.println(getCreationTime(f));// Path file = f.toPath();// BasicFileAttributes attr = Files.readAttributes(file, BasicFileAttributes.class);// System.out.println("creationTime: " + attr.creationTime());// System.out.println("lastAccessTime: " + stAccessTime());// System.out.println("lastModifiedTime: " + stModifiedTime());}public static String getCreationTime(File file) {if (file == null) {return null;}BasicFileAttributes attr = null;try {Path path = file.toPath();attr = Files.readAttributes(path, BasicFileAttributes.class);} catch (IOException e) {e.printStackTrace();}// 创建时间Instant instant = attr.creationTime().toInstant();// 更新时间// Instant instant = stModifiedTime().toInstant();// 上次访问时间// Instant instant = stAccessTime().toInstant();String format = DateTimeFormatter.ofPattern("yyyy-MM-dd").withZone(ZoneId.systemDefault()).format(instant);return format;}}。
JAVA获取文件创建时间
JAVA获取文件创建时间在jdk中，File的操作并没有取得文件创建时间的方法。
唯一提供提供的方法是lastModified()返回long值。
牺牲创建时间的方法实在是为了满足跨平台的需要。
但在windows环境中，需要取得文件创建时间的情况是存在的。
实现的办法是通过windows本地命令行来取得创建日期。
以下代码主要参照/thread.jspa?threadID=311281&messageID=1247450 import java.io.BufferedReader;import java.io.File;import java.io.InputStreamReader;import java.util.StringTokenizer;public class Timetake {/*** @param _file _file* @return datetime datetime*/public static String getFileCreateDate(File _file) {File file = _file;try {Process ls_proc = Runtime.getRuntime().exec("cmd.exe /c dir " + file.getAbsolutePath() + " /tc");BufferedReader br = new BufferedReader(new InputStreamReader(ls_proc.getInputStream()));for (int i = 0; i < 5; i++) {br.readLine();}String stuff = br.readLine();StringTokenizer st = new StringTokenizer(stuff);String dateC = st.nextToken();String time = st.nextToken();String datetime = dateC.concat(time);br.close();return datetime;} catch (Exception e) {return null;}}}File file = new File("C:\ xh\\102.txt");String time = Timetake.getFileCreateDate(file);。
获取和设置文件和文件夹的时间属性
获取和设置文件、文件夹的时间属性摘要：介绍了windows程序设计中文件和文件夹时间属性和大小的获取和设置。
关键字：VC时间属性GetFileTime SetFileTime GetFileSize一获取文件或文件夹的时间属性在遍历文件夹时用到了WIN32_FIND_DATA结构体和FindFirstFile函数，通过这两者可以得到文件或文件夹的详细属性信息。
在WIN32_FIND_DATA结构体中包含了文件或文件夹的全部属性信息，如基本属性（隐藏、只读等）、时间属性（创建、修改、访问时间）、文件大小。
typedef struct_WIN32_FIND_DATA{//wfdDWORD dwFileAttributes;//文件属性FILETIME ftCreationTime;//创建时间FILETIME ftLastAccessTime;//最后访问时间FILETIME ftLastWriteTime;//最后修改的时间DWORD nFileSizeHigh;//文件长度高32位DWORD nFileSizeLow;//文件长度低32位DWORD dwReserved0;//保留DWORD dwReserved1;//保留TCHAR cFileName[MAX_PATH];//文件名TCHAR cAlternateFileName[14];//8.3格式文件名}WIN32_FIND_DATA;例如要获取”C:\\abc.exe”文件的属性可以用如下代码：WIN32_FIND_DATA fileData；HANDLE hFileAttributes=FindFirstFile(”C:\\abc.exe”,&fileData);FindClose(hFileAttributes);通过上面的代码，就将文件”C:\\abc.exe”的属性存放到fileData中了。
但需要注意的是：不能够手动修改WIN32_FIND_DATA中数据的值，只能作为只读数据来使用。
java获取时间戳的方法
java获取时间戳的⽅法JAVA 获取当前⽉的初始时间的时间戳1. public static long getMonthFirstDay() {2. Calendar calendar = Calendar.getInstance();// 获取当前⽇期3. calendar.add(Calendar.MONTH, 0);4. calendar.set(Calendar.DAY_OF_MONTH, 1);// 设置为1号,当前⽇期既为本⽉第⼀天5. calendar.set(Calendar.HOUR_OF_DAY, 0);6. calendar.set(Calendar.MINUTE, 0);7. calendar.set(Calendar.SECOND, 0);8. System.out.println(calendar.getTimeInMillis());9.10. return calendar.getTimeInMillis();11. }获取当前时间戳//⽅法⼀System.currentTimeMillis();//⽅法⼆Calendar.getInstance().getTimeInMillis();//⽅法三new Date().getTime();Calendar.getInstance().getTimeInMillis() 这种⽅式速度最慢，这是因为Canlendar要处理时区问题会耗费较多的时间。
在开发过程中，通常很多⼈都习惯使⽤new Date()来获取当前时间，使⽤起来也⽐较⽅便，同时还可以获取与当前时间有关的各⽅⾯信息，例如获取⼩时，分钟等等，⽽且还可以格式化输出，包含的信息是⽐较丰富的。
但是有些时候或许你并不需要获取那么多信息，你只需要关⼼它返回的毫秒数就⾏了，例如getTime()。
为了获取这个时间戳，很多⼈也喜欢使⽤new Date().getTime()去获取，咋⼀看没什么问题，但其实没这个必要。
Java利用JNI获取文件创建时间
/* 代码： extern "C" JNIEXPORT jstring JNICALL Java_com_zhanrui_MyFileTime_getFileCreationTime(JNIEnv *env, jclass cls, jstring FileName) { HANDLE hFile; FILETIME creationTime; FILETIME lastAccessTime; FILETIME lastWriteTime; FILETIME creationLocalTime; SYSTEMTIME creationSystemTime; jstring result; char fileTimeString[30]; char *zhanrui= jstringToWindows(env, FileName);//支持中文 hFile = CreateFile(zhanrui, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL); if (hFile == INVALID_HANDLE_VALUE) return env->NewStringUTF(""); if (GetFileTime(hFile, &creationTime, &lastAccessTime, &lastWriteTime)) { if (FileTimeToLocalFileTime(&creationTime, &creationLocalTime)) { if (FileTimeToSystemTime(&creationLocalTime, &creationSystemTime)) { sprintf(fileTimeString, "%d-%d-%d %d:%d:%d.%d\0",//"%d-%d-%d %d:%d:%d.%d\0", 如果需要 精确到毫秒，加上.%d 并且加上后面的creationSystemTime.wMilliseconds creationSystemTime.wYear, creationSystemTime.wMonth, creationSystemTime.wDay, creationSystemTime.wHour, creationSystemTime.wMinute, creationSystemTime.wSecond //,creationSystemTime.wMilliseconds 上.%d 并且加上这里面的creationSystemTime.wMilliseconds ); result = env->NewStringUTF(fileTimeString); } else } else result = env->NewStringUTF(""); } else result = env->NewStringUTF(""); CloseHandle(hFile); return result; } result = env->NewStringUTF(""); // 如果需要精确到毫秒，加
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
前言：在我写这篇文章之前，我说说我的碰到这个问题的起因。
公司让我写一个jar包，需要获得指定文件的创建日期（日期必须是完整地年月日时分秒）。
对于java jdk1.7来说很容易，因为1.7给了我们获得创建日期的接口。
但是对于jdk1.6来说，那就是一个老大难，没有提供，只提供了获得最后修改日期的接口。
对于jdk1.6，当然我也查过，请教过好多人，给出了解决办法，那就是使用Java的Runtime 去调用当前操作系统的指令获得文件的创建日期：例如在windows下，public String getFileCreateDate(File _file) {File file = _file;try {Process ls_proc = Runtime.getRuntime().exec("cmd.exe /c dir " + file.getAbsolutePath() + " /tc");BufferedReader br = new BufferedReader(new InputStreamReader( ls_proc.g etInputStream()));for (int i = 0; i < 5; i++) {br.readLine();}String stuff = br.readLine();StringTokenizer st = new StringTokenizer(stuff);String dateC = st.nextToken();String time = st.nextToken();String datetime = dateC.concat(time);SimpleDateFormat formatter1 = new SimpleDateFormat( "yyyy-MM-dd hh:mm: ss");SimpleDateFormat formatter2 = new SimpleDateFormat("yyyy/MM/ddHH:mm");datetime = formatter1.format(formatter2.parse(datetime));br.close();return datetime;} catch (Exception e) {return null;}}引用：/question/535215288.html但是这个方法只能或得到文件的年月日时分，不能获得到秒。
为了获得到秒，最后使用了j ni。
步骤：1、使用c和C++ 写一个获得文件创建时间的类#pragma once // Modify the following defines if you have to target a platform p rior to the ones specified below. // Refer to MSDN for the latest info on corre sponding values for different platforms. #ifndef WINVER // Allow use of features specific to Windows XP or later. #define WINVER 0x0501 // Change this to the appropriate value to target other versions of Windows. #endif #ifndef _WIN32_WI NNT // Allow use of features specific to Windows XP or later. #define _WIN32_WI NNT 0x0501 // Change this to the appropriate value to target other versions of Windows. #endif #ifndef _WIN32_WINDOWS // Allow use of features specific to Win dows 98 or later. #define _WIN32_WINDOWS 0x0410 // Change this to the appropria te value to target Windows Me or later. #endif #ifndef _WIN32_IE // Allow use o f features specific to IE 6.0 or later. #define _WIN32_IE 0x0600 // Change this to the appropriate value to target other versions of IE. #endif #define WIN32_ LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers // Windows Head er Files: #include <windows.h>// WinFileTime.cpp : Defines the entry point for the DLL application. // #inclu de "stdafx.h" #include "FileClass/FileTimeEx.h" #ifdef _MANAGED #pragma managed (push, off) #endif BOOL APIENTRY DllMain( HMODULE hModule, DWORD ul_reason_for_ call, LPVOID lpReserved ) { return TRUE; } JNIEXPORT jstring JNICALL Java_check file_WinFileTime_getFileCreationTime(JNIEnv *env, jobject cls, jstring FileName) { HANDLE hFile; FILETIME creationTime; FILETIME lastAccessTime; FILETIME lastW riteTime; FILETIME creationLocalTime; SYSTEMTIME creationSystemTime; jstring re sult; char fileTimeString[30]; hFile = CreateFileA((char *)env->GetStringUTFCha rs(FileName, 0), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_E XISTING, 0, NULL); if(hFile == INVALID_HANDLE_VALUE) return env->NewStringUTF(" "); if(GetFileTime(hFile, &creationTime, &lastAccessTime, &lastWriteTime)) { if (FileTimeToLocalFileTime(&creationTime, &creationLocalTime)) { if(FileTimeToSys temTime(&creationLocalTime, &creationSystemTime)) { sprintf_s(fileTimeString, " d-d-d d:d:d\0", creationSystemTime.wYear, creationSystemTime.wMonth, creationSy stemTime.wDay, creationSystemTime.wHour, creationSystemTime.wMinute, creationSy stemTime.wSecond), result = env->NewStringUTF(fileTimeString); } else result = env->NewStringUTF(""); } else result = env->NewStringUTF(""); } else result = e nv->NewStringUTF(""); CloseHandle(hFile); return result; } #ifdef _MANAGED #pra gma managed(pop) #endif2、然后生成动态链接文件（*.dll），将这个文件放到C:\Windows\System32和你的java jdk目录下D:\Program Files\Java\jdk1.6.0_18\jre\bin。
3、java文件中写法public final class WinFileTime { static { System.loadLibrary("WinFileTim e"); } private static native String getFileCreationTime(String fileName); public static String getCreationTime(String fileName) { return getFileCreationTime(fileName); } } }注意：头文件与类文件的方法名必须与java中的类名一直，如：c中是Java_checkfi le_WinFileTime_getFileCreationTime,那么java中就是checkfile.WinFileTime.getFile CreationTime(checkfile是包名，WinFileTime是类名，getFileCreationTime是方法名).jdk1.7方法：下载一个jdk1.7帮助文档，看看这个类BasicFileAttributeView 。
Path path=Paths.get(filePath);BasicFileAttributeView basicview=Files.getFileAttributeView(path, BasicFileAttr ibuteView.class,LinkOption.NOFOLLOW_LINKS );BasicFileAttributes attr = basicview.readAttributes();Date createDate = new Date(attr.creationTime().toMillis());//创建时间。