第九章、常用类

第九章、常用类

1. Object类

1.1 Java中常用的包

java.lang包  - 该包是java语言的核心包，该包重的所有内容由Java虚拟机自动导入;
            - 如：java.lang.String 类/System类等.......
 
java.util包 - 该包是java语言的工具包，里面提供了大量的工具类和集合等内容。
            - 如：java.util.Scanner类/Random类、Arrays类等....
 
 
java.io包    -  该包是java语言的输入输出包，里面提供了大量读写文件的相关类。
            -  如：java.io.PrintStream/InputStream
 
 
java.net包   -  该包是java语言的网络包，里面提供了大量网络通信相关的类的内容。
            - 如：java.net.ServerSocket类/Socket类等......
 
 
java.lang.reflect 包 - 该包是java语言的反射包，里面提供了一些反射相关的类。
 
 
........

1.2 基本概述

java.lang.Object类是所有类层次结构的根类，任何类都是该类的直接/间接子类。

1.3 常用方法

boolean equals(Object obj) - 用于判断调用对象是否与参数对象相同
    - 该方法默认比较两个对象的地址，与 == 的效果等效
    - 若希望比较对象的内容，则需要进行方法的重写。
    - 若该方法重写了，则应该去重写hasCode()方法，为了满足hasCode()常规协定。
 
 
 
int hashCode() - 用于获取调用对象的哈希码值(内存地址和编号)并返回。
               - 若两个对象调用equals()方法相等，则各自调用该方法得到的哈希码值值必须相同。
               - 若两个对象调用equals()方法不同等，则各自调用改方法的结果可以相同。
                但是最高不相同
 
String toString() - 用于返回调用对象的字符串表现形式。
            - 默认返回字符串是： 包名.类型 @ 哈希码的无符号十六进制形式。
            - 若希望返回其他内容，则需要进行方法的重写。
            - 当使用print()/println()打印引用变量的时候，会自动调用toString()方法
            - 当使用字符串和引用变量进行拼接(+)时，会自动调用toString()方法。
 
 
            可以自动生成toString()方法

2. 包装类

2.1 基本概述

在某些场合要求所有的数据内容都必须是类类型的对象，而Java语言中有8中基本数据类型声明的遍历都不是对象，
为了使得这些数据在该场合中能够使用，则需要进行对象化处理，此时就需要借助包装类将变量包装成对象在进行使用。
 
8个基本数据类型都对应自身的包装类

2.2 Integer类型(重点)

java.lang.Integer类是Object类的间接子类，用于包装int类型的数据。
该类由final关键字修饰，表示该类不能被继承。
 
(1)常用方法
    该类重写了Object类的equals()、hashCode()以及toString()方法
 
    Integer(int value) - 根据参数指定的整数值来构造对象
    Integer(String s)  - 根据参数指定的字符串来构造对象
 
 
    int intValue() - 用于获取调用对象中含有的int类型数据并返回。
                    用于实现将Integer类型拆包为int类型
 
    static Integer valueOf(int i)  - 根据参数指定的整数来得到对象。
                                    用于实现将int类型包装成Integer类型
 
    static int parseInt(String s)  - 用于将字符串类型的数据转换为int类型的整数(掌握)

2.3 装箱和拆箱

由int类型向Integer类型的转换过程，叫做装箱
由Intger类型向int类型的转换过程，叫做拆箱
从jdk1.5开始，支持自动装箱和自动拆箱的机制。

2.3 实例代码

package day14;

// 演示Integer类的使用
public class TestInteger {
	
