黑马程序员 Android视频 黑马程序员免费教程

如何使用JDK提供的帮助文档
 1：找到文档，打开文档
 2：点击显示，找到索引，出现输入框
 3：你应该知道你找谁?举例：Scanner
 4：看这个类的结构(需不需要导包)
  注意:如果这个类的包是java.lang; 在使用的使用就不需要导包操作，直接使用
   由于，java.util.Scanner, 不是java.lang 在使用的时候就要导包使用
  

  成员变量 字段摘要
  构造方法 构造方法摘要
  成员方法 方法摘要
  
  
 看这个类的说明
   看构造方法---> 构造方法摘要
   看成员方法---> 方法摘要
 然后使用

Object：
 构造方法：
    Object() 空参数构造方法
 方法：
  protected Object clone()  创建并返回此对象的一个副本
  protected void finalize() 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
  public int hashCode() 返回该对象的哈希码值 
  public final Class getClass()返回此 Object 的运行时类
  public String toString()返回该对象的字符串表示
  public boolean equals(Object obj)指示其他某个对象是否与此对象“相等”。
  
Scanner：
 构造方法：
  public Scanner(InputStream source)
 方法：
  public int nextXxx(Xxx radix):
   获取Xxx类型的键盘录入的数据, Xxx代表各种基本数据类型
  public boolean hasNextXxx():
   判断键盘输入的数据是否为Xxx类型的数据
 
String:
 构造方法：
  public String()： 空参数构造方法
  public String(byte[] bytes) 把字节数组 转换成字符串
  public String(byte[] bytes, int startIndex, int length) 把字节数组一部分 转换成字符串
  public String(char[] value) 把字符数组 转换成字符串
  public String(char[] value, int startIndex, int count)把字符数组一部分 转换成字符串
  public String(String original) 把字符串 转换成 字符串对象
  
 方法：
  判断功能：
    boolean equals(Object obj)：判断两个字符串内容是否相等，重写了Object类中的equals方法
   boolean equalsIgnoreCase(String str):判断两个字符串内容是否相等,忽略大小写
   boolean contains(String str): 判断当前字符串 是否包含 给定的字符串
   boolean startsWith(String str): 判断当前字符串 是否以给定的字符串开头
   boolean endsWith(String str) : 判断当前字符串 是否以给定的字符串结束
   boolean isEmpty(): 判断当前字符串是否为 空字符串   ,  " " 空字符串
 
  获取功能：
  int length() ： 获取当前字符串的长度
  char charAt(int index): 获取当前字符串中，给定索引位置对应的字符
  int indexOf(int ch) : 获取当前字符串中， 给定的字符第一次出现的位置，没有找到返回-1
  int indexOf(String str): 获取当前字符串中， 给定的字符串第一次出现的位置，没有找到返回-1
  int indexOf(int ch,int fromIndex)从指定的位置开始， 获取当前字符串中， 给定的字符第一次出现的位置，没有找到返回-1
  int indexOf(String str,int fromIndex)从指定的位置开始,获取当前字符串中， 给定的字符串第一次出现的位置，没有找到返回-1
  String substring(int start) 从指定的位置开始，截取当前字符串到末尾，返回一个新的字符串
  String substring(int start,int end)从指定位置开始，到指定位置结束，截取当前字符串，返回一个新的字符串
   
  转换功能：
  byte[] getBytes() 把当前字符串 转换成 字节数组 
  char[] toCharArray() 把当前字符串转换成 字符数组
  static String valueOf(char[] chs) 静态方法，把给定的字符数组 转换成字符串
  static String valueOf(int i) 静态方法，把基本数据类型 转换成 字符串
  String toLowerCase() 把当前字符串全部转换为 小写字母
  String toUpperCase() 把当前字符串全部转换为 大写字母
  String concat(String str) 把当前字符串 与 给定的字符串进行 拼接

  替换功能
  String replace(char old,char new) 把当前字符串中，给定的旧字符，用新字符替换
  String replace(String old,String new) 把当前字符串中，给定的旧字符串，用新字符串替换
  
  去除字符串两端空格 
  String trim()
  
  按自然顺序比较两个字符串 
  int compareTo(String str) 比较字符串的大小
  int compareToIgnoreCase(String str)  比较字符串的大小,忽略大小写

