比较器
package aaa;
import java.util.Comparator;
public class ComparatorByLength implements Comparator<String> {
public int compare(String o1, String o2) {
String s1 = (String) o1;
String s2 = (String) o2;
int temp = s1.length() - s2.length();
return temp == 0 ? s1.compareTo(s2) : temp;
}
}
package aaa;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
public class ListDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
demo_1();
demo_2();
demo_3();
Demo4();
}
public static void Demo4() {
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("zhangsan");
list.add("zhaoliu");
list.add("xiaoqiang");
System.out.println(list);
Collections.replaceAll(list, "cba", "NBA");// 原理set(indexOf("cba"),"nba");
System.out.println(list);
Collections.shuffle(list);//使用指定的随机源对指定列表进行置换。
System.out.println(list);
Collections.fill(list, "cc");//将list中的所有元素替换冲cc,此方法用做集合的初始化
System.out.println(list);
}
public static void demo_3() {
// 通过比较器实现倒序排列
TreeSet<String> ts = new TreeSet<String>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
int temp = o2.compareTo(o1);
return temp;
}
});
ts.add("abc");
ts.add("hahaha");
ts.add("zzz");
ts.add("aa");
ts.add("cba");
System.out.println(ts);
// 利用工具类中的方法实现翻转排序，排序规则按照比较器。
TreeSet<String> ts1 = new TreeSet<String>(
Collections.reverseOrder(new ComparatorByLength()));
ts1.add("abc");
ts1.add("hahaha");
ts1.add("zzz");
ts1.add("aa");
ts1.add("cba");
System.out.println(ts1);
}
/**
* 集合工具类排序
*/
public static void demo_1() {
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
System.out.println(list);
Collections.sort(list);
mySort(list);// Collections.sort(list)实现原理
System.out.println(list);
Collections.sort(list, new ComparatorByLength());
mySort(list, new ComparatorByLength());
System.out.println(list);
}
public static <T> void mySort(List<T> list, Comparator<? super T> comp) {
for (int i = 0; i < list.size() - 1; i++) {
for (int j = i + 1; j < list.size(); j++) {
if (comp.compare(list.get(i), list.get(j)) > 0) {
Collections.swap(list, i, j);
}
}
}
}
/**
* @param list
* Collections.sort(list)实现的原理， T extends Comparable<? super
* T>的意思是，所有实现Comparable的接口的类型或者父类实现Comparable接口的类型
*/
public static <T extends Comparable<? super T>> void mySort(List<T> list) {
for (int i = 0; i < list.size() - 1; i++) {
for (int j = i + 1; j < list.size(); j++) {
if (list.get(i).compareTo(list.get(j)) > 0) {
Collections.swap(list, i, j);// 交换位置
}
}
}
}
public static void demo_2() {
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
System.out.println(list);
Collections.sort(list);
int index = Collections.binarySearch(list, "cba");
System.out.println("index=" + index);
String max = Collections.max(list, new ComparatorByLength());
System.out.println("max=" + max);
}
}
java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：
给数组赋值：通过fill方法。
对数组排序：通过sort方法,按升序。
比较数组：通过equals方法比较数组中元素值是否相等。
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
import java.util.Arrays;
public class TestArrays {
public static void output(int[] array) {
if (array!=null) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
}
System.out.println();
}
public static void main(String[] args) {
int[] array = new int[5];
//填充数组
Arrays.fill(array, 5);
System.out.println("填充数组：Arrays.fill(array, 5)：");
TestArrays.output(array);
//将数组的第2和第3个元素赋值为8
Arrays.fill(array, 2, 4, 8);
System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");
TestArrays.output(array);
int[] array1 = {7,8,3,2,12,6,3,5,4};
//对数组的第2个到第6个进行排序进行排序
Arrays.sort(array1,2,7);
System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");
TestArrays.output(array1);
//对整个数组进行排序
Arrays.sort(array1);
System.out.println("对整个数组进行排序：Arrays.sort(array1)：");
TestArrays.output(array1);
//比较数组元素是否相等
System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):"+"\n"+Arrays.equals(array, array1));
int[] array2 = array1.clone();
System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):"+"\n"+Arrays.equals(array1, array2));
//使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）
Arrays.sort(array1);
System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)："+"\n"+Arrays.binarySearch(array1, 3));
//如果不存在就返回负数
System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)："+"\n"+Arrays.binarySearch(array1, 9));
}
}
输出结果：
填充数组：Arrays.fill(array, 5)：5 5 5 5 5
将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：5 5 8 8 5
对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：
7 8 2 3 3 6 12 5 4
对整个数组进行排序：Arrays.sort(array1)：2 3 3 4 5 6 7 8 12
比较数组元素是否相等:Arrays.equals(array, array1):
false
克隆后数组元素是否相等:Arrays.equals(array1, array2):true
元素3在array1中的位置：Arrays.binarySearch(array1, 3)：1
元素9在array1中的位置：Arrays.binarySearch(array1, 9)：-9
将数组转成List集合
package aaa;
import java.util.Arrays;
import java.util.List;
public class ArraysDemo {
public static void main(String[] args) {
demo_1();
demo_2();
}
/**
* Arrays.asList方法将数组转化成List集合
*/
public static void demo_1()
{/*
* 重点：List asList(数组)将数组转成集合。
* 好处：其实可以使用集合的方法操作数组中的元素。
* 注意：数组的长度是固定的，所以对于集合的增删方法是不可以使用的
* 否则会发生UnsupportedOperationException
*/
String[] arrStrings={"abc","haha","xixi"};
List<String> list=Arrays.asList(arrStrings);
boolean b1=list.contains("xixi");
//list.add("hehe");//UnsupportedOperationException
System.out.println("list contains="+b1);
}
public static void demo_2()
{
/*
* 如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储。
* 如果数组中的元素是基本类型数值，那么会将该数组作为集合中的元素进行存储。
*/
Integer[] arrIntegers={12,32,434,55,67,87};//
List<Integer> list=Arrays.asList(arrIntegers);
System.out.println(list);//输出结果：[12, 32, 434, 55, 67, 87]
int[] arr={31,11,51,61};
List<int[]> list1=Arrays.asList(arr);
System.out.println(list1.toString());//输出结果：[[I@154ab8e4]
}
}
集合转成数组
package aaa;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ToArray {
public static void main(String[] args) {
/*
* 集合转成数组呢？
* 使用的就是Collection接口中的toArray方法。
* 集合转成数组：可以对集合中的元素操作的方法进行限定。不允许对其进行增删。
*/
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
/*
* toArray方法需要传入一个指定类型的数组。
* 长度该如何定义呢？
* 如果长度小于集合的size，那么该方法会创建一个同类型并和集合相同size的数组。
* 如果长度大于集合的size，那么该方法就会使用指定的数组，存储集合中的元素，其他位置默认为null。
* 所以建议，最后长度就指定为，集合的size。
*/
String[] arrStrings=list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(arrStrings));//输出结果：[abc1, abc2, abc3]
}
}
1、格式：
for(类型 变量 ：Collection集合|数组)
{
}
等同于C#中的foreach
2、传统for和高级for的区别？
传统for可以完成对语句执行很多次，因为可以定义控制循环的增量和条件。
高级for是一种简化形式。
它必须有被遍历的目标。该目标要是数组，要么是Collection单列集合。
对数数组的遍历如果仅仅是获取数组中的元素，可以使用高级for。
如果要对数组的角标进行操作建议使用传统for。
package aaa;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
public class ForEachDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
for (String s:list) {//简化书写
System.out.println(s);
}
int[] arr={2,3,3,4};
for (int i :arr) {
System.out.println(i);
}
Map<Integer, String> map=new LinkedHashMap<Integer,String>();
map.put(3, "zhangsan");
map.put(2,"wangyi");
map.put(7,"wangwu");
map.put(4, "zhangsansan");
for (Integer key:map.keySet()) {
String valueString=map.get(key);
System.out.println(key+"::"+valueString);
}
for(Map.Entry<Integer, String> me:map.entrySet())
{
Integer keyInteger=me.getKey();
String valString=me.getValue();
System.out.println(keyInteger+":"+valString);
}
}
}
输出结果：
abc1
abc2
abc3
2
3
3
4
3::zhangsan
2::wangyi
7::wangwu
4::zhangsansan
3:zhangsan
2:wangyi
7:wangwu
4:zhangsansan
package cn.itcast.p4.news.demo;
public class ParamterDemo {
/**
* @param args
*/
public static void main(String[] args) {
int sum = newAdd(5,1,4,7,3);
System.out.println("sum="+sum);
int sum1 = newAdd(5,1,2,7,3,9,8,7,6);
System.out.println("sum1="+sum1);
}
/*
* 函数的可变参数。
* 其实就是一个数组，但是接收的是数组的元素。
* 自动将这些元素封装成数组。简化了调用者的书写。
* 注意：可变参数类型，必须定义在参数列表的结尾。
*/
public static int newAdd(int a,int... arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum;
}
package cn.itcast.p4.news.demo;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static java.util.Collections.*;//静态导入，其实到入的是类中的静态成员。
import static java.lang.System.*;
public class StaticImportDemo {
/**
* @param args
*/
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abc3");
list.add("abc7");
list.add("abc1");
out.println(list);
sort(list);//静态导入之后，就不用写Collections
System.out.println(list);
String max = max(list);
System.out.println("max="+max);
}
}
输出结果：
[abc1, abc3, abc7]
max=abc7
package aaa;
import java.util.Properties;
import java.util.Set;
public class SystemDemo {
private static final String LINE_SEPARATOR = System
.getProperty("line.separator");// 获取换行符，不同的系统，换行符是不一样的。需要根据属性来获取，要不然可能出现不兼容的现象
public static void main(String[] args) {
// TODO Auto-generated method stub
demo_1();
demo_2();
}
private static void demo_2() {
/*
* System:类中的方法和属性都是静态的。
* 常见方法： long currentTimeMillis();获取当前时间的毫秒值。
*/
long l2 = System.currentTimeMillis();
System.out.println(l2);// 输出的结果是当前时间的毫秒值
System.out.println("hello-"+LINE_SEPARATOR+" world");//换行
}
/**
* 获取所有的属性
*/
private static void demo_1() {
// 获取系统的属性信息，并存储到了Properties集合中。
/*
* properties集合中存储都是String类型的键和值。 最好使用它自己的存储和取出的方法来完成元素的操作。
*/
Properties properties = System.getProperties();
Set<String> namSet = properties.stringPropertyNames();
for (String string : namSet) {
String valueString = properties.getProperty(string);
System.out.println(string + "::" + valueString);
}
}
}
在java中Runtime类表示运行时操作类，是一个封装了JVM进程的类，每一个JVM都对应着一个Runtime类的实例，此实例由JVM运行时为其实例化。所以在JDK文档中读者不会发现任何有关Runtime类中构造方法的定义，这是因为Runtime类本身的构造方法是私有化的（单例设计），如果想要得到一个Runtime实例，只有以下方法：
Runtime run=Runtime.getRuntime（）；
也就是说在Runtime类中提供了一个静态的getRuntime（）方法，此类可以取得Runtime类的实例，然后通过Runtime就可以取得一些系统的信息。如，getRuntime（），取得Runtime实例；freeMemory（）返回java虚拟机中的空闲内存量；maxMemory（）返回JVM的最大内存量；gc（）运行垃圾回收器，释放空间；exec（command）执行本机命令。
package aaa;
import java.io.IOException;
public class RuntimeDemo {
public static void main(String[] args) throws IOException,
InterruptedException {
// TODO Auto-generated method stub
Runtime runtime = Runtime.getRuntime();
Process p = runtime.exec("notepad.exe");
Thread.sleep(5000);
p.destroy();// 销毁进程
runtime.gc();// 垃圾回收
runtime.exec("notepad.exe c:\\RuntimeDemo.java");//用notepad.exe打开RuntimeDemo文件
}
}
package aaa;
import java.util.Random;
public class MathDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
* Math:提供了操作数学运算的方法。都是静态的。
* 常用的方法：
* ceil():返回大于参数的最小整数。
* floor():返回小于参数的最大整数。
* round():返回四舍五入的整数。
* pow(a,b):a的b次方。
*/
double d1 = Math.ceil(12.56);
double d2 = Math.floor(12.56);
double d3 = Math.round(12.46);
sop("d1="+d1);
sop("d2="+d2);
sop("d3="+d3);
double d = Math.pow(10, 2);
sop("d="+d);
//第一种 输出1到10 的随机数
for (int i = 0; i < 10; i++) {
double d4=(int)(Math.random()*10+1);
System.out.println(d4);
}
//第二种 输出1到10 的随机数
Random random=new Random();
for (int i = 0; i < 10; i++) {
double d5=(int)(random.nextDouble()*10+1);
System.out.println(d5);
int d6=random.nextInt(10)+1;
System.out.println(d6);
}
}
public static void sop(String string) {
System.out.println(string);
}
}
package aaa;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo {
public static void main(String[] args) throws ParseException {
// TODO Auto-generated method stub
demo_1();
demo_2();
demo_3();
}
/**
* 将日期格式的字符串-->日期对象。
* 使用的是DateFormat类中的parse()方法。
* @throws ParseException
*/
private static void demo_3() throws ParseException {
// TODO Auto-generated method stub
String str_Date = "2015年4月12日";
DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.LONG);
Date date = dateFormat.parse(str_Date);
System.out.println(date);
//自定义格式转换为日期对象
str_Date="2015---08--12";
dateFormat=new SimpleDateFormat("yyyy---MM--dd");
date=dateFormat.parse(str_Date);
System.out.println(date);
}
/**
* 对日期对象进行格式化。 将日期对象-->日期格式的字符串。 使用的是DateFormat类中的format方法。
*/
private static void demo_2() {
// TODO Auto-generated method stub
Date date = new Date();
DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.LONG);// 格式化日期
System.out.println(dateFormat.format(date));
dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG,
DateFormat.LONG);// 格式化日期和时间
System.out.println(dateFormat.format(date));
// 自定义风格
dateFormat = new SimpleDateFormat("yyyy--MM--dd");
String stringDate = dateFormat.format(date);
System.out.println(stringDate);
}
/**
* 日期对象和毫秒值之间的转换。
*
* 毫秒值-->日期对象 ： 1，通过Date对象的构造方法 new Date(timeMillis); 2，还可以通过setTime设置。
* 因为可以通过Date对象的方法对该日期中的各个字段(年月日等)进行操作。 日期对象-->毫秒值： 2，getTime方法。
* 因为可以通过具体的数值进行运算。
*/
private static void demo_1() {
Date date = new Date();// 将当前日期和时间封装成Date对象。
System.out.println(date);// Sun Apr 29 11:48:02 CST 2012
long time = System.currentTimeMillis();
Date date1 = new Date(time);
System.out.println(date1);
}
}
练习： "2012-3-17"到"2012-4-6"中间有多少天？
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
* 思路：两个日期相减就哦了。
* 咋减呢？必须要有两个可以进行减法运算的数。
* 能减可以是毫秒值。如何获取毫秒值？通过date对象。
* 如何获取date对象呢？可以将字符串转成date对象。
* 1,将日期格式的字符串转成Date对象。2,将Date对象转成毫秒值。3，相减，在变成天数
*/
public class DateTest {
public static void main(String[] args) throws ParseException {
String str_date1 = "2012-3-17";
String str_date2 = "2012-4-18";
test(str_date1,str_date2);
}
public static void test(String str_date1,String str_date2) throws ParseException {
DateFormat dateFormat = DateFormat.getDateInstance();//定义日期格式对象。
dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date1 = dateFormat.parse(str_date1); //1,将日期字符串转成日期对象。
Date date2 = dateFormat.parse(str_date2);
long time1 = date1.getTime();
long time2 = date2.getTime();
long time = Math.abs(time1-time2);
int day = getDay(time);
System.out.println(day);
}
private static int getDay(long time) {
int day = (int)(time/1000/60/60/24);
return day;
}
}
从JDK1.1版本开始，在处理日期和时间时，系统推荐使用Calendar类进行实现。在设计上，Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些，下面就介绍一下Calendar类的使用。
Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。
1、使用Calendar类代表当前时间
Calendar c = Calendar.getInstance();
由于Calendar类是抽象类，且Calendar类的构造方法是protected的，所以无法使用Calendar类的构造方法来创建对象，API中提供了getInstance方法用来创建对象。
使用该方法获得的Calendar对象就代表当前的系统时间，由于Calendar类toString实现的没有Date类那么直观，所以直接输出Calendar类的对象意义不大。
2、使用Calendar类代表指定的时间
Calendar c1 = Calendar.getInstance();
c1.set(2009, 3 - 1, 9);
使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。
set方法的声明为：
public final void set(int year,int month,int date)
以上示例代码设置的时间为2009年3月9日，其参数的结构和Date类不一样。Calendar类中年份的数值直接书写，月份的值为实际的月份值减1，日期的值就是实际的日期值。
如果只设定某个字段，例如日期的值，则可以使用如下set方法：
public void set(int field,int value)
在该方法中，参数field代表要设置的字段的类型，常见类型如下：
Calendar.YEAR——年份
Calendar.MONTH——月份
Calendar.DATE——日期
Calendar.DAY_OF_MONTH——日期，和上面的字段完全相同
Calendar.HOUR——12小时制的小时数
Calendar.HOUR_OF_DAY——24小时制的小时数
Calendar.MINUTE——分钟
Calendar.SECOND——秒
Calendar.DAY_OF_WEEK——星期几
后续的参数value代表，设置成的值。例如：
c1.set(Calendar.DATE,10);
该代码的作用是将c1对象代表的时间中日期设置为10号，其它所有的数值会被重新计算，例如星期几以及对应的相对时间数值等。
3、获得Calendar类中的信息
Calendar c2 = Calendar.getInstance();
int year = c2.get(Calendar.YEAR); //年份
int month = c2.get(Calendar.MONTH) + 1; //月份
int date = c2.get(Calendar.DATE); //日期
int hour = c2.get(Calendar.HOUR_OF_DAY); //小时
int minute = c2.get(Calendar.MINUTE); //分钟
int second = c2.get(Calendar.SECOND); //秒
int day = c2.get(Calendar.DAY_OF_WEEK); //星期几
System.out.println("年份：" + year);
System.out.println("月份：" + month);
System.out.println("日期：" + date);
System.out.println("小时：" + hour);
System.out.println("分钟：" + minute);
System.out.println("秒：" + second);
System.out.println("星期：" + day);
使用Calendar类中的get方法可以获得Calendar对象中对应的信息，get方法的声明如下：public int get(int field)
其中参数field代表需要获得的字段的值，字段说明和上面的set方法保持一致。需要说明的是，获得的月份为实际的月份值减1，获得的星期的值和Date类不一样。在Calendar类中，周日是1，周一是2，周二是3，依次类推。
4、其它方法说明
其实Calendar类中还提供了很多其它有用的方法，下面简单的介绍几个常见方法的使用。
a、add方法：public abstract void add(int field,int amount)
该方法的作用是在Calendar对象中的某个字段上增加或减少一定的数值，增加是amount的值为正，减少时amount的值为负。
例如在计算一下当前时间100天以后的日期，代码如下：
Calendar c3 = Calendar.getInstance();
c3.add(Calendar.DATE, 100);
int year1 = c3.get(Calendar.YEAR);
int month1 = c3.get(Calendar.MONTH) + 1; //月份
int date1 = c3.get(Calendar.DATE); //日期
System.out.println(year1 + "年" + month1 + "月" + date1 + "日");
这里add方法是指在c3对象的Calendar.DATE，也就是日期字段上增加100，类内部会重新计算该日期对象中其它各字段的值，从而获得100天以后的日期，例如程序的输出结果可能为： 2009年6月17日
b、after方法：public boolean after(Object when)
该方法的作用是判断当前日期对象是否在when对象的后面，如果在when对象的后面则返回true，否则返回false。例如：
Calendar c4 = Calendar.getInstance();
c4.set(2009, 10 - 1, 10);
Calendar c5 = Calendar.getInstance();
c5.set(2010, 10 - 1, 10);
boolean b = c5.after(c4);
System.out.println(b);
在该示例代码中对象c4代表的时间是2009年10月10号，对象c5代表的时间是2010年10月10号，则对象c5代表的日期在c4代表的日期之后，所以after方法的返回值是true。另外一个类似的方法是before，该方法是判断当前日期对象是否位于另外一个日期对象之前。
c、getTime方法：public final Date getTime()
该方法的作用是将Calendar类型的对象转换为对应的Date类对象，两者代表相同的时间点。
类似的方法是setTime，该方法的作用是将Date对象转换为对应的Calendar对象，该方法的声明如下：public final void setTime(Date date)
转换的示例代码如下：
Date d = new Date();
Calendar c6 = Calendar.getInstance();
Date d1 = c6.getTime(); //Calendar类型的对象转换为Date对象
Calendar c7 = Calendar.getInstance();
c7.setTime(d); //Date类型的对象转换为Calendar对象
5、Calendar对象和相对时间之间的互转
Calendar c8 = Calendar.getInstance();
long t = 1252785271098L;
long t1 = c8.getTimeInMillis(); //将Calendar对象转换为相对时间
Calendar c9 = Calendar.getInstance();
c9.setTimeInMillis(t1); //将相对时间转换为Calendar对象
在转换时，使用Calendar类中的getTimeInMillis方法可以将Calendar对象转换为相对时间。在将相对时间转换为Calendar对象时，首先创建一个Calendar对象，然后再使用Calendar类的setTimeInMillis方法设置时间即可。
应用示例
下面以两个简单的示例介绍时间和日期处理的基本使用。
1、计算两个日期之间相差的天数
例如计算2010年4月1号和2009年3月11号之间相差的天数，则可以使用时间和日期处理进行计算。
该程序实现的原理为：首先代表两个特定的时间点，这里使用Calendar的对象进行代表，然后将两个时间点转换为对应的相对时间，求两个时间点相对时间的差值，然后除以1天的毫秒数(24小时X60分钟X60秒X1000毫秒)即可获得对应的天数。实现该示例的完整代码如下：
import java.util.*;
/**
* 计算两个日期之间相差的天数
*/
public class DateExample1 {
public static void main(String[] args) {
//设置两个日期
Calendar c1 = Calendar.getInstance();
c1.set(2009, 3 - 1, 11); //日期：2009年3月11号
Calendar c2 = Calendar.getInstance();
c2.set(2010, 4 - 1, 1); //日期：2010年4月1号
//转换为相对时间
long t1 = c1.getTimeInMillis();
long t2 = c2.getTimeInMillis();
long days = (t2 - t1)/(24 * 60 * 60 * 1000); //计算天数
System.out.println(days);
}
}
2、输出当前月的月历
该示例的功能是输出当前系统时间所在月的日历，例如当前系统时间是2009年3月10日，则输出2009年3月的日历。
该程序实现的原理为：首先获得该月1号是星期几，然后获得该月的天数，最后使用流程控制实现按照日历的格式进行输出即可。即如果1号是星期一，则打印一个单位的空格，如果1号是星期二，则打印两个单位的空格，依次类推。打印完星期六的日期以后，进行换行。实现该示例的完整代码如下：
public class DateExample2{
public static void main(String[] args){
//获得当前时间
Calendar c = Calendar.getInstance();
c.set(Calendar.DATE,1); //设置代表的日期为1号
int start = c.get(Calendar.DAY_OF_WEEK); //获得1号是星期几
int maxDay = c.getActualMaximum(Calendar.DATE); //获得当前月的最大日期数
//输出标题
System.out.println("星期日 星期一 星期二 星期三 星期四 星期五 星期六");
//输出开始的空格
for(int i = 1;i < start;i++){
System.out.print(" ");
}
//输出该月中的所有日期
for(int i = 1;i <= maxDay;i++){
System.out.print(" " + i); //输出日期数字
System.out.print(" "); //输出分隔空格
if(i < 10){System.out.print(' ');}
//判断是否换行
if((start + i - 1) % 7 == 0){ System.out.println(); }
}
System.out.println(); //换行
}
}
package cn.itcast.p1.otherapi;
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
int year = 2012;
showDays(year);
}
//求二月份有多少天，思路：三月份第一天减一得到二月最后一天的天数
public static void showDays(int year) {
Calendar c = Calendar.getInstance();
c.set(year, 2, 1);
c.add(Calendar.DAY_OF_MONTH, -1);
showDate(c);
}
//获取Calendar对象的时间属性
public static void showDate(Calendar c) {
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH)+1;
int day = c.get(Calendar.DAY_OF_MONTH);
int week = c.get(Calendar.DAY_OF_WEEK);
System.out.println(year+"年"+month+"月"+day+"日"+getWeek(week));
}
public static String getWeek(int i) {
String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
return weeks[i];
}
}