	public static void main(String[] args) {
		// 使用Integer类中的构造方法来构造对象，该类没有午餐构造方法
		Integer integer1 = new Integer(123);
		// 自动调用toString()方法，得到字符串类型的十进制整数
		System.out.println(integer1);
		
		Integer integer2 = new Integer("456");
		System.out.println(integer2);
		System.out.println("----------------");
		// 实现int类型和Integer类型之间的相互转行
		Integer integer3 = Integer.valueOf(789);
		System.out.println(integer3);// 789 String类型的
		
		int res = integer3.intValue();
		System.out.println(res);// 789 int类型的
		
		System.out.println("-----------------");
		// 实现String类型向int类型的转换
		res = Integer.parseInt("12345");
		System.out.println(res);
		
		// java.lang.NumberFormatException
		// 要求紫福闯中的每个字符都是十进制整数的字符，否则产生数字格式异常
		//res = Integer.parseInt("12345a");
		System.out.println(res);
		
		System.out.println("--------------");
		// 自动装箱和自动拆箱的机制
		Integer integer4 = 100; // int => Integer 发生自动装箱，自动调用valueOf()方法
		res = integer4;			// Integer => int 发生自动拆箱，自动调用intValue()方法
	
		System.out.println("-------------------");
		// 面试比较坑的题
		
/*		Integer integer5 = 128;
		Integer integer6 = 128;
		Integer integer7 = new Integer(128);
		Integer integer8 = new Integer(128);
		
		System.out.println(integer5.equals(integer6)); // true 		比较内容
		System.out.println(integer5 == integer6);      // false		比较地址
		System.out.println(integer7.equals(integer8)); // true 		比较内容
		System.out.println(integer7 == integer8);      // false		比较地址
*/
		Integer integer5 = 127;
		Integer integer6 = 127;
		Integer integer7 = new Integer(127);
		Integer integer8 = new Integer(127);
		
		System.out.println(integer5.equals(integer6)); // true 		比较内容
		System.out.println(integer5 == integer6);      // true		jdk1.5后存在自动装箱池(-128~127)
		System.out.println(integer7.equals(integer8)); // true 		比较内容
		System.out.println(integer7 == integer8);      // false		比较地址
		
		
		System.out.println("-------------------");
		String str1 = "What is Java";
		String str2 = "What is Java";
		System.out.println(str1);
		System.out.println(str2);
		str2 = "what is java";
		System.out.println(str1);
		System.out.println(str2);
		System.out.println("-------------------");
		String s1 = null;
		String s2 = "";
		System.out.println(s1);
		System.out.println(s2);
	}
}

3. String类（重中之重）

3.1 基本概念

java.lang.String类用于描述字符串，可以描述Java程序中的所有字符串字面值 如 "abc"等.
该类描述的字符串内容是个常量，一旦创建完毕之后将不能进行更改。
 
Java为String提供了缓存池机制，当使用双引号定义对象的时候，Java环境首先取字符串缓冲池寻找相同内容的字符串，如果存在
就直接拿过来应用，如果不存在创建一个新的字符串对象放在缓冲池中。
 
比如：
    String s1 = "abc";  - "abc"是个常量，不能更改。
    s1 = "123";         - 并不是改变“abc”字符串的内容，而是改变引用s1的指向。
 
 
 
注意：
    String s1 = null;   String s1 = "";之间有区别吗？？
 
    解析：
        前者表示没有字符串对象，后者表示有字符串对象但是没有内容。

3.2 常用的方法(熟练掌握、记住)

(1)常用的构造方法
    String() - 使用无参构造方式构造对象
    String(byte[] bytes)  - 根据参数指定的byte数组来构造对象
    String(byte[] bytes, int offset, int length)  - 使用参数数组中的一部分来构造对象
    String(String original)  - 根据参数指定的字符串内容来构造对象
    String(StringBuffer buffer)  - 根据参数指定的引用来构造对象
    String(StringBuilder builder)   - 根据参数指定的引用来构造对象
 
