在实际的项目开发中，经常借助于一些类来帮助完成特定的功能，例如进行数学运算、字符串运算、日期运算等等，这些类由Sun公司提供，放在Java 2 Platform软件包内，不需要用户再次编写而直接使用，我们称这些类叫“Java工具类”，这里将会学习这些工具类的部分内容，在将来的项目中我们就可以通过它们的帮助，来完成很多特定的任务，达到快速开发的目的。所有这些类的详细信息均可以通过查询API规范获得。
1 概述
在基础库部分，Sun公司提供了极其丰富的功能类，为了便于区分，根据类的功能大致把这些类放在了不同的包内，例如java.lang包、java.util包、java.io包、java.sql包、java.text包等等。这里主要讲解java.lang包及java.text包中的部分类，对于其他的三个包，将会在后续单独讲解。
对于初学者来说，最为常用的工具类有封装类、String、StringBuffer、Random、Date、Calendar、SimpleDateFormat及Math静态类等等；但是，Java学习之路漫长也曲折，Sun公司提供的支持类成千上万，很难一次掌握，即便是本章内容，也拥有众多类和方法的介绍，在后续的学习、工作过程中，也会遇到自己不会甚至没有见过的新类，你会发现，这众多的类和方法之间，其实充满了联系与区别，是有规律可循的，类的名字、方法的名字，也非常便于记忆。只要各位从容面对，勤加练习，善于归纳总结，多多翻阅JDK API帮助文档，那么学好这部分内容是不困难的。
2包装类
我们知道，java中的基本数据类型是在堆栈上创建的，而所有的对象类型都是在堆上创建的（对象的引用在堆栈上创建）。比如String s=new String(“good luck!”); 其中new String()是在堆上创建的，而它的引用String s是在堆栈上。
很显然，栈内存上的数据比堆内存上的数据速度要快很多，不过，虽然在堆栈上分配内存效率高，不过在堆栈上分配内存有内存泄露的问题，而这并不是任意一个程序员都能解决的问题。并且，对于基本数据类型来说，早在一学期我们就知道它是按值传递的。所以，如果各位想把一个基本数据类型的数据按引用传递，那么是办不到的。包装类（Wrapper Class）的出现，正是为了解决这个问题，包装类把基本数据类型的数据封装为引用类型的对象，而且提供了很多有用的方法。
对于Java的基本数据类型，Sun公司均提供了对应的包装类，如下表所示，各位可以通过查阅API文档来获得这些包装类的详细信息。值得注意的是，所有的包装类均位于java.lang包下，而这个包会由JVM编译器在编译时自动导入我们的程序，所以可以不用手工导入该包下的类而直接使用。
| 基本数据类型 | 对应包装类 |
| boolean | Boolean |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| float | Float |
| double | Double |
大多包装类均具有如下方法：
·带有基本值参数并创建包装类对象的构造方法，如可以利用Integer包装类创建对象，Integer obj=new Integer(145) 1aD>Zn
·带有字符串参数并创建包装类对象的构造方法，如new Integer("-45.36") A =:(IcM#
d9G{S9X
·生成字符串表示法的toString()方法，如obj.toString()
·:%^D,MGi ·· 对同一个类的两个对象进行比较的equals()方法，如obj1.eauqls(obj2) 6=Hxw$6u0U
·生成哈稀表代码的hashCode方法，如obj.hasCode() w_+c$E i+b ?Zt
·将字符串转换为基本值的 parseType方法，如Integer.parseInt(args[0]) (i' a 4
·可生成对象基本值的typeValue方法，如obj.intValue()
下以int基本类型的包装类Integer和Character为例，带领各位了解包装类。
6 dp[/F1 3 Integer整数类
Integer是int基本类型的包装类，下面我们一起来看看Integer类有哪些特点，从介绍封装类的属性、构造器和方法展开。
3.1 属性
| 属性名称 | 描述 |
| static int MAX_VALUE | 返回最大的整型数 |
| static int MIN_VALUE | 返回最小的整型数 |
| static Class TYPE | 返回当前类型 |
示例：
| System.out.println("Integer.MAX_VALUE:"+Integer.MAX_VALUE); |
3.2 构造方法
| 构造器 | 描述 |
| Integer(int value) | 通过一个int的类型构造对象 |
| Integer(String s) | 通过一个String的类型构造对象 |
注：本书对类的构造方法、方法的列表如无特殊说明，均指public方法。
示例：
| //生成了一个值为1234的Integer对象 Integer i = new Integer(1234); Integer i = new Integer("1234"); |
3.3 方法介绍
说明：
1. 所有方法均为public
2. 书写格式：［修饰符］ <返回类型> <方法名（［参数列表］）>
| 方法名称 | 描述 |
| byteValue() | 取得用byte类型表示的整数 |
| int compareTo(Integer anotherInteger) | 比较两个整数。相等时返回０；小于时返回负数；大于时返回正数 |
| int compareTo(Object o) | 将该整数与其他类进行比较。其中o必须为Integer类实例，否则，抛出ClassCastException异常 |
| static Integer decode(String nm) | 将字符串转换为整数 |
| double doubleValue() | 取得该整数的双精度表示 |
| boolean equals(Object obj) | 比较两个对象 |
| float floatValue() | 取得该整数的浮点数表示 |
| static Integer getInteger(String nm) | 根据指定名确定系统特征值 |
| int hashCode() | 返回该整数类型的哈希表码 |
| int intValue() | 返回该整型数所表示的整数 |
| long longValue() | 返回该整型数所表示的长整数 |
| static int parseInt(String s) | 将字符串转换成整数。 s必须是十进制数组成，否则抛出NumberFormatException异常 |
| static int parseInt(String s, int radix) | 以radix为基数radix返回s的十进制数。所谓的基数，就是“几进制” |
| short shortValue() | 返回该整型数所表示的短整数 |
| static String toBinaryString(int i) | 将整数转为二进制数的字符串 |
| static String toHexString(int i) | 将整数转为十六进制数的字符串 |
| static String toOctalString(int i) | 将整数转为八进制数的字符串 |
| String toString() | 将该整数类型转换为字符串 |
| static String toString(int i) | 将该整数类型转换为字符串。不同的是，此为类方法 |
| static String toString(int i, int radix) | 将整数i以基数radix的形式转换成字符串 |
| static Integer valueOf(String s) | 将字符串转换成整数类型 |
| static Integer valueOf(String s, int radix) | 将字符串以基数radix的要求转换成整数类型 |
以下示例使用了compareTo方法对两个Integer对象进行大小比较，比较的内容为Integer对象对应的int值，根据大小相等的不同，返回结果分别为大于、小于、等于0的数字：
| Integer i = new Integer(1234); System.out.println("i.compareTo: " + i.compareTo(new Integer(123))); //输出结果为：i.compareTo: 1 |
以下示例返回一个整数的16进制形式字符串：
| int i = 54321; System.out.println("Integer.toString(int i, int radix): " + Integer.toString(i,16)); //结果为：Integer.toString(int i, int radix): d431 |
4 Character字符类
Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。
4.1 属性
| 属性名称 | 属性描述 |
| static char MIN_VALUE | 此字段的常量值是 char 类型的最小值，即 '\u0000' |
| static char MAX_VALUE | 此字段的常量值是 char 类型的最大值，即 '\uFFFF' |
| static Class TYPE | 表示基本类型 char 的 Class 实例 |
4.2 构造方法
Character(char value)：以char参数构造一个Character对象
4.3 方法
说明：
1. 所有方法均为public；
2. 书写格式：［修饰符］<返回类型> <方法名（［参数列表］）>
具体方法请查看API文档
示例：
| package com.lesson4; /** * Character包装类的用法 */ public class CharacterDemo { public static void main(String[] args) { Character ch1 = new Character('a'); Character ch2 = new Character('A'); // ch1的char值 System.out.println("char value of ch1 : " + ch1.charValue()); // 对比ch1和ch2的大小 System.out.println("ch1 compare to ch2 : " + ch1.compareTo(ch2)); // 表示范围的最小值 System.out.println("min value(int) : " + (int) Character.MIN_VALUE); // 表示范围的最大值 System.out.println("max value(int) : " + (int) Character.MAX_VALUE);
// 判断一个字符是否是数字形式 System.out.println("is digit '1' : " + Character.isDigit('1')); // 判断一个字符是否是大写形式 System.out.println("is upper case 'a' : " + Character.isUpperCase('a')); // 判断一个字符是否是空格 System.out.println("is space char ' ' : " + Character.isSpaceChar(' ')); // 判断一个字符是否是字母 System.out.println("is letter '1' ：" + Character.isLetter('1')); // 判断一个字符是否是字母或数字 System.out.println("is letter or digit '好' ：" + Character.isLetterOrDigit('好')); // 把字母转化为大写形式 System.out.println("to upper case 'a' ：" + Character.toUpperCase('a')); } } |
5 String字符串类
字符串大量用于我们的程序中，Java提供了String类专门用于表示字符串，内有大量实用的方法，大家要牢牢掌握。
5.1 构造方法
| 构造器 | 描述 |
| String() | 构造一个空字符串对象 |
| String(byte[] bytes) | 通过byte数组构造字符串对象 |
| String(char[] chars) | 通过字符数组构造字符串对象 |
| String(String original) | 构造一个original的副本，即拷贝一个original |
| String(StringBuffer buffer) | 通过StringBuffer数组构造字符串对象 |
示例演示String类构造方法的使用：
| byte[] b = {'a','b','c','d','e','f','g','h','i','j'}; char[] c = {'0','1','2','3','4','5','6','7','8','9'}; String sb = new String(b); String sb_sub = new String(b,3,2); String sc = new String(c); String sc_sub = new String(c,3,2); String sb_copy = new String(sb); System.out.println("sb: " + sb ); System.out.println("sb_sub: " + sb_sub ); System.out.println("sc: " + sc ); System.out.println("sc_sub: " + sc_sub ); System.out.println("sb_copy: " + sb_copy ); 输出结果为： sb: abcdefghij sb_sub: de sc: 0123456789 sc_sub: 34 sb_copy: abcdefghij |
5.2 方法
示例
| String s = new String("abcdefghijklmnopqrstuvwxyz"); System.out.println("s.charAt(5): " + s.charAt(5) ); 本例从字符串中提取字符，运行结果为：s.charAt(5): f |
示例：
| String s1 = new String("abcdefghijklmn"); String s2 = new String("abcdefghij"); String s3 = new String("abcdefghijalmn"); System.out.println("s1.compareTo(s2): " + s1.compareTo(s2) ); System.out.println("s1.compareTo(s3): " + s1.compareTo(s3) ); 本例对两个字符串进行对比，运行结果为： s1.compareTo(s2): 4 s1.compareTo(s3): 10 |
示例：
| String s1 = new String("abcdefghij"); String s2 = new String("ghij"); System.out.println("s1.endsWith(s2): " + s1.endsWith(s2) ); 本例判断一个字符串是否是另外一个字符串的结尾，运行结果为：s1.endsWith(s2): true |
示例：
| char[] s1 = {'I',' ','l','o','v','e',' ','h','e','r','!'}; String s2 = new String("you!"); s2.getChars(0,3,s1,7); //s1=I love you! System.out.println( s1 ); 运行结果为：I love you! |
示例：
| String s = new String("write once, run anywhere!"); String ss = new String("run"); System.out.println("s.indexOf('r'): " + s.indexOf('r') ); System.out.println("s.indexOf('r',2): " + s.indexOf('r',2) ); System.out.println("s.indexOf(ss): " + s.indexOf(ss) ); 本例在一个字符串中查找某段字符串的位置，注意indexOf方法的不同形式，运行结果为： s.indexOf('r'): 1 s.indexOf('r',2): 12 s.indexOf(ss): 12 |
示例：
| String s = new String ("write once, run anywhere!"); String ss = new String("write"); String sss = new String("once"); System.out.println("s.startsWith(ss): " + s.startsWith(ss) ); System.out.println("s.startsWith(sss,6): " + s.startsWith(sss,6) ); 本例判断一个字符串是否是另外一个字符串的开始，运行结果为： s.startsWith(ss): true s.startsWith(sss,6): true |
示例：
| String s = new String("java.lang.Class String"); System.out.println("s.toUpperCase(): " + s.toUpperCase() ); System.out.println("s.toLowerCase(): " + s.toLowerCase() ); 本例把一个字符串转换为对应的大写、小写形式，运行结果为： s.toUpperCase(): JAVA.LANG.CLASS STRING s.toLowerCase(): java.lang.class string |
字符串与字符数组关系密切，而且它们可以互相转换，通过String构造方法可以将一个字符数组构造为一个字符串，而通过String类的toCharArray()方法也可以将一个字符串转换为字符数组。其实，通过查看String类的源代码可以知道（多看源码长见识），String类的本质就是由字符数组构建的，String类的第一行就定义到：
| /** The value is used for character storage. */ private final char value[]; |
这个值数组是private final类型的，这也说明一个问题，那就是一旦这个数组被赋值，那么它就不能再被修改了，到底是不是这样呢？请看下一节。
5.3 字符串的不变性
首先来看一个示例，示例中使用String类的concat()方法，试图将第二个字符串连接在第一个字符串的后面，使用replace()方法，试图将字符串中的某些字符替换掉。
示例：
| package com.lesson4; /** * String类的字符串不变性 */ public class StringDemo { public static void main(String[] args) { String s1 = new String("hello "); //将svse连接在s1的后面 s1.concat("abc"); System.out.println("s1 = " + s1); // 使用replace方法把字符串s2中的字符o替换为u String s2 = new String("good morning!"); s2.replace('o', 'u'); System.out.println("s2 = " + s2); } } |
运行程序，查看结果如下：
可以看到字符串s1、s2虽然尝试进行了修改，但是，它们并没有发生任何变化，这是为什么呢？其实，一个字符串对象一但创建，那么这个字符串对象内容存放地址里面的内容就不能改变，对于s1来说，我们尝试在其后连接上abc，因不能对s1进行直接修改，所以将会创建一个新的字符串对象，而新创建的对象的引用，我们并未将其赋给s1，结果导致s1的值没有变化。对于s2来说，也是一样的道理。
那么如何解决这个问题呢？很简单，把新的字符串的引用，赋给s1、s3即可。
| //其余部分省略 s1 = s1.concat("abc"); s2 = s2.replace('o', 'u'); |
由于在对String字符串进行修改的过程中，将会创建新的字符串对象，如果因为需要而反复修改字符串，将大大浪费系统资源，创建一大堆无用的对象。为了避免这种情况出现，我们需要能直接修改的字符串对象，这就是StringBuffer。
6 StringBuffer字符串缓冲类
在实际应用中，经常会遇到对字符串进行动态修改。这时候，String类的功能受到限制，而StringBuffer类可以完成字符串的动态添加、插入和替换等操作（注意有些中文API上说的是“不能修改”，是误译，英文原版为“can be modified”），对StringBuffer的修改，是直接的，不会创建多余的对象。
4.6.1 构造方法
| 构造器名称 | 描述 |
| StringBuffer() | 构造一个没有任何字符的StringBuffer类 |
| StringBuffer(int length) | 构造一个没有任何字符的StringBuffer类，并且，其长度为length |
| StringBuffer(String str) | 以str为初始值构造一个StringBuffer类 |
6.2 方法
以下示例演示了对StringBuffer对象进行字符串追加和插入操作。StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
| package com.lesson4;
/** * StringBuffer，带有缓冲区的字符串 */ public class StringBufferDemo { public static void main(String[] args) { String question = new String("1+1="); int answer = 3; boolean result = (1 + 1 == 3); StringBuffer sb = new StringBuffer(); sb.append(question); sb.append(answer); sb.append(result); sb.insert(5, ','); System.out.println(sb); } } 结果为： 1+1=3,false |
以下示例调整了StringBuffer的容量，这将会给StringBuffer对象分配更多的空间。其实，如果容量不够，那么编译器将会自动分配更高的容量。
| package com.lesson4; /** * 调整StringBuffer对象的容量 */ public class StringBufferDemo { public static void main(String[] args) { StringBuffer sb1 = new StringBuffer(5); StringBuffer sb2 = new StringBuffer(5); sb1.ensureCapacity(6); sb2.ensureCapacity(100); System.out.println( "sb1.Capacity: " + sb1.capacity() ); System.out.println( "sb2.Capacity: " + sb2.capacity() ); } } 结果为： sb1.Capacity: 12 sb2.Capacity: 100 |
以下示例演示了将字符数组复制到字符串:
| package com.lesson4; /** *把字符数组放入StringBuffer */ public class StringBufferDemo { public static void main(String[] args) { StringBuffer sb = new StringBuffer("I love her!"); char[] i = {'I',' ','l','o','v','e',' ','y','o','u'}; sb.getChars(7,10,i,7); System.out.println( "sb: " + sb ); } } 结果为：sb: I love her! |
以下示例对字符串进行反转:
| package com.svse.lesson4; /** * 反转字符串 */ public class StringBufferDemo { public static void main(String[] args) { StringBuffer sb = new StringBuffer("0123456789"); System.out.println( "sb.reverse(): " + sb.reverse() ); } } 结果为：sb.reverse(): 9876543210 |
以下示例设置字符序列的长度。序列将被更改为一个新的字符序列，新序列的长度由参数指定。
| package com.lesson4; /** * 截断字符串 */ public class StringBufferDemo { public static void main(String[] args) { StringBuffer sb = new StringBuffer("0123456789"); sb.setLength(5); System.out.println( "sb: " + sb ); } } 结果为：sb: 01234 |
7 Random随机类
此类用来产生随机数，位于java.util包中，所以需要手工导包。
7.1 构造方法
| 构造器 | 描述 |
| Random() | 创建一个新的随机数发生器 |
| Random(long seed) | 用一个种子（长整型）创建一个随机数发生器 |
7.2 方法
说明：
1. 所有方法均为public；
2. 书写格式：［修饰符］<返回类型> <方法名（［参数列表］）>
请注意nextInt(int n)的取值范围及其和nextInt()方法的区别。
7.3 关于Random类的说明
Random这个类的对象使用一个48位的种子，如果这个类的两个实例是用同一个种子创建的，并且，各自对它们以同样的顺序调用方法，则它们会产生相同的数字序列。
下面就对上面的介绍做一个演示，尤其注意相同种子时的结果，如果用默认的构造函数构造对象，它们是属于同一个种子的；演示代码如下所示：
示例
| package com.lesson4;
import java.util.Random; /** * 根据随机种子获得随机序列 */ public class RandomDemo { public static void main(String[] args) { Random r1 = new Random(50); System.out.println("第一个种子为50的Random对象"); System.out.println("r1.nextBoolean():\t" + r1.nextBoolean()); System.out.println("r1.nextInt():\t\t" + r1.nextInt()); System.out.println("r1.nextDouble():\t" + r1.nextDouble()); System.out.println("r1.nextGaussian():\t" + r1.nextGaussian()); System.out.println("---------------------------"); Random r2 = new Random(50); System.out.println("第二个种子为50的Random对象"); System.out.println("r2.nextBoolean():\t" + r2.nextBoolean()); System.out.println("r2.nextInt():\t\t" + r2.nextInt()); System.out.println("r2.nextDouble():\t" + r2.nextDouble()); System.out.println("r2.nextGaussian():\t" + r2.nextGaussian()); System.out.println("---------------------------"); Random r3 = new Random(100); System.out.println("种子为100的Random对象"); System.out.println("r3.nextBoolean():\t" + r3.nextBoolean()); System.out.println("r3.nextInt():\t\t" + r3.nextInt()); System.out.println("r3.nextDouble():\t" + r3.nextDouble()); System.out.println("r3.nextGaussian():\t" + r3.nextGaussian()); System.out.println("结果一目了然！"); } } 结果： 第一个种子为50的Random对象 r1.nextBoolean(): true r1.nextInt(): -1727040520 r1.nextDouble(): 0.6141579720626675 r1.nextGaussian(): 2.377650302287946 --------------------------- 第二个种子为50的Random对象 r2.nextBoolean(): true r2.nextInt(): -1727040520 r2.nextDouble(): 0.6141579720626675 r2.nextGaussian(): 2.377650302287946 --------------------------- 种子为100的Random对象 r3.nextBoolean(): true r3.nextInt(): -1139614796 r3.nextDouble(): 0.19497605734770518 r3.nextGaussian(): 0.6762208162903859 |
8 Date时间类
Java在日期类中封装了有关日期和时间的信息，类 Date 表示特定的瞬间，精确到毫秒。用户可以通过调用相应的方法来获取系统时间或设置日期和时间。
8.1 构造方法
| 构造器名称 | 描述 |
| Date() | 创建的日期类对象的日期时间被设置成创建时刻相对应的日期时间 |
| Date(long date) | long型的参数date可以通过调用Date类中的static方法parse(Strings)来获得 |
8.2 方法
| package com.svse.lesson4;
import java.util.Date;
/** * Date类的基本用法 * @author svse * */ public class DateDemo { public static void main(String[] args) { Date date1 = new Date(); Date date2 = new Date(1233997578421L); //输出date1、date2对象所对应的毫秒数 System.out.println(date1.getTime()); System.out.println(date2.getTime()); //查看date1是否在date2后 boolean isAfter = date1.after(date2); System.out.println("is date1 after date2："+isAfter); date1.setTime(1133997578421L); isAfter = date1.after(date2); System.out.println("is date1 after date2："+isAfter); } } |
运行结果如下：
Date类的方法
9 Calendar日历类
在历史上有着许多种纪元的方法，它们的差异实在太大了，不同的开发商也会开发出不同的日历计算方式。比如说一个人的生日是“八月八日” 那么一种可能是阳（公）历的八月八日，但也可以是阴（农）历的日期。所以为了计时的统一，必需指定一个日历的选择。那现在最为普及和通用的日历就是 “Gregorian Calendar”——格里高利历。也就是我们在讲述年份时常用 “公元几几年”。Calendar 抽象类定义了足够的方法，让我们能够表述Gregorian Calendar的规则。它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。
注意，由于Calendar类是一个抽象类，所以不能直接通过new关键字创建Calendar类的实例，可以借助于该类提供的静态方法getInstance()来获得一个Calendar对象。正像Date类的默认构造方法一样，该对象所代表的日期正是当前系统日期：
Calendar rightNow = Calendar.getInstance();
Calendar抽象类有一个具体子类：GregorianCalendar。
9.1 字段
| 字段名称 | 描述 |
| static int AM | 指示从午夜到中午之前这段时间的 AM_PM 字段值。 |
| static int AM_PM | get 和 set 的字段数字，指示 HOUR 是在中午之前还是在中午之后。 |
| static int DATE | get 和 set 的字段数字，指示一个月中的某天。 |
| static int DAY_OF_MONTH | get 和 set 的字段数字，指示一个月中的某天。 |
| static int DAY_OF_WEEK | get 和 set 的字段数字，指示一个星期中的某天。 |
| static int DAY_OF_WEEK_IN_MONTH | get 和 set 的字段数字，指示当前月中的第几个星期。 |
| static int AY_OF_YEAR | get 和 set 的字段数字，指示当前年中的天数。 |
| static int HOUR | get 和 set 的字段数字，指示上午或下午的小时。 |
| static int HOUR_OF_DAY | get 和 set 的字段数字，指示一天中的小时。 |
| static int MILLISECOND | get 和 set 的字段数字，指示一秒中的毫秒。 |
| static int MINUTE | get 和 set 的字段数字，指示一小时中的分钟。 |
| static int MONTH | 指示月份的 get 和 set 的字段数字。 |
| static int PM | 指示从中午到午夜之前这段时间的 AM_PM 字段值。 |
| static int SECOND | get 和 set 的字段数字，指示一分钟中的秒。 |
| protected long time | 日历的当前设置时间，以毫秒为单位，表示自格林威治标准时间 1970 年 1月 1 日 0:00:00 后经过的时间。 |
| static int WEEK_OF_MONTH | get 和 set 的字段数字，指示当前月中的星期数。 |
| static int WEEK_OF_YEAR | get 和 set 的字段数字，指示当前年中的星期数。 |
| static int YEAR | 指示年的 get 和 set 的字段数字。 |
9.2 方法
请各位观察API中Calendar类常见的字段和方法，可以发现，这些方法，有的是抽象的，有的是最终方法（final），还有的是静态方法，这体现了程序设计的严谨性：在不同的环境下，不同的需求将导致不同的方法设计。
可能有同学会想不通，该类是一个抽象类，其中有一个抽象方法add()，那么add()方法能不能使用呢？我们慢慢来分析，由于Calendar类是抽象类，我们在获得Calendar实例时，使用的是getInstance()方法，其实，该方法返回的是Calendar类的子类对象，该子类为GregorianCalendar，也就是说，“Calendar ca = Calendar.getInstance()”其实是让ca引用了子类GregorianCalendar的对象，相当于Calendar ca = new GregorianCalendar()，这在语法上是允许的，并且前面的课程中也做过相应介绍。对于GregorianCalendar类来说，其内部实现了抽象的add()方法，所以，我们如果让ca调用add()方法，事实上是调用了GregorianCalendar类的add()方法，是没有任何问题的。
示例：
| package com.lesson4;
import java.util.Calendar; import java.util.Date;
/** * Calendar类的常见方法 */ public class CalendarDemo { public static void main(String[] args) { //创建Calendar实例 Calendar ca = Calendar.getInstance(); //获得ca所包含的年份。注意写法 System.out.println("year is :"+ca.get(Calendar.YEAR)); //为年份增加2 ca.add(Calendar.YEAR, 2); System.out.println("year is :"+ca.get(Calendar.YEAR)); //设置ca的年份 ca.set(Calendar.YEAR,2009); System.out.println("year is :"+ca.get(Calendar.YEAR)); //今天是今年的第几天 System.out.println("day of year:"+ca.get(Calendar.DAY_OF_YEAR)); //今天是本周的第几天，注意默认情况下周日是第一天 System.out.println("day of week : "+ca.get(Calendar.DAY_OF_WEEK)); //获得对应的Date对象 Date date = ca.getTime(); System.out.println("date time : "+date.getTime()); System.out.println("calendar time : "+ca.getTimeInMillis()); } }
|
执行程序，运行结果如下：
10 SimpleDateFormat日历格式化
SimpleDateFormat类可以对Date及字符串进行分析，并在它们之间相互转换，它允许格式化 (date -> text)、语法分析 (text -> date)和标准化。它的继承关系如下：
java.lang.Object
+----java.text.Format
+----java.text.DateFormat
+----java.text.SimpleDateFormat
示例演示了该类在JavaBean内提供日期时间服务的通常用法：
| package com.lesson4;
import java.text.SimpleDateFormat; import java.util.Date; /** * SimpleDateFormat对日期和时间进行格式化 */ public class FormatDateTime { /** 长日期格式*/ public static String toLongDateString(Date dt) { SimpleDateFormat myFmt = new SimpleDateFormat( "yyyy年MM月dd日 HH时mm分ss秒 E "); return myFmt.format(dt); } /** 短日期格式*/ public static String toShortDateString(Date dt) { SimpleDateFormat myFmt = new SimpleDateFormat("yy年MM月dd日 HH时mm分"); return myFmt.format(dt); } /** 长时间格式*/ public static String toLongTimeString(Date dt) { SimpleDateFormat myFmt = new SimpleDateFormat("HH mm ss SSSS"); return myFmt.format(dt); } /**短时间格式*/ public static String toShortTimeString(Date dt) { SimpleDateFormat myFmt = new SimpleDateFormat("yy/MM/dd HH:mm"); return myFmt.format(dt); } /**main方法进行测试*/ public static void main(String[] args) { Date now = new Date(); System.out.println(FormatDateTime.toLongDateString(now)); System.out.println(FormatDateTime.toShortDateString(now)); System.out.println(FormatDateTime.toLongTimeString(now)); System.out.println(FormatDateTime.toShortTimeString(now)); } } |
运行效果如下：
4.11 Math算术运算类
Math类中的静态方法帮助我们完成基本的数学运算，它的定义形式为：
public final class Math extends Object
可以看出，Math类是一个最终类，也就是说，它不能被继承，更不能被重写，Sun公司的牛人们不乐意看到它被别人改动，Math类中的方法全部为静态方法，直接使用就行。
示例：
| package com.lesson4;
/** * Math类的用法 */ public class MathDemo { public static void main(String[] args) { // 绝对值 System.out.println("abs of -1 : " + Math.abs(-1)); // 比这个数大的最小整数 System.out.println("ceil of 9.01 : " + Math.ceil(9.01)); // 比这个数小的最大整数 System.out.println("floor of 9.99 :" + Math.floor(9.99)); // 取较大者 System.out.println("the max is : " + Math.max(101, 276.001)); // 随机数，区间为[0.0,1.0) System.out.println("random number : " + Math.random()); // 四舍五入 System.out.println("round value of 9.49 ：" + Math.round(9.49)); // 返回正确舍入的 double 值的正平方根 System.out.println("square root of 225 : " + Math.sqrt(225)); } }
|
运行后结果如下：
8084
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
