Java常用类
一、Object类
java.lang.Object
Object类是Java中所有类的父类，一切类都直接或者间接继承Object类。
native本地，这是一个用C/C++编写的本地方法，运行在本地方法栈。
常见方法
1、public int hashCode()
返回该对象的哈希码值。支持此方法是为了提高哈希表的性能。
2、public String toString()
返回该对象的字符串表示。
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}int hashCode()是Object类自己的方法，运行结果是一个十进制数的哈希值。
toHexString(十进制) 计算结果就是十六进制。
建议Object子类重写Object类的toString()方法，建立自定义的对象字符串
重写的依据：成员变量，做到将类中所有的成员变量连接变成字符串，返回此字符串。
System.out.println(a)实际是System.out.println(a.toString( ))
3、protected void finalize() throws Throwable
JVM启动垃圾回收器前可能调用这个方法。
4、public boolean equals(Object obj)
java认为，所有的对象，都具备比较性，因此Object中，定义了一个比较对象的方法equals。
子类重写equals方法，建立对象的自己的比较方式，不比较内存地址，比较的是对象的成员变量的值。
重写的依据就是类的成员变量。
==和equals的区别：
==比较基本数据类型，比较具体数值是否相等。
== 两边是引用数据类型，比较的是两个对象的内存真实地址。
equals默认情况下，比较的是两个对象的真实地址。
5、protected Object clone() throws CloneNotSupportedException
创建并返回此对象的一个副本。
如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException。
Object 类本身不实现接口 Cloneable
二、String类
java.lang.String
String类的定义方法
第一种： String s = "abc"，创建一个对象s直接指向对象"abc"。
第二种： String s1 = new String("abc")，使用的是String类的构造器，创建两个对象，对象"abc",对象 new String()，变量s1指向的是new String() 。
字符串的特点
实际：public final class String s = “abc”；字符串实际是加final的字符数组。
特点一：不需要new 的对象，直接写双引号，就表示一个字符串对象。
特点二：String前面实际有final修饰，所以字符串是常量，一旦创建，不能改变。
输出字符串的时候，其实输出的就是那个字符数组，但是输出语句println对字符串数组直接遍历，所以看到的是每个字符，不是地址。
"" 和null的区别：""是对象；null是常量，不占内存。
String类的构造方法
空参，byte[]转成String，char[]转成String
1、空参数构造，new String()
2、byte[]转成String，new String(byte[] bytes),查询ASCII编码表。
byte[] b = {97, 98, 99};
// 将字节数组传递给String类的构造器
String s = new String(b);// s = "abc"
3、byte[]一部分转成String，new String(byte[] bytes, int offset, int length)，offset是开始下标，length是获取几个，注意的数组的长度，防止越界异常。
byte[] b = {97, 98, 99, 100, 101, 102};
// 将字节数组传递String构造器，从下标2开始转3个
String s = new String(b, 2, 3);// s = "cde"
4、char[]转成String，new String(char[] value)
char[] ch = {'n', 'v', 'q', '3', 'w', 'a'};
// 将字符数组传递给String构造器
String s = new String(ch);// s = "nvq3wa"5、char[]一部分转成String，new String(char[] value, int offset, int count) ，offset是开始下标，count是获取几个，注意的数组的长度，防止越界异常。
char[] ch = {'n', 'v', 'q', '3', 'w', 'a'};
// 将字符数组传递String构造器，从下标1开始转4个
String s = new String(ch, 1, 4);// s = "vq3w"String的判断方法
equals，equalsIgnoreCase，isEmpty，startsWith，endsWith ，contains，valueOf
1、判断两个字符串是否完全相等，public boolean equals(Object anObject)，重写了Object类的equals
String s1 = "hello";
String s2 = new String("hello");
boolean b = s1.equals(s2);// b = true
String s3 = null;
String s4 = null;// s3 == s4
b = s3.equals(s4);// 空指针异常2、判断两个字符串是否相等，忽略大小写，public boolean equalsIgnoreCase(String anotherString)
String s1 = "hello 汉字 world";
String s2 = "hello 汉字 World";
boolean b = s1.equalsIgnoreCase(s2);// b = true
3、判断一个字符串是不是空串""，public boolean isEmpty()，开始于JDK1.6(包含)。
String s = " ";
boolean b = s.isEmpty();// b = false
4、判断一个字符串是否以另一个字符串开头，public boolean startsWith(String prefix)
5、判断一个字符串是否以另一个字符串结尾，public booleanendsWith(String suffix)，反向查找。
String s = "Demo.java";
boolean b = s.startsWith("Demo.java");// b = true
b = s.endsWith(".java");// b = true6、一个字符串是否包含指定的char值序列，public boolean contains(CharSequence s)，完全包含返回真。
String s = "abcdefg";
// 传递的是接口CharSequence 的实现类对象 String
boolean b = s.contains("cd");// b = ture7、将其他数据类型转成字符串public static String valueOf(O bject obj)
int x = 10;
String s = String.valueOf(x);// s = "10"String类的获取方法
charAt， indexOf， lastIndexOf，substring，length
1、指定下标，返回这个下标上的单个字符，public char charAt(int index)，注意越界异常。
String s = "howareyou";
char ch = s.charAt(2);// ch = 'w'2、指定字符，找这个字符在字符串中第一次出现的下标，public intindexOf(int ch)，如果没有找到，返回-1。
3、指定字符，找这个字符在字符串中第一次出现的下标，public int indexOf(int ch, int fromIndex)，指定开始查找的位置索引。
如果没有找到，返回-1；如果索引过大，不会报越界异常，而是返回负数；如果索引为负数，则索引默认为0开始查找。
String s = "howoldareyou";
int i = s.indexOf('o');// i = 1
i = s.indexOf('o', 5);// i = 104、指定字符串，找字符串在另一个字符串中第一次出现的下标，public int indexOf(String str)
5、指定字符串，找字符串在另一个字符串中第一次出现的下标，public int indexOf(String str, int fromIndex)，指定开始查找的位置。
如果没有找到，返回-1；如果索引过大，不会报越界异常，而是返回负数；如果索引为负数，则索引默认为0开始查找。
String s = "howoldareyou";
int i = s.indexOf("are");// i = 6
i = s.indexOf("are", 7);// i = -16、指定字符，找这个字符在字符串最后一次出现的下标，public int lastIndexOf(int ch)，反向索引，如果没找到，返回-1。
7、指定字符，找这个字符在字符串最后一次出现的下标，public int lastIndexOf(int ch, int fromIndex)，反向索引，指定开始查找的位置，如果没找到，返回-1。
String s = "howoldareyou";
int i = s.lastIndexOf('o');// i = 10
i = s.lastIndexOf('o', 5);// i = 38、指定字符串，找这个字符串在另一个字符串中最后一次出现的下标，public int lastIndexOf(String str)，反向索引，如果没找到，返回-1。
9、指定字符串，找这个字符串在另一个字符串中最后一次出现的下标，public int lastIndexOf(String str, int fromIndex)，反向索引，指定开始查找的位置，如果没找到，返回-1。
10、获取字符串长度，public int length()
11、获取字符串的一部分，public String substring(int beginIndex)，返回新的字符串，从开始下标计算，后面的全要。
String s = "haqapafa";
s = s.substring(2);// s = "qapafa"12、获取字符串的一部分，public String substring(int beginIndex, int endIndex)，返回新的字符串，原始不变，包含头，不包含尾。
String s = "abcdefghijk";
s = s.substring(0, 5);// s = "abcdef"String类的转换方法
getBytes，toCharArray，toLowerCase，toUpperCase，concat，replace
1、将字符串转成字节数组，返回字节数组，public byte[] getBytes(String charsetName) throws UnsupportedEncodingException，查询ASCII表。
String s = "abc";
byte[] b = s.getBytes();// b = {97, 98, 99}2、将字符串转成字符数组，返回字符数组，public char[] toCharArray()，不查询ASCII表。
String s = "to China";
char[] ch = s.toCharArray();// ch = {'t','o',' ','C','h','i','n','a'}3、使用默认语言环境的规则，将字符串全部转成大写字符，返回新字符串，public String toUpperCase()
4、使用默认语言环境的规则，将字符串全部转成小写字符，返回新字符串，public String toLowerCase()
String upper = "AbcHK";
upper = upper.toUpperCase();// upper = "ABCHK"
String lower = "BG6T汉字HwaK@H";
lower = lower.toLowerCase();// lower = "bg6t汉字hwak@h"5、字符串的追加方法 返回新字符串，public Stringconcat(Stringstr)
String s = "abc";
s = s.concat("fg");// s = "abcfg"6、替换字符串，返回新的字符串，public String replace(char oldChar, char newChar)
7、替换字符串，返回新的字符串，public String replace(CharSequence target, CharSequence replacement)
String s = "good bye";
s = s.replace('d', 'Q'); // s = "gooQ bye"
String str = "how do you do";
str = str.replace("do", "while");// str = "how while you while"String类的其他方法
contains，valueOf，split，replace，compareTo，trim
1、切割字符串，public String [] split(String regex)，返回新的字符串数组，如果规则不满足，原始字符串直接装进新的数组的0下标。
String s = "192.168.3.199";
String[] str = s.split("\\.");// str = {"192", "168", "3", "199"}2、安照字典顺序比较两个字符串，public int compareTo(String anotherString)，调用者小于参数，结果是负数；调用者等于参数，结果是0；调用者大于参数，结果是正数。字典顺序，称为自然顺序。
String s1 = "abcd";
String s2 = "bcde";
int num = s1.compareTo(s2);// num = -1,因为a比bASCII码小13、去掉字符串的两端空格 ，返回新字符串，public String trim()
String s1 = " abc def qq ";
String s2 = s1.trim();// s2 = "abc def qq"4、使用指定的格式字符串和参数返回一个格式化字符串，public static String format(String format, Object... args)
// 定义方法实现字符串比较
public static boolean compareTo(String s, String s1) {
if (s == null || s1 == null)
return false;
if (s.isEmpty() && s1.isEmpty())
return true;
if (s.isEmpty() || s1.isEmpty())
return false;
if (s.length() != s1.length())
return false;
char[] ch = s.toCharArray();
char[] ch1 = s1.toCharArray();
for (int i = 0; i < ch.length; i++) {
if (ch[i] != ch1[i])
return false;
}
return true;
} // 定义方法将字符串中的字符进行大小写互转
public static String Conversion(String s) {
if (s == null)
return null;
if (s.isEmpty())
return "";
char[] ch = s.toCharArray();
for (int i = 0; i < ch.length; i++) {
if (ch[i] >= 'A' && ch[i] <= 'Z')
ch[i] += 32;
else if (ch[i] >= 'a' && ch[i] <= 'z')
ch[i] -= 32;
}
return new String(ch);
} // 定义方法判断一个字符串是不是回文
public static void judgeHuiWen(String s) {
if (s == null || s.isEmpty()) {
System.out.println(s + " 不是回文");
return;
}
char[] ch = s.toCharArray();
for (int i = 0, j = ch.length - 1; i < j; i++, j--) {
if (ch[i] != ch[j]) {
System.out.println(s + " 不是回文");
return;
}
}
System.out.println(s + " 是回文");
}三、StringBuffer类
java.lang.StringBuffer
String类固定不变，很浪费内存，运行速度较慢。
StringBuffer是字符串的缓冲区，底层数据结构可变数组(字符)，StringBuffer自己会做数组的扩容，删除原数组，降低资源的浪费，提升速度，提高效率。
StringBuffer类的构造方法
new StringBuffer()，默认创建16个位置的数组。
new StringBuffer(String str)，直接把字符串，装进缓冲区。
StringBuffer类的常见方法
1、将数据追加到缓冲区，public StringBuffer append(Object obj)，返回StringBuffer
// 空的缓冲区，里面默认16位置字符数组
StringBuffer buffer = new StringBuffer();
// 追加数据，用append，方法调用链，链式编程
buffer.append(true).append(false).append('a').append(1.1).append(22);
System.out.println(buffer);// buffer = "truefalsea1.122"2、删除缓冲区中的字符串，public StringBuffer delete(int start, int end)，包含头，不包含尾。
StringBuffer buffer = new StringBuffer();
buffer.append(false).append(234);// buffer = "false234"
buffer.delete(0, 3);// buffer = "se234"3、在缓冲区指定位置插入数据，public StringBuffer insert(int offset,Object obj)，注意越界异常。
StringBuffer buffer = new StringBuffer();
buffer.append(1234567);
// 指定位置下标3,插入数据 www
buffer.insert(3, "www");// buffer = "123www4567"4、修改缓冲区中指定位置的单个字符，public void setCharAt(int index,char ch)，注意越界异常。
StringBuffer buffer = new StringBuffer();
buffer.append(1234567);
// 修改5下标上的内容为Q
buffer.setCharAt(5, 'Q');// buffer = "12345Q7"5、翻转缓冲区，public StringBuffer reverse()
StringBuffer buffer = new StringBuffer();
buffer.append(1234567);
buffer.reverse();// buffer = "7654321"6、将缓冲区中的内容变成字符串，public String toString()，可变对象转成不可变对象。
StringBuffer buffer = new StringBuffer();
buffer.append(1234567);
String s = buffer.toString();// s = "1234567" // 定义方法实现字符串缓冲区翻转功能
public static void reverse(StringBuilder builder) {
char[] ch = builder.toString().toCharArray();
for (int i = 0, j = ch.length - 1; i < j; i++, j--) {
char temp = ch[i];
ch[i] = ch[j];
ch[j] = temp;
}
builder.delete(0, builder.length()).append(ch);
}四、StringBuilder类
Java.lang.StringBuilder
开始于JDK1.5版本，StringBuilder类的方法，以及类的使用方法和StringBuffer完全一致。
区别：
StringBuffer 同步，线程安全，运行速度慢。
StringBuilder 异步，线程不安全，运行速度快。
开发单线程程序，采用StringBuilder
五、基本数据类型对象包装类
一切都是对象，8个基本数据类型，也进行了对象的封装，提供更多的方法和属性，方便操作这些基本数据类型。这些类，全部在java.lang包中。
byte 对应包装类 Byte
short 对应包装类 Short
int 对应的包装类Integer
long 对应的包装类 Long
boolean 对应的包装类 Boolean
float 对应的包装类 Float
double 对应的包装类 Double
char 对应的包装类Character
Integer类
构造方法：
new Integer(int value)
new Integer(String s)
常用方法：将数字格式的字符串，转成基本数据类型int，进行数学计算。
1、将字符串参数解析为有符号的整数，public static int parseInt(String s) throwsNumberFormatException，字符串中的字符必须是十进制数字。
String s = "123";
int i = Integer.parseInt(s);// i = 1232、public static int parseInt(Strings, int radix) throws NumberFormatException，s是要解析的整数表示形式的String，radix是解析s时使用的基数，即进制数。
Integer.parseInt("0", 10);// 返回 0
Integer.parseInt("473", 10);// 返回 473
Integer.parseInt("-0", 10);// 返回 0
Integer.parseInt("-FF", 16);// 返回 -255
Integer.parseInt("1100110", 2);// 返回 102
Integer.parseInt("2147483648", 10);// 抛出 NumberFormatException
Integer.parseInt("99", 8);// 抛出 NumberFormatException
Integer.parseInt("Kona", 10);// 抛出 NumberFormatException
Integer.parseInt("Kona", 27);// 返回 411787其他方法
1、以int类型返回该Integer的值，public int intValue()
Integer i = new Integer("25");
int x = i.intValue();// x = 252、进制转换方法，将十进制转成二进制，八进制，十六进制。
System.out.println(Integer.toBinaryString(175788));// 转成二进制
System.out.println(Integer.toOctalString(20));// 转成八进制
System.out.println(Integer.toHexString(1789));// 转成十六进制3、基本类型转成String对象，public static String toString(int i)
4、public static String toString(int i, int radix)，返回字符串，字符串表示的是i的radix进制，i是十进制。
String s = Integer.toString(3);// s = "3"
String str = Integer.toString(6, 2);// str = "110"自动装箱和拆箱（JDK1.5的新特性）
可以直接让引用类型和基本数据类型进行运算。
自动装箱：基本类型自动包装成对象。
自动拆箱：引用类型自动转变为基本数据类型。
// 进行自动装箱，将基本数据类型，封装成对象
Integer i = 10;// 其实是这样的 ：Integer i = new Integer(10);
if (i != null)
// 引用类型，转变为基本类型，自动拆箱
i = i + 1;// 求和以后，和值赋值给引用变量i ,又是一次自动装箱
取值范围是byte，JVM运行的时候，不会从新开辟内存空间
Integer i = 127;
Integer j = 127;
System.out.println(i == j);// true
System.out.println(i.equals(j));// true六、正则表达式Regex
Java.util.regex
正则表达式，专门处理杂操作的字符串。
弊端：JVM的底层也是通过大量的计算和String类的方法，来实现正则的功能，效率相对较低。
正则表达式的匹配功能
String类方法public boolean matches(String regex)实现，regex就是一个正则表达式。检测字符串和规则是否匹配，完全匹配返回真。
num.matches("[1-9][0-9]{4,10}");// 第一位为1到9，后面4到10位为0到9java.util.Regex.Pattern类，描述了正则怎么写
字符类[abc] 匹配字符是不是abc其中的一个 例：b = s.matches("a[abc]c");
字符类[^abc] 只要不是abc其中一个
字符类[a-zA-Z] 匹配所有的字母
字符类[0-9] 匹配所有的数字
预定义字符 \d 匹配所有数字 例：b = s.matches("a[\\d]c");
预定义字符 \D 匹配所有非数字 例：b = s.matches("a[\\D]c");
预定义单词字符 \w 匹配26个字母大小写，数字和下划线_， 例：[\\w]
预定义单词字符 \W 匹配非26个字母大小写，数字下划线_， 例：[\\W]
数量词 ? 匹配一次或者一次也没有 例：b = s.matches("ac?");
数量词 * 匹配零次、一次或多次 例：b = s.matches("ac*");
数量词 + 一次到多次 例：b = s.matches("ac+"); //前面是ab，后面有多个b
数量词 {n} 恰好n次 例：b = s.matches("ab{3}") //刚好3次
数量词 {n,} 至少n次 例：b = s.matches("ab{3,}") //至少3次
数量词 {n,m} 至少n次，但不超过m次 例：b = s.matches("ab{3,5}") //》3&&《5
例：验证身份证号和qq号
// 18位 第一位123456，最后一个可能有X
boolean b = num.matches("[123456][0-9]{16}[0-9X]");
// 规则 1开头，第二位356874，后面0-9，一共11位
boolean b = num.matches("1[356784][0-9]{9}");正则表达式的切割功能
String类的方法split("正则规则") 返回字符串数组。
正则组：符号()表示一个组，专门处理叠词：aa、11、东东
叠词切割格式：(.)\\1+
String s = "wqqecffffoccccccmrrrrrrrrrrrrrrre";
String[] str = s.split("(.)\\1+");// str = "wecome"正则表达式替换功能
String类的方法public String replaceAll(String regex,String replacement)，replacement替换匹配regex的子字符串。
替换叠词，可以用捕获组$，捕获到组匹配上的叠词中的字符。
String s = "weqqqqlcfffffomekkkkkkktochmmmmmmmina";
s = s.replaceAll("(.)\\1+", "$1");// s = "weqlcfomektochmina" public static void main(String[] args) {
check_Email("[email protected]");
dieCi("北北北北...北..京京京京...欢欢..迎..迎迎迎..迎.你你你...你你你.你");
}
// 验证电子邮件格式
public static void check_Email(String email) {
boolean b = email.matches("[a-zA-Z0-9_]+@[a-z0-9]+(\\.[a-z]+)+");
System.out.println(b);// b = true
}
// 叠词还原
public static void dieCi(String s) {
s = s.replaceAll("\\.+", "");
s = s.replaceAll("(.)\\1+", "$1");
System.out.println(s);// s = "北京欢迎你"
}正则表达式查找功能
在一个字符串中，使用正则表达式，将需要的内容，获取出来。
实现功能，需要2个类的支持，java.util.regex，Pattern和Matcher
实现步骤：
1、正则规则预编译，使用Pattern类方法public static Pattern compile(String regex)，返回Pattern类的本类对象。
2、Pattern类的对象，调用Pattern类的方法public Mathcer matcher(CharSequence input)，将正则规则和查找字符串进行匹配，返回一个Matcher(匹配器)。
3、调用Mathcer类方法public boolean find()，进行查找，找到返回真，找不到返回假。
4、调用Matcher类的方法public String group()，获取查找后结果，返回字符串。
Mathcer类两个方法：start()、end()，返回值都是int，返回获取到的字符串的前后下标，包含头不包含尾。
例：找出字符串中3个字母的单词的内容和前后下标
String s = "father and monther i love you but i can not do something";
String regex = "\\b[a-zA-Z]{3}\\b";// 边界匹配器，\b单词边界
Pattern p = Pattern.compile(regex);// 预编译
Matcher m = p.matcher(s);// 创建匹配器
// 循环查找和获取
while (m.find()) {
System.out.print(m.group());
// System.out.println(m.start()+" "+m.end());前后下标
}
// 结果:andyoubutcannot七、日期类Date
java.util.Date
java.text.Format，抽象类
java.text.DateFormat，抽象类
java.text.SimpleDateFormat
日期和时间也是对象，描述时间和日期。
获取毫秒值都是到1970年1月1日00:00:00的毫秒值。
构造方法
1、new Date()，获取当前操作系统的时间和日期。
2、new Date(long date)，传递long参数，传递毫秒值，返回这个毫秒值对应的那个时间和日期。
Date d = new Date();// 获取当前操作系统的时间和日期
long time = System.currentTimeMillis();// 获取当前系统时间的毫秒值
Date date = new Date(1406859587984l);// d = long型140-41毫秒值对应的时间Date类的常用方法
1、public long getTime()，返回Date对象日期对应的毫秒值。获取当前系统毫秒值，System.currentTimeMillis()。
2、public void setTime(long time)，传递毫秒值，将日期设置到指定毫秒值。
long time = date.getTime();// time = date的时间的毫秒值。
date.setTime(1406859587984L);// 调用setTime方法，传递毫秒值。3、public boolean after(Date when)，测试当前日期是否在参数指定的日期之后，如果是返回真。
4、public boolean before(Date when)，测试当前日期是否在参数指定的日期之前，如果是返回真。
boolean b = d1.after(d2); // 测试d1是不是在d2之后
b = d1.before(d2);// 测试d1是不是在d2之前日期的格式化
显示成国人习惯看的日期格式：2014-01-01 15:31:31
java.text.DateFormat，是抽象类，不能实例化对象。
DateFormat的子类SimpleDateFormat，子类对象调用父类方法format传递日期对象，返回String。
// 传递时间模式：2014-01-01 15:31:31
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH：mm：ss");
String date = sdf.format(new Date());// 调用父类方法format日期的风格化
直接使用抽象父类DateFormat的静态方法，返回子类对象，形成多态。
1、只需要日期，public static final DateFormat getDateInstance(int style)
2、需要日期和时间，public static final DateFormat getDateTimeInstance(int dateStyle, int timeStyle)
DateFormat类中，提供静态常量，直接类名调用LONG，SHORT
// 静态方法getDateTimeInstance获取子类对象，指定风格
DateFormat df = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);
String date = df.format(new Date()); // 调用方法format格式化日期字符串转成日期对象
需要DateFormat类的方法，public Dateparse(String source) throwsParseException
// 静态方法，返回DateFormat类子类对象
DateFormat df = DateFormat.getDateInstance();// 2222-22-22
try {
Date d = df.parse("2014-3-3");
} catch (ParseException e) {
e.printStackTrace();
}例：输入两个日期，计算两个日期相差多少天
Scanner sc = new Scanner(System.in);
System.out.println("输入第一个日期");
String str1 = sc.nextLine();
System.out.println("输入第二个日期");
String str2 = sc.nextLine();
// 获取到DateFormat类的子类对象
DateFormat df = DateFormat.getDateInstance();
// 两个字符串转成Date类型
try {
Date date1 = df.parse(str1);
Date date2 = df.parse(str2);
// 两个日期转成毫秒值
long time1 = date1.getTime();
long time2 = date2.getTime();
// 计算两个毫秒值之差
long timeSpacing = Math.abs(time1 - time2);
System.out.println(timeSpacing / 1000 / 60 / 60 / 24);
} catch (ParseException e) {
e.printStackTrace();
}八、日历类Calendar
java.util.Calendar
描述日历类的对象，抽象类。
从JDK1.1开始，很多Date类的中的方法，被日历类Calendar取代。
直接使用public static Calendar getInstance()获取日历类子类对象。
常用方法
(1)public int get(int field)，返回给定日历字段的值。
// 使用静态方法，获取日历类的子类对象
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
showCalendar(c);
}
// 定义方法，传递日历类对象,格式：2014年11月11日星期三 19点55分55秒
public static void showCalendar(Calendar c) {
System.out.println(c.get(Calendar.YEAR) + "年" + getZero((c.get(Calendar.MONTH) + 1)) + "月"
+ getZero(c.get(Calendar.DAY_OF_MONTH)) + "日 "
+ getWeek((c.get(Calendar.DAY_OF_WEEK) - 1)) + "" + c.get(Calendar.HOUR_OF_DAY)
+ "点" + c.get(Calendar.MINUTE) + "分" + c.get(Calendar.SECOND) + "秒");
}
// 定义方法，实现月份、天数不足2位，补0
private static String getZero(int num) {
if (num < 10)
return "0" + num;
else
return num + "";
}
// 定义方法，数组的查表法，修正星期日的问题
private static String getWeek(int week) {
String[] s = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
return s[week];
}(2)set方法设置日历，如果不设置，日历就是操作系统上的日历。
1、public void set(int field, int value)，field为设置的日历字段，value为具体的数值。
Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR, 2015);// 修改日历的年份为2015年
CalendarDemo.showCalendar(c);2、public final void set(int year, int month, int date)，设置年月日。
Calendar c = Calendar.getInstance();
c.set(2014, 11, 12);// 修改日历，到2014年的12月12日
CalendarDemo.showCalendar(c);3、public final void setTime(Date date)，日历设置为Date对象指定的日期。
4、public void setTimeInMillis(long millis)，设置日历为指定的毫秒值。
5、public abstract void add(int field,int amount)，对日历指定的字段，进行偏移。
Calendar c = Calendar.getInstance();
c.add(Calendar.DAY_OF_MONTH, 15);// 让天数向后偏移15天
CalendarDemo.showCalendar(c);日历小练习
1、判断是不是闰年。
思路：把这一年的3月1日向前偏移1天，为29则是闰年。
Calendar c = Calendar.getInstance();
c.set(2008, 2, 1);// 设置日历，到2008年的3月1日
// 这个日历，向前偏移1天
c.add(Calendar.DAY_OF_MONTH, -1);
System.out.println(c.get(Calendar.DAY_OF_MONTH));2、保质期的计算，条件：生成日期是2014年1月19日，保质期186天。
Calendar c = Calendar.getInstance();
c.set(2014, 0, 19);// 生成日期，2014年1月19日
c.add(Calendar.DAY_OF_MONTH, 186);// 天数偏移186天
CalendarDemo.showCalendar(c);九、Math类
Java.lang.math
数学计算类，方法都是进行数学计算的。
1、伪随机数，Math.random()，返回double 0.0-1.0
2、绝对值，Math.abs()
3、获取两个数中较大的值，Math.max()
4、获取两个数中较小的值，Math.min()
5、向上取整，ceil(double d)获取大于等于该参数的最小整数。
6、向下取整，floor(double d)获取小于等于该参数的最大整数。
7、幂运算，pow(double x,double y)计算x的y次方。
8、四舍五入，round(double d)计算方式是参数+0.5后的结果。
System.out.println(Math.ceil(-11.1));// -11.0
System.out.println(Math.floor(-11.1));// -12.0
System.out.println(Math.pow(2, 5));// 32
System.out.println(Math.round(-1.5));// -1 // 定义方法生成6位不重复的验证码
public static void method() {
char[] ch = { 'a', 's', 'e', 'D', 'Y', 'L', '6', '8', '9', '张', '李', '王' };
Random r = new Random();
StringBuilder builder = new StringBuilder();
while (true) {
int num = r.nextInt(ch.length);
if (builder.toString().contains(ch[num] + ""))
continue;
builder.append(ch[num]);
if (builder.length() == 6)
break;
}
System.out.println(builder.toString());
}十、大数据运算
超级大数，四则运算+ - */使用大数据的运算类方法实现。
java.math.BigInteger
java.math.BigDecimal
BigInteger类
new BigInteger(String val)，val为数字格式，没有位数限制，返回整数类型。
大数据加法运算，BigInteger add(BigInteger big)
大数据减法运算，BigInteger subtract(BigInteger big)
大数据乘法运算，BigInteger multiply(BigInteger big)
大数据除法运算，BigInteger divide(BigInteger big)
BigDecimal类
new BigDecimal(String val) ，val为数字格式，可以写浮点，没有位数限制。
加法，减法，乘法，和BigInteger类一模一样。
大数据除法运算，带浮点返回值BigDecimal divide(BigDecimal divisor, int scale,int roundingMode)，scale为保留几位，roundingMode为舍入模式。
舍入模式在类的静态常量。
常用舍入模式：
ROUND_UP，向上加1
ROUND_HALF_UP，四舍五入
ROUND_DOWN，直接舍去保留位后面的值
ROUND_HALF_DOWN， 向下+1
十一、System类
java.lang.System
1、public static final InputStream in，标准输入流
2、public static final PrintStream out，标准输出流
3、public static void gc()，运行垃圾回收器。
4、public static void exit(int status)，终止JVM的运行，后面的代码不执行，非 0 的状态码表示异常终止。
5、public static long currentTimeMillis()，返回当前时间与协调世界时1970年1月1日午夜之间的毫秒时间差。
6、public static Properties getProperties()，返回当前的系统属性。
十二、Runtime类
java.lang.Runtime
使用public static Runtime getRuntime()，获取Runtime类的对象，不能自己new
在单独的进程中执行指定的字符串命令，public Process exec(String command) throws IOException
// 用记事本打开ArrayDemo.java
Runtime r = Runtime.getRuntime();
try {
Process p = r.exec("notepad E:\\workspace\\ArrayDemo.java");
Thread.sleep(3000);// 延迟3000毫秒
p.destroy();// 杀掉子进程
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}