(2)常用的成员方法
        char charAt(int index)  - 用于返回参数指定下标位置的字符
        int length()            - 用于返回当前字符串的长度。
 
        int compareTo(String anotherString)
                - 用于比较调用对象和参数对象的字符串大小关系并返回。
                - 使用当前字符串中第一个字符起的每一个字符减去参数字符串中对象位置的字符
                - 若第一个字符不相等则可以代表字符大小的关系，若相等则使用下一个字符继续比较
                - 若存在的字符都相同，则大小取决于长度。
 
 
        如：
            "abc" 和 "bcd"比较大小：由于第一个字符'a'小于'b'，因此字符串"bcd"比较大
            "abc" 和 "abd" 比较大小：由于前两个字符相等，则第三个字符'c'小于'd'，因此"abd"大
            "abc" 和 "abcd"比较大小：由于前面字符相等，则大小取决于字符长度，因此“abcd”大
 
 
        int compareToIgnoreCase(String str) 
                - 用于比较调用对象和参数对象的字符串大小关系并返回。
                - 不考虑大小写，也就是'A'和'a'在该方法中认为是相等的关系。
 
 
        boolean equals(Object anObject)
                - 用于比较字符串内容是否相等并返回。
 
        boolean equalsIgnoreCase(String anotherString)
                - 用于比较字符串内容是否相等并返回,不考虑大小写，如：'A'和'a'是相等                 
 
        案例：
            提示用户输入用户名和密码模拟登录的过程，当用于输入“admin”和“123”的时候，则提示登录成功，否则提示
            登录失败，当用户输入3次之后任然失败，则提示“账户已冻结，明天再试”，要求不考虑大小写。
 
 
    boolean contains(CharSequence s)  - 用于判断调用对象中是否包含参数指定的内容
                                      - 其中参数是接口类型，因此实参传递有两种方式：
                                      a.创建实现类的对象作为实参传递，而String类就是该接口的实现类
                                      b.使用匿名内部类创建接口类型的对象作为实参传递
    boolean endsWith(String suffix) 
                                - 用于判断当前字符串是否以参数指定的内容为结尾
    boolean startsWith(String prefix) 
                                - 用于判断当前字符串是否以参数指定的内容为开头
    String toLowerCase()  - 用于将当前字符串中所有的字符转换为小写并返回
    String toUpperCase()  -  用于将当前字符串中所有的字符转换为大写并返回 
    String trim()   - 用于去除当前字符串中两端的空白字符并返回。
    byte[] getBytes()  - 用于将当前字符串内容转换为byte数组并返回 
    char[] toCharArray()  - 用于将当前字符串内容转换为char数组并返回
    int indexOf(int ch)     - 用于返回当前字符串中参数 ch指定的字符第一次出现的下标
    int indexOf(int ch, int fromIndex)   - 用于从fromIndex位置开始查询ch指定的字符，若查找失败，则返回  -1
    int indexOf(String str)   - 用于查找参数str指定的字符串并返回下标
    int indexOf(String str, int fromIndex)  - 用于从fromIndex位置开始查找
    int lastIndexOf(int ch)    - 用于返回参数 ch指定的字符最后一次出现的下标
    int lastIndexOf(int ch, int fromIndex)      - 用于从fromIndex位置开始查询ch指定的字符出现的下标，反向搜索的第一次，若查找失败，则返回  -1
    int lastIndexOf(String str)     - 用于返回str指定的字符串并最后一次出现的下标
    int lastIndexOf(String str, int fromIndex)   - 用于从fromIndex位置开始反向搜索的第一次
    String substring(int beginIndex)   - 用于获取当前字符串中从 beginIndex 位置开始的子字符串并返回。
     String substring(int beginIndex, int endIndex)   -  用于获取当前字符串中从beginIndex位置开始到endIndex结尾的子字符串并返回。
     boolean matches(String regex)   - 用于判断当前字符串是否满足参数字符串指定的规则。
    
    
    作业：
        1.首先输入学生人数，循环输入班级的学生信息，然后放入Student数组中，并打印所有姓zhang的学生信息。
        要求姓名拼音(不要用汉字),学生所有信息有String格数输入，中间用逗号隔开。
        其中信息有：学号、姓名以及年龄。
 
 
    提示：
        需要查询String类中split()方法进行字符串拆分，实参传递逗号(",")即可。
        Student[] arr = new Student[10];

3.3 示例代码

3.3.1 getBytes和toCharArray方法实例

package day14;

/*
 * 	 byte[] getBytes()    - 用于将当前字符串内容转换为byte数组并返回
 *   byte[] toCharArray() - 用于将当前字符串内容转换为char数字并返回 
 * 
 */
public class TestStringByteChar {

	public static void main(String[] args) {
		// 1.准备一个字符串对象
		String string1 = new String("Good Morning!");
		
		// 2.将该字符串对象转换为char数组并打印
		char[] arr = string1.toCharArray();
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
		
		System.out.println("----------------");
		
		// 3.将字符串对象转换为byte类型的数组对象
		byte[] by = string1.getBytes();
		for (int i = 0; i < by.length; i++) {
			System.out.println(by[i]);
		}
		
		System.out.println("----------------");
		// 4.使用静态方法valueOf将字符串数组转换为String类型
		String string2 = String.valueOf(arr);
		System.out.println(string2);
		
		// 5.使用构造方法将字符串数组转换为String类型
		String string3 = new String(arr);
		System.out.println(string3);
	}
}