<span style="font-size:18px;">package cn.itcast_01_String;
/*
 * 统计大串中小串出现的次数
	举例：在字符串”woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun”中java出现了5次
	
	分析：
		1: 定义字符串

		2：定义变量count，用来记录Java出现的次数 
		
		3：在字符串中找"java"，获取到位置int index =str.indexOf("java")
		
		       找到了(位置不是-1)：
				a: count++
		        b: 截取字符串subString(位置) 
		                   	位置 = index + "java".length()
				c: 将返回的新字符串，覆盖原有字符串
				d: 回到 步骤3 继续
		
		       没找到(位置是 -1)：
				a: 结束循环  
		
		4：打印次数
	
 */
public class StringTest {
	public static void main(String[] args) {
		//1: 定义字符串
		String str = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";//大串
		String key = "java";//小串
		
		//2：定义变量count，用来记录Java出现的次数 
		int count = 0;
		
		while (true) {
			//3：在字符串中找"java"，获取到位置int index =str.indexOf("java")
			int index = str.indexOf(key);
			if (index != -1) {
				 //  找到了java
				count++;
				//位置 = index + "java".length(),将返回的新字符串，覆盖原有字符串
				str = str.substring(index + key.length());
			} else {
				// 没找到(位置是 -1)
				//a: 结束循环  
				break;
			}
		}
		
		//4：打印次数
		System.out.println("java出现的次数： " + count);
		
		
		
		
	}
}
</span>

package cn.itcast_01_String;
/*
 * 统计大串中小串出现的次数(优化版)
	举例：在字符串”woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun”中java出现了5次
	
	分析：
		1: 定义字符串

		2：定义变量count，用来记录Java出现的次数 
		
		3：在字符串中找"java"，获取到位置int index =str.indexOf("java")
		
		       找到了(位置不是-1)：
				a: count++
		        b: 截取字符串subString(位置) 
		                   	位置 = index + "java".length()
				c: 将返回的新字符串，覆盖原有字符串
				d: 回到 步骤3 继续
		
		       没找到(位置是 -1)：
				a: 结束循环  
		
		4：打印次数
	
 */
public class StringTest2 {
	public static void main(String[] args) {
		//1: 定义字符串
		String str = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";//大串
		String key = "java";//小串
		
		//2：定义变量count，用来记录Java出现的次数 
		int count = 0;
		/*
		while (true) {
			//3：在字符串中找"java"，获取到位置int index =str.indexOf("java")
			int index = str.indexOf(key);
			if (index != -1) {
				 //  找到了java
				count++;
				//位置 = index + "java".length(),将返回的新字符串，覆盖原有字符串
				str = str.substring(index + key.length());
			} else {
				// 没找到(位置是 -1)
				//a: 结束循环  
				break;
			}
		}
		*/
		
		//定义一个用来记录位置的变量index
		int index = -1;
		//找java出现的位置
		//把位置赋值给index
		//判断这个index的值 是否为-1, 如果为-1,结束循环
		while ( (index = str.indexOf(key)) != -1  ) {
			// 找到了java
			count++;
			//位置 = index + "java".length(),将返回的新字符串，覆盖原有字符串
			str = str.substring(index + key.length());
		}
		//4：打印次数
		System.out.println("java出现的次数： " + count);
		
		
		
		
	}
}

 

StringBuffer:字符串缓冲区

 特点：StringBuffer 线程安全的类  -- 代码安全 --不会出错 -- 效率低
 
 String 与 StringBuffer的区别？
  String： 长度固定，内容固定
  StringBuffer: 长度可变，内容可变

 构造方法：
 public StringBuffer()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
 public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区。
 public StringBuffer(String data)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
                                                         该字符串的初始容量为 16 加上字符串参数的长度。
 
 方法：
 public int capacity()返回当前容量 （框的容量）
 public int length()返回长度（字符数）。  (框中实际使用的容量)
 public StringBuffer append(String str)追加，在原有数据的基础上，添加新数据

                                                               将指定的参数类型数据[任意类型数据]，添加到当前的字符串缓冲区对象中返回当前字符串缓冲区对象
 public StringBuffer insert(int offset,String str)在指定的位置上，将指定的参数类型数据[任意类型数据]，插入到当前的字符串缓冲区对象中，返回当前字符串缓冲区对象
 public StringBuffer deleteCharAt(int index)把指定位置上的字符，在当前的字符串缓冲区对象中删除，返回当前字符串缓冲对象
 public StringBuffer delete(int start,int end)从指定位置开始，到指定位置结束，在当前的字符串缓冲区对象中删除，返回当前字符串缓冲对象
  包左不包右

