比較器
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;
}
}
import java.util.ArrayList;
import java.util.Collections;
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");
Collections.shuffle(list);//使用指定的随機源對指定清單進行置換。
Collections.fill(list, "cc");//将list中的所有元素替換沖cc,此方法用做集合的初始化
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.add("aa");
list.add("zzz");
list.add("nbaa");
Collections.sort(list);
mySort(list);// Collections.sort(list)實作原理
Collections.sort(list, new ComparatorByLength());
mySort(list, new ComparatorByLength());
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) {
if (list.get(i).compareTo(list.get(j)) > 0) {
Collections.swap(list, i, j);// 交換位置
public static void demo_2() {
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)：");
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)：");
//比較數組元素是否相等
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));
//使用二分搜尋算法查找指定元素所在的下标（必須是排序好的，否則結果不正确）
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集合
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]
集合轉成數組
public class ToArray {
* 集合轉成數組呢？
* 使用的就是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。
import java.util.LinkedHashMap;
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
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
*/
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;
import static java.util.Collections.*;//靜态導入，其實到入的是類中的靜态成員。
import static java.lang.System.*;
public class StaticImportDemo {
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
import java.util.Properties;
import java.util.Set;
public class SystemDemo {
private static final String LINE_SEPARATOR = System
.getProperty("line.separator");// 擷取換行符，不同的系統，換行符是不一樣的。需要根據屬性來擷取，要不然可能出現不相容的現象
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）執行本機指令。
import java.io.IOException;
public class RuntimeDemo {
public static void main(String[] args) throws IOException,
InterruptedException {
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檔案
import java.util.Random;
public class MathDemo {
// 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();
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);
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 {
* 将日期格式的字元串-->日期對象。
* 使用的是DateFormat類中的parse()方法。
* @throws ParseException
private static void demo_3() throws ParseException {
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);
* 對日期對象進行格式化。 将日期對象-->日期格式的字元串。 使用的是DateFormat類中的format方法。
Date date = new Date();
DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.LONG);// 格式化日期
System.out.println(dateFormat.format(date));
dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG,
DateFormat.LONG);// 格式化日期和時間
// 自定義風格
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方法。
* 因為可以通過具體的數值進行運算。
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"中間有多少天？
/*
* 思路：兩個日期相減就哦了。
* 咋減呢？必須要有兩個可以進行減法運算的數。
* 能減可以是毫秒值。如何擷取毫秒值？通過date對象。
* 如何擷取date對象呢？可以将字元串轉成date對象。
* 1,将日期格式的字元串轉成Date對象。2,将Date對象轉成毫秒值。3，相減，在變成天數
*/
public class DateTest {
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 {
//設定兩個日期
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){
//獲得目前時間
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 {
Calendar c = Calendar.getInstance();
int year = 2012;
showDays(year);
//求二月份有多少天，思路：三月份第一天減一得到二月最後一天的天數
public static void showDays(int year) {
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小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)