3.3.2 CharAt方法实例

package day14;

public class TestStringCharAt {

	public static void main(String[] args) {
		// 使用无参构造来创建对象
		String string1 = new String();
		int len = string1.length();
		System.out.println("len = "+len);
		
		System.out.println("-------------");
		// 使用有参构造来创建对象
		String string2 = new String("hello");
		len = string2.length();
		System.out.println("len = "+len);
		
		System.out.println("-------------");
		// 使用charAt()方法来获取里面的单个字符
		// char cv = string2.charAt(-1); 产生字符串下标越界异常
		char cv = string2.charAt(0);
		System.out.println(cv); // h
		
		cv = string2.charAt(4);
		System.out.println(cv); // o
		System.out.println("-------------");
		
		// 打印字符串中的所有字符
		for(int i=0;i<string2.length();i++){
			System.out.println(string2.charAt(i));
		}
		
		// 课后练习：分别使用两种方式将字符串"12345"转换为整数打印
		// 1.借用于Integer类
	    // 2.去除单个字符利用ASCII进行拆分
	}
}

3.3.3 CompareTo方法实例

package day14;

public class TestStringCompareTo {

	public static void main(String[] args) {
		
		String string1 = new String("abc");
		
		// 调用compareTo()方法实现字符串大小的比较
		System.out.println(string1.compareTo("bcd")); // 负数-1  'a' - 'b'
		System.out.println(string1.compareTo("abe")); // 负数-2  'a' - 'b'
		System.out.println(string1.compareTo("abcdef")); // 负数-3  3 - 6
		
		System.out.println("--------------------");
		// 对应位置的字符串做减法，若所有字符相同则用长度做减法
		System.out.println(string1.compareTo("aaa")); // 正数1  'b' - 'a'
		System.out.println(string1.compareTo("aba")); // 正数2  'c' - 'a'
		System.out.println(string1.compareTo("")); // 正数3  3 - 0
		
		System.out.println("--------------------");
		// 'a' 97  'A' 65
		System.out.println(string1.compareTo("Abc")); // 正数32
		System.out.println(string1.compareToIgnoreCase("Abc")); // 0
		
	}
}

3.3.4 IndexOf方法实例

package day14;

public class TestStringIndexOf {

	public static void main(String[] args) {
		
		// 1.构造字符串对象
		String string1 = new String("Good Good Study,Day Day Up!");
		
		// 2.查找字符串的内容
		// 查找单个字符串在该字符串中的索引位置并返回
		int pos = string1.indexOf("g");
		System.out.println(pos); // -1
		
		pos = string1.indexOf("G");
		System.out.println(pos); // 0
		
		// 从指定位置查询字符出现的下标位置
		pos = string1.indexOf("G",0);
		System.out.println(pos); // 0
		
		pos = string1.indexOf("G",1);
		System.out.println(pos); // 5
		
		System.out.println("------------------");
		
		// 查找字符串在该字符串中首次出现的索引位置并返回
		pos = string1.indexOf("day");
		System.out.println(pos); // -1
		
		pos = string1.indexOf("Day");
		System.out.println(pos); // 16
		
		pos = string1.indexOf("Day",16);
		System.out.println(pos); // 16
		
		pos = string1.indexOf("Day",17);
		System.out.println(pos); // 20
		
		// 当下标不存在并且没有发生异常，而是返回-1
		pos = string1.indexOf("Day",28);
		System.out.println(pos); // -1
		
		
		// 练习：编程实现查找string1中”Day“出现的所有位置并打印出来
		
		System.out.println("--------------");
		
		// 使用lastIndexOf()方法查找该字符最后一次出现的索引位置
		// Good Good Study,Day Day Up!
		pos = string1.lastIndexOf('D');
		System.out.println(pos); // 20
		
		pos = string1.lastIndexOf('D',20);
		System.out.println(pos); // 20

		pos = string1.lastIndexOf('D',19);
		System.out.println(pos); // 16

		pos = string1.lastIndexOf('D',15);
		System.out.println(pos); // -1
		
		System.out.println("----------------");
		// 使用lastIndexOf()方法查找字符串最后一次出现的索引位置,数字表示终点
		// Good Good Study,Day Day Up!
		
		pos = string1.lastIndexOf("Good");
		System.out.println(pos); // 5
		
		pos = string1.lastIndexOf("Good",5);
		System.out.println(pos); // 5
		
		pos = string1.lastIndexOf("Good",4);
		System.out.println(pos); // 0
		
		pos = string1.lastIndexOf("Good",-1);
		System.out.println(pos); // -1
		
		System.out.println("-----------------");
		// 获取当前字符串中指定的下标位置的字符串
		// Good Good Study,Day Day Up!
		String string2 = string1.substring(3);
		System.out.println(string2);
		
		// 包括4 不包括10 顾头不顾尾
		String string3 = string1.substring(4, 10);
		System.out.println(string3);
	}
}