<span style="font-size:18px;">public class StringBufferMethod2 {
	public static void main(String[] args) {
		StringBuffer buffer = new StringBuffer();
		
		buffer.append("hello");
		buffer.append("World");
		buffer.append("赵日天");
		buffer.append(12345);
		
		//public StringBuffer deleteCharAt(int index)删除一个字符
		//buffer.deleteCharAt(10);
		
		//public StringBuffer delete(int start,int end)删除指定范围内的字符 ,包左不包右
		buffer.delete(10, 13);
		
		
		//打印
		System.out.println(buffer);
	}
}</span>

 public StringBuffer replace(int start,int end,String str)从指定位置开始，到指定位置结束，用给定的字符串，将字符串缓冲区中的数据替换,返回当前的字符串缓冲区对象
 反转功能 
 public StringBuffer reverse()反转，返回当前的字符串缓冲区对象

<span style="font-size:18px;">public class StringBufferMethod3 {
	public static void main(String[] args) {
		StringBuffer buffer = new StringBuffer();
		
		buffer.append("Hello");
		buffer.append("JavaWeb");
		buffer.append("JavaEE");
		buffer.append("Android");
		
		//public StringBuffer replace(int start,int end,String str)
		buffer.replace(0, 5, "JavaSE");
		
		//public StringBuffer reverse()
		StringBuffer buffer2 = new StringBuffer("123");
		buffer2.reverse();
		
		System.out.println(buffer);
		System.out.println(buffer2);
	}
}
</span>

StringBuffer截取功能
 public String substring(int start)
   从指定位置开始到最后，截取该字符串缓冲区的数据，返回字符串对象
  
  public String substring(int start,int end)
   从指定位置开始到指定位置结束，截取该字符串缓冲区的数据，返回字符串对象
 
 截取功能和前面几个功能的不同
  返回值类型是String类型，本身没有发生改变

public String toString()返回此序列中数据的字符串表示形式。

Arrays类概述
  针对数组进行操作的工具类。
  提供了排序，查找等功能。
 成员方法
  public static String toString(int[] a) 把各种数组 转换为字符串
  public static void sort(int[] a) 把各种数组 进行元素排序
  public static int binarySearch(int[] a,int key) 在各种类型数组中，进行执行数值的查找，折半查找方式(二分查找法)
   注意：该方法的使用，前提要求 给定的数组是一个有序的数组

<span style="font-size:18px;">public class ArraysDemo {
	public static void main(String[] args) {
		int[] arr = {1,5,9,3,7};

		//public static String toString(int[] a) 把各种数组 转换为字符串
		String result = Arrays.toString(arr);
		System.out.println(result);//[1, 5, 9, 3, 7]
		
		//public static void sort(int[] a) 把各种数组 进行元素排序
		Arrays.sort(arr);
		System.out.println("排序后：" + Arrays.toString(arr));//排序后：[1, 3, 5, 7, 9]
		
		//public static int binarySearch(int[] a,int key)
		// 前提要求 给定的数组是一个有序的数组  折半查找方式(二分查找法)
		//int index = Arrays.binarySearch(arr, 7);
		//int index = Arrays.binarySearch(arr, 9);
		//System.out.println("arr数组中9的位置：" + index);
		//int index = Arrays.binarySearch(arr, 0);//-1
		//int index = Arrays.binarySearch(arr, 2);//-2
		int index = Arrays.binarySearch(arr, 4);//-3
		System.out.println("arr数组中4数据对应的位置：" + index);
		
		
	}
}
</span>

