第六章 常见类的使用
学习目标：
2 理解和掌握 Object 类
2 理解和掌握 String 类
2 理解和掌握正则表达式基础知识
2 理解和掌握 StringBuffer 类
2 理解和掌握 StringBuilder 类
2 掌握 Math 类的使用?
2 掌握日期相关类的使用?
2 掌握 System 类的使用?
一：Object 类
java.lang 包中定义的 Object 类是所有 Java 类的根父类，其中定义了一些实现和支持面
向对象机制的重要方法。任何Java 对象，如果没有父类，就默认它继承了 Object类。因此，
实际上，以前的定义是下面的简略：
public class Employee extends Object 和
public class Manager extends Employee
Object 类定义许多有用的方法，包括 toString(),它就是为什么 Java软件中每样东西
都能转换成字符串表示法的原因。 （即使这仅具有有限的用途） 。
1：equals方法
Object类定义的equals方法用于判别某个指定的对象与当前对象 （调用 equals方法的对
象）是否等价。在Java 语言中数据等价的基本含义是指两个数据的值相等。
”==”进行比较的时候，引用类型数据比较的是引用，即内存地址，基本数据类型比较的
是值。
1.1：equals方法与“==”运算符的关系
equals()方法只能比较引用类型，"=="可以比较引用类型及基本类型；
特例：当用equals()方法进行比较时，对类 File、String、Date及包装类来说，是比较类
型及内容而不考虑引用的是否是同一个实例；
用"=="进行比较时，符号两边的数据类型必须一致(可自动转换的数据类型除外)，否则
编译出错，而用equals方法比较的两个数据只要都是引用类型即可。
示例如下：
class MyDate {
private int day, month, year;
public MyDate(int day, int month, int year) {
this.day = day;
this.month = month;
this.year = year;
}
}
public class Test {
public static void main(String[] args) {
MyDate m1 = new MyDate(8, 8, 2008);
MyDate m2 = new MyDate(8, 8, 2008);
if (m1 == m2) {
System.out.println("m1==m2");
} else {
System.out.println("m1!=m2");
}
if (m1.equals(m2)) {
System.out.println("m1 is equal to m2");
} else {
System.out.println("m1 is not equal to m2");
}
m2 = m1;
if (m1 == m2) {
System.out.println("m1==m2");
} else {
System.out.println("m1!=m2");
}
}
}
程序运行结果为：
m1!=m2
m1 is not equal to m2
m1==m2
小结一下:
在引用类型的比较上，Object里面的 equals方法默认的比较方式，基本上等同于“==” ，
都是比较内存地址，只有那几个特殊的是比较的值。
1.2：覆盖equals方法
对于程序员来说，如果一个对象需要调用 equals 方法，应该在类中覆盖 equals 方法。
如果覆盖了equals方法，那么具体的比较就按照你的实现进行比较了。
一般来讲：为了比较两个分离的对象（也就是内存地址不同的两个对象） ，自行覆盖的
equals 方法里面都是检查类型和值是否相同。上面那几个特殊的情况就是这样，比如 String
类，它覆盖了equals方法，然后在里面进行值的比较。
覆盖equals方法的一般步骤如下：
（1）：用==检查是否参数就是这个对象的引用
（2）：判断要比较的对象是否为null，如果是null，返回 false
（3）：用instanceof 判断参数的类型是否正确
（4）：把参数转换成合适的类型
（5）：比较对象属性值是不是匹配
示例如下：
覆盖前equals和==比较的都是内存地址：
public class Test{
public static void main(String[] args) {
A a1 = new A();
a1.age = 3;
A a2 = new A();
a2.age = 3;
System.out.println("a1 == a2 test ="+(a1==a2));
System.out.println("a1 equals a2 test ="+a1.equals(a2));
}
}
class A{
public int age = 0;
}
运行结果是：
a1 == a2 test =false
a1 equals a2 test =false
覆盖后equals比较的是值，==比较的是内存地址：
public class Test{
public static void main(String[] args) {
Test t = new Test();
A a1 = new A();
a1.age = 3;
A a2 = new A();
a2.age = 3;
System.out.println("a1 == a2 test ="+(a1==a2));
System.out.println("a1 equals a2 test ="+a1.equals(a2));
}
}
class A{
public int age = 0;
public boolean equals(Object obj){
//第一步先判断是否同一个实例
if(this==obj){
return true;
}
//第二步判断要比较的对象是否为null
if (obj == null){
return false;
}
//第三步判断是否同一个类型
if(obj instanceof A){
//第四步类型相同，先转换成为同一个类型
A a = (A)obj;
//第五步然后进行对象属性值的比较
if(this.age == a.age){
return true;
}else{
return false;
}
}else{
//类型不同，直接返回false
return false;
}
}
}
说明：如果对象的属性又是一个引用类型的话，会继续调用该引用类型的 equals 方法，直
到最后得出相同还是不同的结果。示例如下：
public class Test{
public static void main(String[] args) {
Test t = new Test();
A a1 = new A();
a1.age = 3;
A a2 = new A();
a2.age = 3;
System.out.println("a1 == a2 test ="+(a1==a2));
System.out.println("a1 equals a2 test ="+a1.equals(a2));
}
}
class A{
public int age = 0;
public String name = "Java私塾";
public boolean equals(Object obj){
//第一步先判断是否同一个实例
if(this==obj){
return true;
}
//第二步判断要比较的对象是否为null
if (obj == null){
return false;
}
//第三步判断是否同一个类型
if(obj instanceof A){
//第四步类型相同，先转换成为同一个类型
A a = (A)obj;
//第五步然后进行对象属性值的比较
if(this.age == a.age && this.name.equals(a.name)){
return true;
}else{
return false;
}
}else{
//类型不同，直接返回false
return false;
}
}
}
最后重要的一点规则：覆盖equals方法应该连带覆盖 hashCode 方法。
2：hashCode 方法
hashCode是按照一定的算法得到的一个数值，是对象的散列码值。主要用来在集合（后
面会学到）中实现快速查找等操作，也可以用于对象的比较。
在Java 中，对hashCode的规定如下：
（1）：在同一个应用程序执行期间，对同一个对象调用 hashCode()，必须返回相同的整
数结果——前提是equals()所比较的信息都不曾被改动过。 至于同一个应用程序在不同执
行期所得的调用结果，无需一致。
（2）：如果两个对象被equals(Object)方法视为相等，那么对这两个对象调用hashCode
()必须获得相同的整数结果。
（3）：如果两个对象被equals(Object) 方法视为不相等，那么对这两个对象调用 hashC
ode()不必产生不同的整数结果。然而程序员应该意识到，对不同对象产生不同的整数结
果，有可能提升hashTable（后面会学到，集合框架中的一个类） 的效率。
简单地说：如果两个对象相同，那么它们的 hashCode 值一定要相同；如果两个对象的
hashCode相同，它们并不一定相同。
在Java 规范里面规定，覆盖equals方法应该连带覆盖 hashCode方法，这就涉及到一个
如何实现hashCode方法的问题了。
实现一：偷懒的做法：对同一对象始终返回相同的 hashCode，如下：
public int hashCode(){
return 1;
}
它是合法的， 但是不好， 因为每个对象具有相同的 hashCode， 会使得很多使用 hashCode
的类的运行效率大大降低，甚至发生错误。
实现二：采用一定的算法来保证
在高效Java 编程这本书里面，给大家介绍了一个算法，现在 eclipse自动生成 equals方
法和hashCode方法就是用的这个算法，下面介绍一下这个算法：
（1）：将一个非0常数，例如 31，储存于 int result变量
（2）：对对象中的每个有意义的属性 f（更确切的说是被 equals()所考虑的每一个属
性）进行如下处理：
A. 对这个属性计算出类型为int的 hash 码 c：
i. 如果属性是个 boolean，计算(f ? 0 : 1)。
ii. 如果属性是个 byte,char,short或 int，计算(int)f。
iii. 如果属性是个 long，计算(int)(f^(f >>> 32))。
iv. 如果属性是个 float，计算Float.floatToIntBits(f)。
v. 如果属性是个 double，计算Double.doubleToLongBits(f)，然后将计算结果
按步骤 2.A.iii处理。
vi. 如果属性是个对象引用， 而且 class 的equals()通过递归调用 equals()的方
式来比较这一属性，那么就同样也对该属性递归调用hashCode()。如果需要更复
杂的比较，请对该属性运算一个范式（canonical representation），并对该范
式调用hashCode()。如果属性值是null，就返回 0（或其它常数；返回 0 是传统
做法）。
vii. 如果属性是个数组，请将每个元素视为独立属性。也就是说对每一个有意义
的元素施行上述规则，用以计算出hash 码，然后再依步骤 2.B 将这些数值组合起
来。
B. 将步骤A计算出来的 hash码 c 按下列公式组合到变量 result中：
result = 31*result + c;
（3）： 返回result。
示例如下：这个就是用eclipse自动生成的
public class Test{
private byte byteValue;
private char charValue;
private short shortValue;
private int intValue;
private long longValue;
private boolean booleanValue;
private float floatValue;
private double doubleValue;
private String uuid;
private int[] intArray = new int[3];
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + (booleanValue ? 1231 : 1237);
result = prime * result + charValue;
long temp;
temp = Double.doubleToLongBits(doubleValue);
result = prime * result + (int) (temp ^ (temp >>> 32));
result = prime * result + Float.floatToIntBits(floatValue);
result = prime * result + Arrays.hashCode(intArray);
result = prime * result + intValue;
result = prime * result + (int) (longValue ^ (longValue >>> 32));
result = prime * result + shortValue;
result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
return result;
}
}
3：toString 方法
toString()方法是Object类中定义的另一个重要方法，其格式为：
public String toString(){……}
方法的返回值是String类型，用于描述当前对象的有关信息。 Object类中实现的toString()
方法是返回当前对象的类型和内存地址信息，但在一些子类（如 String, Date等）中进行了
重写，也可以根据需要在用户自定义类型中重写 toString()方法，以返回更适用的信息。
除显式调用对象的toString()方法外，在进行 String与其它类型数据的连接操作时，
会自动调用toString()方法，其中又分为两种情况：
（1） ：引用类型数据直接调用其 toString()方法转换为 String 类型；
（2） ： 基本类型数据先转换为对应的包装类型， 再调用该包装类的toString()方法转换为String
类型。
另外，在 System.out.println()方法输出引用类型的数据时，也先自动调用了该对象的
toString()方法，然后再将返回的字符串输出。
示例如下：
class MyDate{
private int day,month,year;
public MyDate(int d, int m, int y){
day = d; month = m; year = y;
}
}
class YourDate{
private int day,month,year;
public YourDate(int d, int m, int y){
day = d; month = m; year = y;
}
public String toString(){
return day + "-" + month + "-" + year;
}
}
public class Test{
public static void main(String args[]){
MyDate m = new MyDate(8,8,2008);
System.out.println(m);
System.out.println(m.toString());
YourDate y = new YourDate(8,8,2008);
System.out.println(y);
}
}
运行结果：
cn.javass.java6.test.MyDate@1fb8ee3
cn.javass.java6.test.MyDate@1fb8ee3
8-8-2008
toString 方法被用来将一个对象转换成 String 表达式。当自动字符串转换发生时，它被
用作编译程序的参照。System.out.println()调用下述代码：
Date now = new Date()
System.out.println(now)
将被翻译成：
System.out.println(now.toString());
对象类定义缺省的 toString()方法，它返回类名称和它的引用的地址（通常情况下不是
很有用） 。许多类覆盖 toString()以提供更有用的信息。例如，所有的包装类覆盖 toString()
以提供它们所代表的值的字符串格式。甚至没有字符串格式的类为了调试目的常常实现
toString()来返回对象状态信息。
二：String 类
1：String的直接量
双引号括起来的字符序列就是String的直接量。实例: “John” 或 "111222333"
字符串赋值，可以在声明时赋值
String color = "blue";
color 是String 类型的引用。
“blue” 是String直接量。
String 直接量是存放在栈内存里，所以一旦定义就不能改变值了，只能是让变量指向
新的内存空间。比如：
color = “red”;
如果采用new 的方法定义String，那么是需要分配堆内存空间的，如下：
String str = new String(“Hello”);
一共有两个对象，在栈和堆内存中各有一个对象，内容都是“Hello”。
2：String 的常用方法
2.1：String 方法:length(),charAt() ,getBytes()和 getChars()
方法 length()
–返回 String 的长度，是按照char 返回的长度
–与数组不同之处: String类不含有 length成员域（属性）
方法charAt(int index)
–获得字符串指定位置的字符
方法getBytes()
–使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一
个新的 byte 数组中
方法getChars(int srcBegin, int srcEnd,
char[ ] dst, int dstBegin)
–拷贝字符串的部分字符序列到指定的字符数组的指定位置
注意：对于字符串中的汉字，是按照 char 来计算的，一个中文汉字占两个字节，也就
是说，通过length()得到的是字符串char 的长度，而不是字节数，利用这个特点，就可以
进行中文判断了。
例如：如何判断一个字符串里面有没有中文呢？如果字符串对应的 byte[]和 char[]的
长度是不一样的，那就说明包含中文，其实还可以顺带计算出有几个汉字。
public class Test{
public static void main(String[] args) {
String str = "这里是Java私塾";
int charLen = str.length();
int byteLen = str.getBytes().length;
if(byteLen > charLen){
int chineseNum = byteLen - charLen;
System.out.println("str包含汉字，汉字共"+chineseNum+"个");
}else{
System.out.println("str没有包含汉字");
}
}
}
运行结果是：
str包含汉字，汉字共5个
2.2：字符串比较
–字符类型的数据也是数值类型数据
–比较字符串大小，实际上就是依次比较其所包含的字符的数值大小
–小写字母与大小字母是不相同的，Java是区分大小写
方法 compareTo(String s)：
比较两个字符串的大小。返回 0表示相等，返回大于0 的数表示前面的字符串大于
后面的字符串，返回小于0表示前面的字符串小于后面的字符串，区分大小写的。如下：
public class Test{
public static void main(String[] args) {
String str = "这里是JAVA私塾";
String str2 = "这里是java 私塾";
if(str.compareTo(str2)==0){
System.out.println("the str 等于 str2");
}else if(str.compareTo(str2) > 0){
System.out.println("the str 大于 str2");
}else if(str.compareTo(str2) < 0){
System.out.println("the str 小于 str2");
}
}
}
运行结果：the str 小于 str2
方法 compareToIgnoreCase(String s)：忽略大小写，比较两个字符串的大小。返回 0
表示相等，返回大于0的数表示前面的字符串大于后面的字符串，返回小于0 表示前面的字
符串小于后面的字符串。如下：
public class Test{
public static void main(String[] args) {
String str = "这里是JAVA私塾";
String str2 = "这里是java 私塾";
if(str.compareToIgnoreCase(str2)==0){
System.out.println("the str 等于 str2");
}else if(str.compareToIgnoreCase(str2) > 0){
System.out.println("the str 大于 str2");
}else if(str.compareToIgnoreCase(str2) < 0){
System.out.println("the str 小于 str2");
}
}
}
运行结果：the str 等于 str2
方法equals(Object s)：比较两个 String对象的值是否相等，这个是区分大小写的
方法equalsIgnoreCase(String s)：比较两个 String对象的值是否相等，忽略大小写
String的比较要使用equals()方法，不能使用”==”
2.3：查找字符串中的字符或子串
查找字符串(String)中的字符或子串
方法indexOf
四种重载方法 indexOf() 返回第一次找到时的下标
如果没有找到，则返回-1。实例:
String name = "CoolTools";
System.out.println (name.indexOf("oo"));
方法 lastIndexOf
–public int lastIndexOf(int ch, int fromIndex)
–从指定位置往回查找，返回找到的最大的字符下标位置
–即返回满足下面条件的最大值:
(this.charAt(k) == ch) && (k <= fromIndex)
–返回-1: 如果当前字符串不含该字符
方法startsWith(Stirng prefix)：测试此字符串是否以指定的前缀开始，如下：
public class Test{
public static void main(String[] args) {
String str = "这里是 Java 私塾";
String str2 = "Java";
System.out.println(str.startsWith(str2));
}
}
运行结果：false
方法startsWith(String prefix,int toffset)：测试此字符串从指定索引开始的子字
符串是否以指定前缀开始。
public class Test{
public static void main(String[] args) {
String str = "这里是 Java 私塾";
String str2 = "Java";
System.out.println(str.startsWith(str2,3));
}
}
运行结果：true
方法endsWith(String suffix)：测试此字符串是否以指定的后缀结束
2.4：从当前字符串中抽取子字符串
方法 substring
–substring(int beginIndex)
返回新的字符串: 当前字符串的子串
该子串从指定的位置开始，并一直到当前字符串结束为止
–substring(int beginIndex, int endIndex)
返回新的字符串: 当前字符串的子串
该子串从指定的位置(beginIndex )开始， 到指定的位置(endIndex - 1)
结束
例如：
“unhappy”.substring(2) 返回 "happy"
“Harbison“.substring(3)返回 "bison"
“emptiness”.substring(9)返回 "" (空串)
“emptiness“.substring(10)返回 StringIndexOutOfBoundsException
“hamburger“.substring(4, 8)返回 "urge"
“smiles“.substring(1, 5)返回 "mile"
2.5：字符串拼接
方法 concat
–拼接两个字符串，并返回一个新字符串
–源字符串不会被修改
–s1.concat( s2 )
返回字符串s1 和s2拼接的结果
实例:
String s1 = "ABC";
String s2 = "XYZ";
s1 = s1.concat(s2); // 等同于 s1 = s1 + s2;
2.6：类String的成员方法valueOf
静态(static)成员方法valueOf
–将参数的值转化成相应的字符串
–valueOf(char[ ] data)
返回 new String(data);
–valueOf(char[ ] data, int offset, int count)
返回 new String(data, offset, count);
–其它valueOf方法的参数的类型: boolean、char、int、long、float、double
和Object
对象还可以通过方法toString转化成字符串
2.7：字符串分解
方法split(String regex)
根据给定正则表达式的匹配拆分此字符串， 得到拆分好的字符串数组， 示例如下：
public class Test{
public static void main(String[] args) {
String str = "这里,是Java,私塾";
String tempS[] = str.split(",");//按照“， ”对字符串进行拆分
for(int i=0;i<tempS.length;i++){
System.out.println("tempS["+i+"]==="+tempS[i]);
}
}
}
运行结果：
tempS[0]===这里
tempS[1]===是Java
tempS[2]===私塾
注意：
（1）如果用“.”作为分隔的话，必须是如下写法：String.split("\\."),这样才能正确的
分隔开，不能用String.split(".");
public class Test{
public static void main(String[] args) {
String str = "这里.是Java.私塾";
String tempS[] = str.split("\\.");//按照"."对字符串进行拆分
for(int i=0;i<tempS.length;i++){
System.out.println("tempS["+i+"]==="+tempS[i]);
}
}
}
（2）如果用“|”作为分隔的话，必须是如下写法：String.split("\\|"),这样才能正确的
分隔开，不能用String.split("|");
因为“.”和“|”都是转义字符，必须得加"\\";
public class Test{
public static void main(String[] args) {
String str = "这里|是Java|私塾";
String tempS[] = str.split("\\|");//按照"|"对字符串进行拆分
for(int i=0;i<tempS.length;i++){
System.out.println("tempS["+i+"]==="+tempS[i]);
}
}
}
StringTokenizer 类
与String的split 方法功能类似，也是用来分解字符串，StringTokenizer 是出于
兼容性的原因而被保留的遗留类（在新代码中并不鼓励使用它） 。建议所有寻求此功能的人
使用 String 的 split 方法或 java.util.regex 包。所以这里就不多说了。
2.8：其它String方法
方法replace( char1, char2 )
–返回一个新的字符串，它是将 s1 中的所有 char1替换成的结果char2
–源字符串没有发生变化
–如果s1不含char1, 则返回源字符串的引用，即 s1
实例:
–“mesquite in your cellar”.replace(‘e’, ‘o’) 结果返回
"mosquito in your collar"
–“JonL”.replace(‘q’, ‘x’)结果返回“JonL” (没有发生变化)
方法toUpperCase
–返回对应的新字符串，所有小写字母都变为大写的，其它的不变
–如果没有字符被修改，则返回源字符串的引用
–类似方法s1.toLowerCase （所有大写字母都变为小写字母）
方法trim( )
–返回新字符串，截去了源字符串最前面和最后面的的空白符
–如果字符串没有被改变，则返回源字符串的引用
方法toString( )
–由于s1本身就是字符串了，所以返回 s1 本身
–其它引用类型也可以通过方法 toString，生成相应的字符串
方法toCharArray( )
–将字符串转换成字符数组
方法intern
–返回具有相同内容的字符串的引用
–如果字符串池含有该内容的字符串， 则返回字符串池中具有该内容的字符串的
引用
–如果字符串池没有字符串的内容与其相同， 则在字符串池中创建具有该内容的
字符串，再返回新创建的字符串的引用
字符串池
–组成: 字符串直接量 以及 由方法 intern产生的字符串
–字符串池中的字符串s与 t ： s与 t 具有相同内容(s.equals(t))当且仅当指
向s与t的同一个字符串(s.intern() == t.intern())
–可以采用这个机制加速字符串是否相等的判定
三：正则表达式和相关的 String 方法
完整的正则表达式语法是比较复杂的，这里只是简单地入个门，更多的正则表达式请参
考相应的书籍或者文章。不过没有什么大的必要，常见的正则表达式基本都是写好了的，拿
过来用就可以了。
1：正则表达式是什么
在编写处理字符串的程序时，经常会有查找符合某些复杂规则的字符串的需要，正则表
达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。
回忆一下在 Windows下进行文件查找，查找的通配符也就是*和?。如果你想查找某个目
录下的所有的Word 文档的话，你会搜索*.doc。在这里，*会被解释成任意的字符串。和通
配符类似，正则表达式也是用来进行文本匹配的工具，只不过比起通配符，它能更精确地描
述你的需求——当然， 代价就是更复杂——比如你可以编写一个正则表达式，用来查找所有
以0开头，后面跟着2-3个数字，然后是一个连字号“-” ，最后是 7 或 8位数字的字符串(像
010-12345678 或0123-1234567)。
简言之正则表达式是用于进行文本匹配的工具，也是一个匹配的表达式。
2：正则表达式基础入门
学习正则表达式的最好方法是从例子开始， 理解例子之后再自己对例子进行修改，实验。
下面给出了不少简单的例子，并对它们作了详细的说明。
假设你在一篇英文小说里查找hi，你可以使用正则表达式 hi。
这是最简单的正则表达式了，它可以精确匹配这样的字符串：由两个字符组成，前一个
字符是h,后一个是 i。通常，处理正则表达式的工具会提供一个忽略大小写的选项，如果选
中了这个选项，它可以匹配hi,HI,Hi,hI 这四种情况中的任意一种。
不幸的是，很多单词里包含 hi 这两个连续的字符，比如 him,history,high 等等。用
hi 来查找的话，这里边的 hi 也会被找出来。如果要精确地查找 hi 这个单词的话，我们应
该使用\bhi\b。
\b 是正则表达式规定的一个特殊代码（某些人叫它元字符，meta character） ，代表着
单词的开头或结尾，也就是单词的分界处。虽然通常英文的单词是由空格或标点符号或换行
来分隔的，但是\b并不匹配这些单词分隔符中的任何一个，它只匹配一个位置。
假如你要找的是hi后面不远处跟着一个Lucy，你应该用\bhi\b.*\bLucy\b。
.是另一个元字符，匹配除了换行符以外的任意字符。*同样是元字符，不过它代表的不
是字符，也不是位置，而是数量——它指定*前边的内容可以连续重复出现任意次以使整个
表达式得到匹配。因此，.*连在一起就意味着任意数量的不包含换行符。现在
\bhi\b.*\bLucy\b 的意思就很明显了：先是一个单词 hi,然后是任意个任意字符(但不能是
换行符)，最后是Lucy 这个单词。
如果同时使用其它的一些元字符，我们就能构造出功能更强大的正则表达式。比如下面
这个例子：
0\d\d-\d\d\d\d\d\d\d\d 匹配这样的字符串：以 0 开头，然后是两个数字，然后是一
个连字号“-” ，最后是8 个数字(也就是中国的电话号码。当然，这个例子只能匹配区号为
3位的情形)。
这里的\d 是一个新的元字符，匹配任意的数字(0，或1，或 2，或……)。-不是元字符，
只匹配它本身——连字号。
为了避免那么多烦人的重复，我们也可以这样写这个表达式：0\d{2}-\d{8}。 这里\d
后面的{2}和{8}的意思是前面\d 必须连续重复匹配 2次和 8 次。
3：在 Java中运行正则表达式
在Java中的String类中有好几个方法都跟正则表达式有关，最典型的就是
方法matches(String regex)
告知此字符串是否匹配给定的正则表达式
使用这个方法来测试和运行上面学到的正则表达式，示例如下：
public class Test{
public static void main(String[] args) {
String str = "010-86835215";
System.out.println("str 是 一个 正 确的 电 话 号 码 ？ 答 案 是：
"+str.matches("0\\d{2}-\\d{8}"));
}
}
运行结果：str是一个正确的电话号码？答案是：true
注意：由于在Java 里面“\”需要转义，应该变成“\\” 。
在Java中，有专门进行正则表达式的类，在 java.util.regex 包里面。
3.1：java.util.regex.Pattern类
Pattern类是正则表达式的编译表示形式。
指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于
创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及
的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式
常见方法如下：
static Pattern compile(String expression)
static Pattern compile(String expression, int flags)：编译正则表达式字符串
到pattern对象用以匹配的快速处理
参数:
expression 正则表达式
flags 下列标志中的一个或多个： CASE_INSENSITIVE, UNICODE_CASE,
MULTILINE, UNIX_LINES, DOTALL, and CANON_EQ
Matcher matcher(CharSequence input)：返回一个 matcher对象，它可以用来在一个
输入中定位模式匹配
String[] split(CharSequence input)
String[] split(CharSequence input, int limit)：将输入字符串分离成记号，并由
pattern 来指定分隔符的形式。返回记号数组。分隔符并不是记号的一部分。
参数:
input 分离成记号的字符串
limit 生成的最大字符串数。
3.2：java.util.regex.Matcher类
Mathcer类通过解释 Pattern 对字符序列执行匹配操作的引擎。
常见方法如下：
boolean matches()：返回输入是否与模式匹配
boolean lookingAt()：如果输入的起始匹配模式则返回 True
boolean find()
boolean find(int start)：尝试查找下一个匹配，并在找到匹配时返回True
参数:
start 开始搜索的索引
int start()：返回当前匹配的起始位置位置
int end()：返回当前匹配的结尾后位置
String group()：返回当前匹配
int groupCount()：返回输入模式中的分组数
int start(int groupIndex)
int end(int groupIndex)
返回一个给定分组当前匹配中的起始位置和结尾后位置
参数:
groupIndex分组索引（从 1开始） ，0表示整个匹配
String group(int groupIndex)：返回匹配一个给定分组的字符串
参数:
groupIndex 分组索引（从1 开始） ，0 表示整个匹配
String replaceAll(String replacement)
String replaceFirst(String replacement)
返回从matcher输入得到的字符串，但已经用替换表达式替换所有或第一个匹配
参数:
replacement 替换字符串
Matcher reset()
Matcher reset(CharSequence input)
复位mather状态。
3.3：Java中操作正则表达式示例
public class Test{
public static void main(String[] args) {
String str = "010-86835215";
Pattern p = Pattern.compile("0\\d{2}-\\d{8}");
Matcher m = p.matcher(str);
boolean flag = m.matches();
System.out.println("str是一个正确的电话号码？答案是："+flag);
}
}
运行结果：str是一个正确的电话号码？答案是：true
4：元字符
现在你已经知道几个很有用的元字符了，如\b、.、*，还有\d.当然还有更多的元字符
可用，比如\s 匹配任意的空白符，包括空格，制表符(Tab)，换行符，中文全角空格等。\w
匹配字母或数字或下划线或汉字等。
下面来试试更多的例子：
例1：\ba\w*\b
匹配以字母 a 开头的单词——先是某个单词开始处(\b)，然后是字母 a,然后是任意数
量的字母或数字(\w*)，最后是单词结束处(\b)（好吧，现在我们说说正则表达式里的单词
是什么意思吧：就是几个连续的\w。不错，这与学习英文时要背的成千上万个同名的东西的
确关系不大） 。
例2：\d+
匹配 1 个或更多连续的数字。这里的+是和*类似的元字符，不同的是*匹配重复任意次
(可能是 0次)，而+则匹配重复1次或更多次。
例3：\b\w{6}\b
匹配刚好6个字母/数字的单词。
例4：^\d{5,12}$
匹配必须为5位到12位数字的字符串
元字符^（和数字6在同一个键位上的符号）以及$和\b 有点类似，都匹配一个位置。^
匹配你要用来查找的字符串的开头，$匹配结尾。这两个代码在验证输入的内容时非常有用，
比如一个网站如果要求你填写的QQ号时，可以使用。
这里的{5,12}和前面介绍过的{2}是类似的，只不过{2}匹配只能不多不少重复 2 次，
{5,12}则是重复的次数不能少于5次，不能多于12次，否则都不匹配。
因为使用了^和$，所以输入的整个字符串都要用来和\d{5,12}来匹配，也就是说整个输
入必须是5到12个数字，因此如果输入的 QQ 号能匹配这个正则表达式的话，那就符合要求
了。
5：重复
已经看过了前面的*,+,{2},{5,12}这几个匹配重复的方式了。下面是正则表达式中所有
的限定符(指定数量的代码，例如*,{5,12}等)：
常用的限定符
代码/语法 说明
* 重复零次或更多次
+ 重复一次或更多次
? 重复零次或一次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到 m次
下面是一些使用重复的例子：
Windows\d+ : 匹配Windows后面跟 1个或更多数字
13\d{9} : 匹配13后面跟9个数字(中国的手机号)
6：字符类
要想查找数字，字母或数字，空白是很简单的，因为已经有了对应这些字符集合的元字
符，但是如果你想匹配没有预定义元字符的字符集合(比如元音字母 a,e,i,o,u),应该怎么
办？
很简单，你只需要在中括号里列出它们就行了，像[aeiou]就匹配任何一个英文元音字
母，[.?!]匹配标点符号(.或?或!)(英文语句通常只以这三个标点结束)。
我们也可以轻松地指定一个字符范围，像[0-9]代表的含意与\d就是完全一致的：一位
数字，同理[a-z0-9A-Z_]也完全等同于\w（如果只考虑英文的话） 。
7：常见正则表达式
（1） ：检测是否Email 地址
^([\\w-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([\\w-]+\\.)
+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$
（2） ：判断输入的字符串只包含汉字
^[\u4e00-\u9fa5]+$
（3） ：匹配3位或4位区号的电话号码，其中区号可以用小括号括起来，也可以不用，区号
与本地号间可以用连字号或空格间隔，也可以没有间隔
^\\(0\\d{2}\\)[- ]?\\d{8}$|^0\\d{2}[- ]?\\d{8}$|^\\(0\\d{3}\\)[- ]?\\d{7}$|
^0\\d{3}[- ]?\\d{7}$
（4） ：判断输入的字符串是否是一个合法的手机号，这个不完全，只是 13开头的
^13\\d{9}$
（5） ：判断输入的字符串只包含数字，可以匹配整数和浮点数
^-?\\d+$|^(-?\\d+)(\\.\\d+)?$
（6） ：匹配非负整数
^\\d+$
（7） ：判断输入的字符串只包含英文字母
^[A-Za-z]+$
（8） ：判断输入的字符串是否只包含数字和英文字母
^[A-Za-z0-9]+$
好了，学到这里对基本的正则表达式就有了基本的认识，下面来看看 String 里面跟正
则表达式有关的几个方法的使用。
8：相关 String类的方法
方法 matches(String regex)
告知此字符串是否匹配给定的正则表达式
方法replaceAll(String regex, String replacement)
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
示例如下：
public class Test{
public static void main(String[] args) {
String str = "这里是Java私塾,到Java私塾学习Java";
String regStr = "Java";
str = str.replaceAll(regStr, "ABC");
System.out.println("str="+str);
}
}
运行结果：
str=这里是ABC私塾,到ABC私塾学习ABC
方法 replaceFirst(String regex, String replacement)
使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串
方法split(String regex)
根据给定正则表达式的匹配拆分此字符串，它是全部拆分
方法split(String regex, int limit)
根据匹配给定的正则表达式来拆分此字符串，limit是限制拆分的次数，实际分解
的次数是limit-1 次，limit就是分解后数组的length。
示例如下：
public class Test{
public static void main(String[] args) {
String str = "这里,是Java,私塾";
String tempS[] = str.split(",",2);
for(int i=0;i<tempS.length;i++){
System.out.println("tempS["+i+"]=="+tempS[i]);
}
}
}
运行结果：
tempS[0]==这里
tempS[1]==是Java,私塾
四：StringBuffer 类和 StringBuilder 类
前面学到过String类有一个重要的特点，那就是String的值是不可变的，这就导致每
次对String的操作都会生成新的String对象，不仅效率低下，而且大量浪费有限的内存空
间。那么对于经常要改变值的字符串应该怎样操作呢？
答案就是使用 StringBuffer和 StringBuilder 类，这两个类功能基本相似，区别主要
在于 StringBuffer 类的方法是多线程安全的（多线程的课程在后面会学习到） ，而
StringBuilder 不是线程安全的，相比而言 StringBuilder 类会略微快一点。
1：StringBuffer 类
类 String
–字符串(String)对象一旦创建，其内容不能再被修改 (read-only)
类 StringBuffer
–StringBuffer 对象的内容是可以被修改的
–除了字符的长度之外，还有容量的概念
–通过动态改变容量的大小，加速字符管理
1.1：StringBuffer的构造方法
buf1 = new StringBuffer();
–创建空的StringBuffer 对象，初始容量为 16字符
buf2 = new StringBuffer( 容量 );
–创建空的StringBuffer 对象，指定容量大小。
buf3 = new StringBuffer( myString );
–创建含有相应字符序列的 StringBuffer对象， 容量为 myString.length() +
16
–实例:
StringBuffer b = new StringBuffer("hello");
1.2：StringBuffer的常用方法
?方法 length()
–返回 StringBuffer 的长度
?方法 capacity()
–返回StringBuffer 的容量
?方法setLength(int newLength)
–增加或减小 StringBuffer 的长度
?方法 charAt(int index)
–返回StringBuffer 对象中指定位置的字符
?方法setCharAt(int index, char ch)
–设置 StringBuffer对象中指定位置的字符
?方法 getChars(int srcBegin, int srcEnd,
Char[] dst, int dstBegin)
–将StringBuffer对象中指定的字符子序列，拷贝到指定的字符数组(dst)
?方法 reverse()
–将StringBuffer 对象中的字符序列按逆序方式排列，可用作字符串倒序
?11种append(…) 方法
–允许数值类型的值添加到 StringBuffer对象中
?10 种 insert 方法
–允许将各种数据插到 StringBuffer 对象的指定位置
?方法 delete(int start, int end) 和 deleteCharAt(int index)
–允许删除StringBuffer 对象中的指定字符
其中最常用的恐怕就要算append 方法和toString 方法了，如下示例:
public class Test{
public static void main(String[] args) {
StringBuffer buffer = new StringBuffer();
buffer.append("这里");
buffer.append("是");
buffer.append("Java");
buffer.append("私塾");
System.out.println("buffer=="+buffer.toString());
}
}
运行结果：buffer==这里是Java私塾
2：StringBuilder 类
StringBuilder类是一个可变的字符序列。 此类提供一个与 StringBuffer 兼容的 API，
但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单
个线程使用的时候（这种情况很普遍） 。如果可能，建议优先采用该类，因为在大多数实现
中，它比 StringBuffer 要快。
它的功能基本等同于StringBuffer 类，就不再赘述了。
public class Test{
public static void main(String[] args) {
StringBuilder builder = new StringBuilder();
builder.append("这里");
builder.append("是");
builder.append("Java");
builder.append("私塾");
System.out.println("buffer=="+builder.toString());
}
}
运行结果：builder==这里是Java私塾
五：Math类
Java中的数学（Math）类是final 类，不可继承。
其中包含一组静态方法和两个常数
1：常数
PI ：double，圆周率
E ：double，自然对数
2：截取(注意方法的返回类型)
double ceil(double d)
-返回不小于d的最小整数
double floor(double d)
-返回不大于d的最大整数
int round(float f)
-返回四舍五入后的整数
long round(double d)
-返回四舍五入后的整数
3：变换（int long float各种类型相似）
double abs(double d)
-返回绝对值
double min(double d1, double d2)
-返回两个值中较小的值
double max(double d1, double d2)
-返回两个值中较大的值
4：对数
double log(double d)
-自然对数
double exp(double d)
-E的指数
5：其它
double sqrt(double d)
-返回平方根
double random()
-返回随机数
还有三角函数的运算等，请参考 JDK 文档
示例如下：问题：请问有101条记录，按照每组 10条记录进行分组，应该分多少组？
public class Test{
public static void main(String[] args) {
int records = 101;//共有 101条记录
final int GROUP_NUM = 10;//每组 10条
int groups = (int)Math.ceil(1.0*records/GROUP_NUM);//注意这里的 1.0，目
的是要把类型变成double型的，而不是 int/int，结果还是 int，就错了。
System.out.println("应该分的组数为="+groups);
}
}
运行结果：应该分的组数为=11
六：Java 日期操作的类
1：Date类
java.util 包里面的Date 类，是Java 里面进行日期操作常用类。Date类用来表示特定
的瞬间，精确到毫秒。
1.1：如何初始化Date
构造方法：Date()
分配 Date 对象并初始化此对象，以表示分配它的时候的当前时间（精确到
毫秒） 。使用Date类得到当前的时间。
构造方法：Date(long date)
分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元
（epoch） ” ，即 1970 年 1 月 1 日 00:00:00 格林威治时间）以来的指定毫秒数。
2.2：常用方法
方法：after(Date when)
测试此日期是否在指定日期之后
方法：before(Date when)
测试此日期是否在指定日期之前
方法：getTime()
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
2.3：示例：简单的性能测试——监控一段代码运行所需要的时间
public class Test {
public static void main(String args[]) {
long d1 = new Date().getTime();//得到此时的时间
int sum = 0;
for(int i=1;i<=1000000;i++){//看清楚了，可是一百万次
sum +=i;
}
System.out.println("从1加到1000000的和="+sum);
long d2 = new Date().getTime();//得到此时的时间
System.out.println("从1加到1000000所耗费的时间是="+(d2-d1)+"毫秒
");
}
}
运行结果：
从1加到1000000的和=1784293664
从1加到1000000所耗费的时间是=20毫秒
2：DateFormat类和SimpleDateFormat类
在java.text包中的DateFormat类，是日期/时间格式化子类的抽象类，它以与语言无
关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进
行格式化（也就是日期——>文本） 、解析（文本——> 日期）和标准化。
由于DateFormat是个抽象类，SimpleDateFormat类是它的子类，所以下面就主要按照
SimpleDateFormat 类来讲解。
2.1：如何初始化
这里只讲述最常用到的构造方法，更多的请参看JDK文档。
构造方法：SimpleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat
2.2日期和时间模式
日期和时间格式由日期和时间模式 字符串指定。在日期和时间模式字符串中，未加引
号的字母 ‘A‘ 到 ‘Z‘ 和 ‘a‘ 到 ‘z‘ 被解释为模式字母，用来表示日期或时间字符串元
素。文本可以使用单引号 (‘) 引起来，以免进行解释。"‘‘" 表示单引号。所有其他字符均
不解释；只是在格式化时将它们简单复制到输出字符串，或者在解析时与输入字符串进行匹
配。
定义了以下模式字母（所有其他字符 ‘A‘ 到 ‘Z‘ 和 ‘a‘ 到 ‘z‘ 都被保留）：
字母 日期或时间元素 表示 示例
G Era 标志符 Text
y 年 Year 1996;
M 年中的月份 Month July;
w 年中的周数 Number 27
W 月份中的周数 Number 2
D 年中的天数 Number 189
d 月份中的天数 Number 10
F 月份中的星期 Number 2
E 星期中的天数 Text Tuesday;
a Am/pm 标记 Text
H 一天中的小时数（0-23） Number 0
k 一天中的小时数（1-24） Number 24
K am/pm 中的小时数（0-11） Number
h am/pm 中的小时数（1-12） Number
m 小时中的分钟数 Number 30
s 分钟中的秒数 Number 55
S 毫秒数 Number 978
z 时区 General time
Z 时区 RFC 822
2.3：常用方法
方法：parse(String source)
从给定字符串的开始解析文本，以生成一个日期
方法：format(Date date)
将一个 Date 格式化为日期/时间字符串
这里只讲述最常用的方法，更多的方法请参看 JDK文档。
2.4：示例
import java.util.*;
import java.text.*;
public class Test {
public static void main(String args[]) {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
Date d = new Date();
//把当前时间转换成为我们熟悉的时间表达格式
String str = df.format(d);
System.out.println("当前时间是："+str);
//然后再把字符串格式的日期转换成为一个Date类
try {
Date d2 = df.parse("2008-08-08 08:08:08 888");
System.out.println("北京奥运会开幕时间是："+d2.getTime());
} catch (ParseException e) {
e.printStackTrace();
}
}
}
运行结果：
当前时间是：2008-07-22 00:57:45 612
北京奥运会开幕时间是：1218154088888
2.5：说明
虽然JDK文档上说Date 的毫秒值，是相对于格林威治时间 1970 年1 月 1 号的 0 点，但
实际测试，这个 Date 是跟时区相关的，也就是说在中国测试这个基准值应该是 1970 年 1
月1日的8点，不过这个不影响我们的处理，因为只要是同一个基准时间就可以了，而不用
关心具体是多少，见下面的示例：
public class Test {
public static void main(String args[]) {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
Date d = new Date(0L);//把时间设为0，表示到基准时间
//然后转换成为字符串看看是什么时候
String str = df.format(d);
System.out.println("基准时间是："+str);
}
}
运行结果：
基准时间是：1970-01-01 08:00:00 000
3：Calendar类
java.util包中的Calendar类是Java里面另外一个常用的日期处理的类。 Calendar 类
是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段
之间的转换提供了一些方法， 并为操作日历字段（例如获得下星期的日期） 提供了一些方法。
3.1：如何初始化
Calendar 类是通过一个静态方法 getInstance()来获取 Calendar 实例。返回的
Calendar 基于当前时间，使用了默认时区和默认语言环境
如下：Calendar c = Calendar.getInstance();
3.2：使用Calendar对日期进行部分析取
Calendar 类一个重要的功能就是能够从日期里面按照要求析取出数据，如：年、月、
日、星期等等。
方法：get(int field)
返回给定日历字段的值
示例如下：
public class Test {
public static void main(String args[]) {
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);//注意：month特殊，是从0开始的，
也就是0表示1月
int day = c.get(Calendar.DAY_OF_MONTH);
System.out.println("现在是"+year+"年"+(month+1)+"月"+day+"日");
}
}
运行结果：
现在是2008年7月22日
3.3：使用Calendar进行日期运算
这是Calendar另外一个常用的功能，也就是对日期进行加加减减的运算。
方法：add(int field, int amount)
根据日历的规则，为给定的日历字段添加或减去指定的时间量
示例如下：
public class Test {
public static void main(String args[]) {
Calendar c = Calendar.getInstance();
c.add(Calendar.DATE, 12);//当前日期加12天，如果是-12就表示当前日期减
去12天
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);//注意：month特殊，是从0开始的，
也就是0表示1月
int day = c.get(Calendar.DAY_OF_MONTH);
System.out.println("在当前日期加12天是"+year+"年"+(month+1)+"月
"+day+"日");
}
}
运行结果：在当前日期加12天是2008年8月3日
3.4：为Calendar设置初始值
方法 setTime(Date date)
使用给定的 Date 设置此 Calendar 的当前时间
方法setTimeInMillis(long millis)
用给定的 long 值设置此 Calendar 的当前时间值
public class Test {
public static void main(String args[]) {
Calendar c = Calendar.getInstance();
c.setTimeInMillis(1234567890123L);
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);//注意：month特殊，是从0开始的，
也就是0表示1月
int day = c.get(Calendar.DAY_OF_MONTH);
System.out.println("设置的时间是"+year+"年"+(month+1)+"月"+day+"
日");
}
}
运行结果：设置的时间是2009年2月14日
七：System 类
1：命令行参数
当 Java 程序启动时，可以添加 0 或多个命令行参数（Command-line Arguments） 。不
管使用双引号与否都作为字符串自动保存到 main函数的参数中。参数之间用空格分隔。
public class Test{
public static void main(String args[]){
System.out.println(args.length);
for(int i=0; i<args.length; i++){
System.out.println(args[i]);
}
}
}
本段代码可以使用下面语句测试：java Test 这里 是 Java 私塾
运行结果：
4
这里
是
Java
私塾
2：系统属性
（1） ：系统属性（System Properties）是Java 提供的另外一种运行时给程序提供参数
的方法。属性（Property）是名字和值之间的映射，这里名字和值都只能是 String。
（2） ：Java有一个类Properties描述了名字和值之间的映射。
System.getProperties 方法返回系统的Properties对象。
System.getProperty(String propertyName)方法返回对应名字属性的值。
System.getProperty(String name，String value)重载方法当没有name 指定
的属性时，返回value 指定的缺省值。
（3） ：每一个 JVM 提供了一组缺省属性，可以通过 System.getProperties 方法的帮助
文档了解到。基本类型的包装类中包含静态方法，用于将属性值转换成对应类型的值。如
Boolean.getBoolean(String); Long.getLong(String)。String 参数这里是属性名字，如
果属性不存在，那么返回false 或null。
（4） ：Properties类的对象包含两个主要方法：
getProperty(String Name)和 getProperty(String Name, String value)方法返
回对应名字属性的值。
properNames()列举系统的一组对象名字，进而可以列举系统的属性值。
例如：
import java.util.Properties;
import java.util.Enumeration;
public class TestProperties{
public static void main(String args[]){
Properties props = System.getProperties();
Enumeration prop_names = props.propertyNames();//这是个早期的集合类
while(prop_names.hasMoreElements()){
String prop_name = (String) prop_names.nextElement();
String property = props.getProperty(prop_name);
System.out.println("Property ‘" + prop_name + "‘ is ‘" +property+"‘");
}
}
}
prop_names是Enumeration是枚举类型的对象，包含一组属性名，允许程序循环列出。
hasMoreElements 方法检测是否还有其它元素， nextElement返回程序的下一个元素。
运行：java -DMyProp=theValue TestProperties
注意：严格的格式 –D后没有空格
运行结果：很多的Java系统级属性，下面列出部分，太多了，你可以把程序运行一下：
Property ‘java.runtime.name‘ is ‘Java(TM) SE Runtime Environment‘
Property ‘sun.boot.library.path‘ is ‘c：\jdk1.6.0_01\jre\bin‘
Property ‘java.vm.version‘ is ‘1.6.0_01-b06‘
Property ‘java.vm.vendor‘ is ‘Sun Microsystems Inc.‘
Property ‘java.vendor.url‘ is ‘http://java.sun.com/‘
。。。。。。
3：控制台输入输出
许多应用程序要与用户进行文本 I/O（输入/输出）交互，标准输入是键盘；标准输出
是终端窗口。Java SDK支持控制台I/O使用三个 java.lang.System 类中定义的变量：
System.out是一个PrintStream对象，初始引用启动 Java 的终端窗口。
Syste.in 是一个InputStream对象，初始指向用户键盘。
System.err是一个PrintStream对象，初始引用启动 Java 的终端窗口。
这三个对象都可以重新定向(如文件)：System.setOut\setIn\setErr。
往标准输出写东西使用 PrintStream对象的 println或 print 方法。print 方法输出参
数；但println方法输出参数并追加一个换行符。
println或print方法都对原始类型进行重载， 同时还重载了char[]和Object， String。
参数是Object时，调用参数的toString方法。
输出例子：
public class Test {
public static void main(String args[]) {
char c[] = { ‘a‘, ‘b‘, ‘c‘ };
System.out.println(c);
}
}
运行结果：abc
输入例子：
public class Test {
public static void main(String args[]) {
String s = "";
InputStreamReader ir = new InputStreamReader(System.in);
BufferedReader in = new BufferedReader(ir);
System.out.println("Ctrl+z to exit");
try {
s = in.readLine();
while (s != null) {
System.out.println("Read:" + s);
s = in.readLine();
}
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行的时候从控制台输入数据，然后回车，就看到具体读入的值的输出了。
这里先看看，涉及到后面要学习的I/O 的知识。
4：格式化输出 printf
从JDK5.0 开始，Java 里面提供了C风格的格式化输出方法 —— printf，
比如输出一个加法算式，JDK5.0版本以前的写法是：
public class Test {
public static void main(String[] args) {
int x = 5;
int y = 7;
int nSum = x + y;
System.out.println(x + " + " + y + " = " + nSum);
}
}
运行结果：5 + 7 = 12
而在JDK5.0以后版本中可以写为：
public class Test {
public static void main(String[] args) {
int x = 5;
int y = 7;
int nSum = x + y;
System.out.printf("%d + %d = %d\n", x, y, nSum);
}
}
以上两种写法的输出结构是一样的，即“5 + 7 = 12” 。
这种改变不仅仅是形式上的，printf 还可以提供更为灵活、强大的输出功能，比如限定
按照两位整数的形式输出，可以写为：
public class Test {
public static void main(String[] args) {
int x = 5;
int y = 7;
int nSum = x + y;
System.out.printf("%02d + %02d = %02d\n", x, y, nSum);
}
}
运行输出结果将是“05 + 07 = 12” 。
其实这个功能在Java 里面并没有什么大用， 具体的 printf格式化字符串格式请参见JDK
文档中的具体说明。
5：属性文件
后缀为“.properties”的文件在Java 中被称为属性文件，是Java 中历史悠久，使用频繁
的配置文件（或者叫资源文件）格式。
属性文件的基本格式为：key=value
Java 提供现成的API来读取properties文件的内容，并进行解析，所以使用非常方便。
运行时候只要把“.properties”文件放到 classpath下就可以了。
示例如下：假设有一个 test.properties如下：
#表示注释
test1=This is Java properties
#默认的properties是不认中文的，需要编码（后面会学到） ，所以这里用英文测试
test2=Welcome to Java World
Java读取
Java 有好几种方法来读取properties文件，这里演示其中一种：
public class Test {
public static void main(String args[]) {
try {
String name = "test.properties";
InputStream in = new BufferedInputStream(new
FileInputStream(name));
Properties p = new Properties();
p.load(in);
System.out.println("test1的值=="+p.getProperty("test1"));
System.out.println("test2的值=="+p.getProperty("test2"));
} catch (Exception err) {
err.printStackTrace();
}
}
}
运行结果：
test1的值==This is Java properties
test2的值==Welcome to Java World
作业
1：设计一个银行帐户类，具有户名，帐号，余额等 属性，以及存款、取款等方法，并对此
类进行测试
2：写一个方法，功能：定义一个一维的 int 数组，长度为 3，把任意三个整数 a,b,c 赋值给
数组,然后将它们按从小到大的顺序输出（使用冒泡排序）
3：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前 20项之和。 (不使
用数学公式，要求用递归)
4：输出一个字符数组中的所有字符的所有组合。比如有字符集 str={A,B,C}。应输出：
A B C AB AC BA BC CA CB ABC ACB BAC BCA CAB CBA
5：已知两个对像String s1,String s2,已用 ASC码排序好了，编写程序将两个 String 合并，得
到的结果。例如：s1="abc" s2="abc" 得 s="aabbcc";结果也是排序的
6：两个乒乓球队进行比赛，各出三人。甲队为 a,b,c 三人，乙队为 x,y,z 三人。已抽签决定
比赛名单。有人向队员打听比赛的名单。a 说他不和 x 比，c 说他不和 x,z 比，请编程序找
出三队赛手的名单。
7：编程：编写一个截取字符串的方法，输入为一个字符串和字节数，输出为按字节截取的
字符串。 但是要保证汉字不被截半个，如"我 ABC"4，应该截为"我 AB"，输入"我 ABC汉
DEF"，6， 应该输出为"我ABC"而不是"我 ABC+汉的半个"。
8：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规
则如下：每位数字都加上5,然后用和除以10 的余数代替该数字，再将第一位和第四位交换，
第二位和第三位交换。请编写一个方法来实现上述加密算法。
9：企业发放的奖金根据利润提成。利润低于或等于 10 万元时，奖金可提 10%；利润高于
10 万元，低于 20 万元时，低于 10 万元的部分按 10%提成，高于 10 万元的部分，可提成
7.5%；20万到40万之间时，高于20万元的部分，可提成 5%；40 万到60 万之间时高于 40
万元的部分，可提成3%；60 万到100万之间时，高于60 万元的部分，可提成 1.5%，高于
100 万元时，超过 100 万元的部分按 1%提成，请编写程序，输入当月利润，求应发放奖金
总数？
10： 老伯伯要带鱼、狗、猫过河到对岸.，有一条船，只能坐一个人，老伯每次只能带一样
动物过河，当老伯不在的时侯狗会咬猫，猫会吃鱼.，请问怎么顺序过河呢？要求：编写程
序，由程序来推出过河的顺序
javaSE 基础笔记之常见类的使用,布布扣,bubuko.com
原文：http://www.cnblogs.com/jemutse/p/3618671.html