3.3.5 ManyMethod实例

package day14;

public class TestStringManyMethod {

	public static void main(String[] args) {
		
		String string1 = new String("    let me give you some Color see see!");
		
		// 测试String类中相关方法
		// 判断当前字符串中是否包含指定参数的内容，注意大小写
		System.out.println(string1.contains(new String("some"))); // ture
		System.out.println(string1.contains(new String("Some"))); // false 
		
		System.out.println("-------------------");
		// 判断当前字符串是否以let开头，以see!结尾
		System.out.println(string1.startsWith("let"));
		System.out.println(string1.endsWith("see!"));
		
		System.out.println("-------------------");
		// 将当前字符串中所有的字符转换为大写和小写
		String string2 = string1.toUpperCase();
		System.out.println(string2);
		
		String string3 = string1.toLowerCase();
		System.out.println(string3);

		System.out.println("-------------------");
		// 去除当前字符串两端的空表字符
		String string4 = string1.trim();
		System.out.println(string4);
		System.out.println(string1);
	}
}

3.3.6 登录注册实例

package day14;

import java.util.Scanner;

/*
 * 通过equalsIgnoreCase是新年用户登录
 */
public class TestStringLogin {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		// 3.适应for循环来模拟用户3次输入的机会
		for(int i=3;i>0;i--){
			
			// 1.分别提示用户输入用户名和密码信息
			System.out.println("请输入你的账号信息：");
			String username = sc.nextLine();
			
			System.out.println("请输入你的密码信息：");
			String password = sc.nextLine();
			
			// 2.判断用户输入的用户名和密码是否正确，并给出相对应的提示
			// 当字符串面值和字符串变量比较是否相等的时候，推荐使用字符串面值来调用方法
			// 避免发生空指针异常发生
			if("admin".equalsIgnoreCase(username) && "123".equalsIgnoreCase(password)){
				System.out.println("登录成功！");
				break;
			}else {
				// 当用户使用完最后一次机会，则冻结账户
				if(i==1){
					System.out.println("你的第三次机会已用完，明日再来！");
				}else {
					System.out.println("账号或密码错误，你还有"+(i-1)+"次机会！");
				}				
			}		
		}	
	}
}

4. StringBuffer类和StringBuilder类(查询API手册)

4.1 基本概述

由于String类描述字符序列是不可以改变的，因此描述多个类似的字符串需要单独保存，此时内存空间消耗比较大。
为了节省内存空间直接对象字符序列本身进行改变，则使用StringBuffer和StringBuilder。
 
StringBuffer类从jdk1.0开始就存在的，属于线程安全的类，效率比较低。
StringBuilder类从jdk1.5开始出现，属于非线程安全的类，效率比较高，推荐使用该类。

4.2 常用的方法

StringBuilder(String str)  - 根据字符串来构造对象
    - 初始容量为：16 + 字符串参数的长度
    - 该类没有重写equals()和hashCode()方法，但是重写了toString() 方法
 
    int capacity()  - 用于获取当前对象的容量并返回
    int length()    - 用于返回当前对象的字符个数
 
 
StringBuilder insert(int offset, String str) - 用于将str插入到当前字符串中offset的位置并返回。
 
StringBuilder append(String str)   - 用于将str追加到当前字符串的末尾位置
 
tringBuilder delete(int start, int end)   - 用于从当前字符串中将start到end之间的字符串内容移除。
 
StringBuilder replace(int start, int end, String str)   - 用于将当前字符串从中start到end之间的字符串用str替换。
 
StringBuilder reverse() - 用于将当前字符串中的字符序列反转过来
 
 
扩容算法：
使用append追加东西的时候，如果长度超过了字符串存储空间进行扩容，将旧的复制过去。
 
 
 int newCapacity = (value.length << 1) + 2;
 