Integer类概述
 Integer 类在对象中包装了一个基本类型 int 的值
 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法
 
 字段：
  public static final int MAX_VALUE 最大值
  public static final int MIN_VALUE 最小值Integer类概述
 Integer 类在对象中包装了一个基本类型 int 的值
 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法
 
 字段：
  public static final int MAX_VALUE 最大值
  public static final int MIN_VALUE 最小值Integer类概述
 Integer 类在对象中包装了一个基本类型 int 的值
 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法
 
 字段：
  public static final int MAX_VALUE 最大值
  public static final int MIN_VALUE 最小值

<span style="font-size:18px;">public class IntegerDemo {
	public static void main(String[] args) {
		//10十进制  转换到 其他进制
		String s1 = Integer.toBinaryString(12);//1100
		System.out.println(s1);
		
		System.out.println( Integer.MAX_VALUE );
		System.out.println( Integer.MIN_VALUE );
		
		
	}
}
</span>

Integer构造方法：
 *   public Integer(int value)
 *    构造一个新分配的 Integer 对象，它表示指定的 int 值。
 *    理解为： 把int基本类型数据 封装成 对象
 *
 *   public Integer(String s)
         构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
         理解为： 把多个数字字符 转换为 Integer对象
         
         NumberFormatException: 数字格式化异常：
          该构造方法可能会有问题产生，类型不匹配问题，该方法要的是数字字符串，不能包含其他字符
 */Integer构造方法：
    public Integer(int value)
    构造一个新分配的 Integer 对象，它表示指定的 int 值。 
    理解为： 把int基本类型数据 封装成 对像

   public Integer(String s)
         构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
         理解为： 把多个数字字符 转换为 Integer对象
         
         NumberFormatException: 数字格式化异常：
          该构造方法可能会有问题产生，类型不匹配问题，该方法要的是数字字符串，不能包含其他字符
 

<span style="font-size:18px;">public class IntegerDemo2 {
	public static void main(String[] args) {
		//public Integer(int value)
		Integer in = new Integer( 12345 );
		System.out.println(in.toString());
		
		//public Integer(String s)
		Integer in2 = new Integer("1234567890");
		//Integer in2 = new Integer("hello");//错误
		System.out.println(in2);
	}
}</span>

package cn.itcast_01_Integer;
/*
 * int类型和String类型的相互转换
	int – String
		//方式1 
		 	int值  与 字符串相加
		 	例如: 20 + ""
		 	
		//方式2 构造方法
		 int --> Integer --> String
		 
		 Integer in = new Integer(20);
		 in.toString();
		 
		//方式3 其他方法
		通过Integer类的toString方法
			public static String toString(int i)
		通过String类的valueOf方法
			public static String valueOf(int i)(记住)
	
	String – int
		//方式1： 构造方法
		 	String --> Integer --> int
			Integer类中的构造方法
			public int intValue() 获取到Integer对象中的 int基本类型数据
		//方式2：方法
		 	Integer类中的方法
		 		public static int parseInt(String s) (记住)
		 		public static Integer valueOf(String s)

 */
public class IntegerDemo3 {
	public static void main(String[] args) {
		//int – String
		//方式2 构造方法
		//int --> Integer --> String
		Integer in = new Integer(20);
		System.out.println( in.toString() );
		//方式3 其他方法
		System.out.println(Integer.toString(12345));
		System.out.println(String.valueOf(67890));
		
		
		//String – int
		//方式1： 构造方法
	 	//String --> Integer --> int
		Integer in2 = new Integer("123456");
		int num = in2.intValue();
		System.out.println(num);
		//方式2：方法
		System.out.println( Integer.parseInt("123") );
		System.out.println( Integer.valueOf("1234") );
		
		
		
	}
}

 

<span style="font-size:18px;">package cn.itcast_01_Integer;
/*
 * int类型和String类型的相互转换
	int – String
		//方式1 
		 	int值  与 字符串相加
		 	例如: 20 + ""
		 	
		//方式2 构造方法
		 int --> Integer --> String
		 
		 Integer in = new Integer(20);
		 in.toString();
		 
		//方式3 其他方法
		通过Integer类的toString方法
			public static String toString(int i)
		通过String类的valueOf方法
			public static String valueOf(int i)(记住)
	
	String – int
		//方式1： 构造方法
		 	String --> Integer --> int
			Integer类中的构造方法
			public int intValue() 获取到Integer对象中的 int基本类型数据
		//方式2：方法
		 	Integer类中的方法
		 		public static int parseInt(String s) (记住)
		 		public static Integer valueOf(String s)

 */
