Java-Collections總結（java中Collections）
比較器
package aaa;
import java.util.Comparator;
public class ComparatorByLength implements Comparator
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
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
@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
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
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
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
*??????????? T>的意思是，所有實現Comparable的接口的類型或者父類實現Comparable接口的類型
*/
public static
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
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?
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
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
System.out.println(list);//輸出結果：[12, 32, 434, 55, 67, 87]
int[] arr={31,11,51,61};
List
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
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
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
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 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
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
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];
}
}
Java 數據結構
版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。
相關文章