20
 
0001 0100
 
0010 1000
    32  8  
 
20 * 2
 
    value.length * 2 + 2
 
容量扩大两倍+2  

• 代码示例

  package day14;
  
  import javax.swing.plaf.synth.SynthSpinnerUI;
  
  public class TestStringBuilder {
  
  	public static void main(String[] args) {
  		StringBuilder stringBuilder1 = new StringBuilder("hello");
  		System.out.println(stringBuilder1); // 调用toString()  hello
  		System.out.println("容量："+stringBuilder1.capacity()); // 16+5
  		System.out.println("字符串个数是："+stringBuilder1.length());
  		
  		System.out.println("----------------");
  		// 实现性字符串对象stringBuilder1中插入指定的字符串内容 报错：StringIndexOutOfBoundsException
  		// StringBuilder stringBuilder2 = stringBuilder1.insert(-1, "abcd");
  		
  		// StringBuilder类描述的字符序列本身可以改变
  		StringBuilder stringBuilder2 = stringBuilder1.insert(0, "abcd");
  		System.out.println(stringBuilder2); // abcdhello
  		System.out.println(stringBuilder1); // abcdhello
  		
  		// String类描述的字符序列本身不会改变
  		String str1 = "hello";
  		String str2 = str1.toUpperCase();
  		System.out.println(str1); // hello
  		System.out.println(str2); // HELLO
  		
  		System.out.println("----------------");
  		// 字符串尾部追加内容
  		StringBuilder stringBuilder3 = stringBuilder1.append("worldssssssss");
  		System.out.println(stringBuilder1);
  		System.out.println(stringBuilder3);
  		
  		// 当插入的字符串超过初始容量的时候，则会自动扩大容量
  		System.out.println("容量："+stringBuilder3.capacity()); // 16+5
  		System.out.println("字符串个数是："+stringBuilder3.length());
  		System.out.println("------------------");
  		
  		// 实现字符串内容的删除 "hello"移除
  		stringBuilder1.delete(9, 14);
  		System.out.println(stringBuilder1);
  		
  		System.out.println("----------------");
  		// 实现字符串中内容的修改，"abcd"替换为"ABCD"
  		stringBuilder1.replace(0, 4, "ABCD");
  		System.out.println(stringBuilder1);
  		
  		System.out.println("---------------");
  		// 实现字符串的反转
  		stringBuilder1.reverse();
  		System.out.println(stringBuilder1);
  	
  		System.out.println("---------------");
  		// 实现StringBuilder类型向String类型的转换
  		// String str3 = new String(stringBuilder1);
  		String str3 = stringBuilder1.toString();
  		System.out.println(str3);
  		// 实现String类型向StringBuilder类型的转换
  		StringBuilder str4 = new StringBuilder(str3);
  		System.out.println(str4);
  	}
  }
  

5. 日期相关类

5.1 Date类

(1).基本概念

java.util.Date类用于描述特定的瞬间，可以精确到毫秒。通常描述年月日时分秒信息。

(2).常用方法

Date() - 无参构造方式   ，默认使用当前系统时间来初始化对象
 
Date(long date) - 根据参数指定的毫秒来构造对象。
    - 参数为距离1970 年 1 月 1 日0时0分0秒的毫秒数， 1秒=1000毫秒  1毫秒=1000微妙
    - 该方法与File类中的方法搭配使用很方便。
 
 
long getTime()   -  用于获取调用对象距离1970 年 1 月 1 日0时0分0秒的毫秒数
 
void setTime(long time)   -  根据参数指定的毫秒数来调整对象描述的时间。

(3).代码示例

package day15;

import java.util.Date;


public class TestDate {