public class IntegerDemo3 {
	public static void main(String[] args) {
		//int – String
		//方式2 构造方法
		//int --> Integer --> String
		Integer in = new Integer(20);
		System.out.println( in.toString() );
		//方式3 其他方法
		System.out.println(Integer.toString(12345));
		System.out.println(String.valueOf(67890));
		
		
		//String – int
		//方式1： 构造方法
	 	//String --> Integer --> int
		Integer in2 = new Integer("123456");
		int num = in2.intValue();
		System.out.println(num);
		//方式2：方法
		System.out.println( Integer.parseInt("123") );
		System.out.println( Integer.valueOf("1234") );
		
		
		
	}
}
</span>

<span style="font-size:18px;">Character类概述
 Character 类在对象中包装一个基本类型 char 的值
 此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然
 
 键盘输入字符串，判断该字符串中有多个少大写、小写、数字的个数
 
 方法：
 public static boolean isDigit(char ch)确定指定字符是否为数字。 
 public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
 public static boolean isUpperCase(char ch)确定指定字符是否为大写字母
 
正则表达式：
 正则表达式语法规则：
  字符 （一个字符）
   x 字符 x , x任意字符  
    如：a代表字符a， b代表字符b
   
   \x 转义字符  ,x任意字符 
   \\反斜线字符  ,代表就是一个 \
   \t  制表符  Tab键
   \n 新行（换行）符
   \r 回车符  
   
  字符类(多个字符)
   [abc] 代表 a、b 或 c中的其中一个字符
   [^abc] 任何字符，除了 a、b 或 c（否定） 
   [a-z] 代表 字符a 到 字符z 之间的任意字符
   [a-zA-Z] 代表所有字母中的一个
   [0-9] 代表 0-9之间的一个数字
   
  预定义字符类:
   . 代表任何的一个字符
    就是表示一个.怎么办？ \.  
   
   \w 单词字符：[a-zA-Z_0-9] 
   \d 数字：[0-9] 
   
  边界匹配器
   ^ 行的开头 
   $ 行的结尾  
   \b 单词边界  代表不是单词字符的字符，就是单词边界
    hello java,android!Javaee</span>

<p><span style="font-size:18px;">  Greedy 数量词
   注意： 这里的X 可以代表一个字符，也可以代表一组字符(字符串)</span></p><p><span style="font-size:18px;">   X? 代表X所代表的字符，出现一次或一次也没有 
   X 代表X所代表的字符，出现零次或多次 
   X+ 代表X所代表的字符，出现一次或多次 
   X{n} 代表X所代表的字符，出现恰好 n 次 
   X{n,} 代表X所代表的字符，出现至少 n 次 
   X{n,m} 代表X所代表的字符，出现至少 n 次，但是不超过 m 次 </span></p><p><span style="font-size:18px;">
</span> </p><pre class="java" name="code"><span style="font-size:18px;">package cn.itcast_04_Regex_method;

import java.util.Scanner;

/*
 * 判断功能案例：
	校验邮箱
	
	[e-mail]
	[e-mail]
	[e-mail]
	[e-mail]
	[e-mail]
	
	  左边    @  右边
	[0-9a-z_A-Z]+   @ [0-9a-z_A-Z]+  (\.  [0-9a-z_A-Z]+)+
	
	\\w+ @ \\w+ (\\.\\w+)+  
	  
 */
public class RegexTest {
	public static void main(String[] args) {
		//键盘录入
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入邮箱地址");
		String email = sc.nextLine();
		
		//指定规则
		String regex = "\\w+@\\w+(\\.\\w+)+";
		
		//验证
		boolean flag = email.matches(regex);
		System.out.println(flag);
	}
}</span>

 
 方法：
  public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。
  public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串。
  public String replaceAll(String regex,String replacement)将满足规则的字符串 用给定的字符串替换
  
  
 Pattern:正则表达式对象类： 把正则表达式字符串 封装成了 正则表达式对象
  public static Pattern compile(String regex)将给定的正则表达式编译到模式中。
  public Matcher matcher(CharSequence input)创建匹配给定输入与此模式的匹配器。
  
 Matcher 匹配器类
     通过调用模式的 matcher 方法从模式创建匹配器。创建匹配器后，可以使用它执行三种不同的匹配操作：
   matches 方法尝试将整个输入序列与该模式匹配。
   lookingAt 尝试将输入序列从头开始与该模式匹配。
   find 方法扫描输入序列以查找与该模式匹配的下一个子序列。
  方法：
  public boolean find()尝试查找与该模式匹配的输入序列的下一个子序列。
    find() -- hasNextXxx() -- 判断是否有满足条件的数据
  
  public String group()返回由以前匹配操作所匹配的输入子序列。
    group() -- nextXxx() -- 获取满足条件的数据
  
Math:包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
 
   字段：
    public static final double E比任何其他值都更接近 e（即自然对数的底数）的 double 值。
   public static final double PI比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。
  方法：
    public static double abs(double a) 返回 double 值的绝对值
    public static double cbrt(double a)返回 double 值的立方根
    public static double ceil(double a)返回比double 值大的最小整数
    public static double floor(double a)返回比double 值小的最大整数
    public static double max(double a, double b)返回两个 double 值中较大的一个
    public static long round(double a) 四舍五入， 取整
    public static double sqrt(double a)返回正确舍入的 double 值的正平方根
  

  Random: 随机数类
   此类用于产生随机数
 
  构造方法：
    public Random()创建一个新的随机数生成器对象， 默认的种子是当前系统时间的毫秒值
    public Random(long seed) 使用单个 long 种子创建一个新的随机数生成器。如果种子相同，每次得到随机数相同
 
  方法：
    public int nextInt() int范围内的随机数
   public int nextInt(int n) 在0-n之间的随机数
  
System类概述
  System 类包含一些有用的类字段和方法。它不能被实例化。
 成员方法
  public static void gc() : 运行垃圾回收器
  public static void exit(int status) : 退出正在运行的Java虚拟机
  public static long currentTimeMillis(): 获得当前时间的毫秒值  (1970年1月1日 00:00:00 到当前时间之间的毫秒差值)
  public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)//数组复制

BigInteger类概述
  可以让超过Integer范围内的数据进行运算
 构造方法
  public BigInteger(String val)
  
 方法：
  public BigInteger add(BigInteger val) 加法
  public BigInteger subtract(BigInteger val) 减法
  public BigInteger multiply(BigInteger val) 乘法
  public BigInteger divide(BigInteger val) 除法
  public BigInteger[] divideAndRemainder(BigInteger val) 取商 + 余数 

BigDecimal类概述
  不可变的、任意精度的有符号十进制数。
 构造方法
  public BigDecimal(String val)
  
 方法：
  public BigDecimal add(BigDecimal augend) 加法
  public BigDecimal subtract(BigDecimal subtrahend) 减法
  public BigDecimal multiply(BigDecimal multiplicand) 乘法
  public BigDecimal divide(BigDecimal divisor) 除法
  public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode) 除法，保留指定位数的小数，指定进位方式
  

 
Date: 日期类
 构造方法：
  public Date(): 获取当前系统时间
  public Date(long time): 获取1970年1月1日0点 加上 给定的毫秒值后，所对应的时间

 Date 与 long类型的相互转换
   public void setTime(long time) : 给当前的日期对象，设置时间
    public long getTime() : 获取当前日期对象 距离1970年1月1日0点  的毫秒值
    
DateFormat类概述
  DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。
  是抽象类，所以使用其子类SimpleDateFormat
 SimpleDateFormat构造方法
  public SimpleDateFormat()
  public SimpleDateFormat(String pattern)
 成员方法
  public final String format(Date date) : 将给定的日期对象 转换成 字符串对象
  public Date parse(String source) :将给定的字符串 转换为 日期对象

Calendar类概述
 Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，
  并为操作日历字段（例如获得下星期的日期）提供了一些方法。
    
 成员方法
  public static Calendar getInstance() 通过日历类中的静态方法，返回日历对象
  public int get(int field) : 获取日历对象中的成员
  public void add(int field,int amount) 对日历对象中，指定的成员进行时间调整
  public final void set(int year,int month,int date)// 设置日历 年月日