	public static void main(String[] args) {
		// 1.使用无参的方法构造对象
		Date date1 = new Date();
		System.out.println(date1); // 自动调用toString()方法  输入系统时间
		
		// 2.使用有参的方法构造对象
		Date date2 = new Date(1000);
		System.out.println(date2); // Thu Jan 01 08:00:01 CST 1970
		
		System.out.println("-----------------");
		// 3.使用有参的方法构造对象
		/*
		 * 		year  - 减1900的年份
		 * 		month - 0-11   之间的月份
		 * 		date  - 月中1-31   之间的某一天
		 *      hrs   - 0-23   之间的小时数
		 *      min   - 0-59  之间的分钟数
		 *      sec   - 0-59  之间的秒数
		 */
		Date date3 = new Date(2008-1900, 8-1, 4,20,8,8);
		System.out.println(date3);
		
		System.out.println("-------------------");
		// 使用getTime()和setTime()方法
		long date4 = date1.getTime();
		System.out.println("当前系统时间距离1970年1月1日0时0分0秒的毫秒数是："+date4);
		
		Date date5 = new Date(date4);
		System.out.println(date5);
		
		date2.setTime(2000);
		System.out.println("date2="+date2);
	}	
}

5.2 SimpleDateFormat类

(1).基本概念

java.text.SimpleDateFormat类用于实现Date类型和String类型之间的转换，调用日期格式

(2).常用方法

SimpleDateFormat(String pattern)   -  根据参数指定的格式来构造对象
    - 参数字符串中格式由： y-年  M-月  d-日   H-时  m-分   s-秒
 
 String format(Date date)  - 用于将Date类型转换为String类型并返回
 
 Date parse(String source)   - 用于将String类型转换为Date类型并返回

(3).代码示例

package day15;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestSimpleDateFormat {

	public static void main(String[] args) throws ParseException {
		
		// 1.按照默认方式打印日期
		Date date1 = new Date();
		System.out.println(date1); // 打印默认格式
		
		// 2.按照指定格式来打印日期
		
		//SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
		// 实现将date1的数值按照sdf的格式来转换为String类型
		String format = sdf.format(date1);
		System.out.println(format);

		// 实现将str的数值按照sdf的格式转换为Date类型
		Date date2 = sdf.parse(format);
		System.out.println(date2);
	}
}

5.3 Calendar类

• 代码示例

  package day15;
  
  import java.text.SimpleDateFormat;
  import java.util.Calendar;
  import java.util.Date;
  
  public class TestCalendar {
  
  	public static void main(String[] args) {
  		// 1.使用过时的Date的构造方法可以传入年月日时分秒信息
  		Date date1 = new Date(2008-1900,8-1,8,20,8);
  		System.out.println(date1);
  		
  		SimpleDateFormat sdf1= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  		String format1 = sdf1.format(date1);
  		System.out.println(format1);
  		
  		
  		System.out.println("-------------------");
  		// 1.获取Calendar类型的对象
  		Calendar calendar = Calendar.getInstance();
  		calendar.set(2008, 8-1, 20, 8, 8);
  		
  		// 2.转换为Date类型的对象
  		Date date2 = calendar.getTime();
  		System.out.println(date2);
  		
  		// 3.按照中国人的习惯打印日期格式
  		SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  		String format2 = sdf2.format(date2);
  		System.out.println(format2);
  		
  		
  		/*
  		 * 练习：
  		 * 		提示用户按照指定格式输入生日信息，计算距离1970年1月1日的天数并打印出来
  		 * 		如输入格式：1998年1月5日
  		 */		
  	}
  }
  

  5.4 作业

  提示用户按照指定格式输入生日信息，计算距离1970年1月1日的天数并打印出来
  	如输入格式：1998年1月5日
  		
  

  package HomeWork;
  
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.Date;
  import java.util.Scanner;
  
  /*
   * 练习：
   * 		提示用户按照指定格式输入生日信息，计算距离1970年1月1日的天数并打印出来
   * 		如输入格式：1998年1月5日
   */
  public class HomeWorkDate {
  
  
  	public static void main(String[] args) throws ParseException {
  		Scanner scanner = new Scanner(System.in);
  		System.out.println("请输入生日信息(格式：xxxx-xx-xx xx:xx:xx)：");
  		String userInfo = scanner.nextLine();
  		System.out.println("用户输入的信息："+userInfo);
  		
  		// 实例化一个时间格式的对象
  		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  		// 将用户输入的时间转换成Date类型的时间对象
  		Date date1 = sdf.parse(userInfo);
  		// 获取转换后的Date对象的时间戳
  		long now = date1.getTime();
  		// 用获取后的时间戳除以每天的毫秒数
  		long dayNumber = now/(24*60*60*1000);
  		System.out.println("标准化时间："+date1);
  		System.out.println("时间戳："+now);
  		System.out.println("距离1970年1月1日"+dayNumber+"天。");
  	}
  }