【 Object类、Date类、Calendar类、System类、StringBuilder类、包装类】

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Sugar_i/article/details/81318948

Object类

定义：
java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

如果一个类没有特别指定父类，那么默认则继承自Object类。比如：

public class MyClass /*extends Object*/ {  
    // ...
}

public String toString()：返回该对象的字符串表示。
public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

直接打印对象名称，得到的是一个“地址哈希值”。
println方法在打印的时候，将会自动调用toSring方法。
注解：

• 1、所有对象都能继承一个toString方法，将自身转换成为字符串形式
  2、如果没有覆盖重写toString，那么使用Object当中默认的toString，也就是拼接地址值。
  3、如果覆盖重写了，那么new的是子类，优先使用子类的toString方法

用法：
-对象名.toString()
-equals如果不重写，默认是进行地址值的比较。
如果子类进行内容比较，不用Object默认equals方法，那么子类就需要：覆盖重写equals方法和hasCode方法

定义实例化对象的时候，使用Alt+Insert快捷键生成toString和equals、hashCode方法

【Person类重写覆盖Object类中的toString、equals、hashCode方法：】

@Override
public String toString() {
   return "Person{" +
           "name='" + name + '\'' +
           ", age=" + age +
           '}';
}

@Override
public boolean equals(Object o) {
   if (this == o) return true;
   if (o == null || getClass() != o.getClass()) return false;
   Person person = (Person) o;
   return age == person.age &&
           Objects.equals(name, person.name);
}

@Override
public int hashCode() {

   return Objects.hash(name, age);
}

【测试类打印：】

Person p1 = new Person("古力娜扎",15);
Person p2 = new Person("古力娜扎",15);

// 重写toString方法后，打印出的不再是一个地址哈希值，而是调用了toString方法
System.out.println(p1); // Person{name='古力娜扎', age=15}
System.out.println(p1.equals(p2)); // true

Objects类

• 在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成
  public static boolean equals(Object a, Object b): 判断两个对象是否相等。

public static void main(String[] args) {
    String a, b; // 定义两个字符串引用对象
    a = "10";
    b = "10";
    boolean b0 = equals(a, b); // 调用Objects的equals方法
    System.out.println(b0); // true
}

public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}

Date类

定义：
java.util.Date类 表示特定的瞬间，精确到毫秒

public Date()：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
public Date(long date)：分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT,也叫作原点时刻）以来的指定毫秒数。
中国大陆的原点时刻：1970年1月1日08:00:00 GMT。

public long getTime()：把日期对象转换成对应的时间毫秒值。

Date date = new Date(); // 获取当前时间
System.out.println(date); // Tue Jul 31 18:29:16 CST 2018

long str =date.getTime();
System.out.println(str); // 获取当前时间的毫秒数，用long数据类型接收

DateFormat类

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

• 格式化：按照指定的格式，从Date对象转换为String对象。
• 解析：按照指定的格式，从String对象转换为Date对象。
  构造方法

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类：
java.text.SimpleDateFormat。
这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

• public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串，代表日期时间的自定义格式。

常用格式：

• yyyy - 公元年份
• MM - 月
• dd - 日
• HH - 小时
• ss - 秒
• SSS - 毫秒

DateFormat类的常用方法有：

• public String format(Date date)：将Date对象格式化为字符串。
• public Date parse(String source)：将字符串解析为Date对象。

// Date --> String类型转换    
Date date = new Date();
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH-mm-s.SSS");
System.out.println(df.format(date)); // 2018-07-31 18-50-6.366


// String --> Date 类型转换 ，需要抛出异常
String dateStr = "2018-10-13";
DateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");

try {
   // 使用parse方法把String类型转换成Date类型
   Date dateTrans = df1.parse(dateStr);
   System.out.println(dateTrans.toLocaleString()); //转换为本地形式 
   // 2018年10月13日 上午12:00:00
}catch (ParseException e){
   e.printStackTrace();
}

Calendar类

ava.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。
获取方式
Calendar为抽象类，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象，如下：
Calendar静态方法

• public static Calendar getInstance()：使用默认时区和语言环境获得一个日历。
  常用方法

Calendar类常用方法：

• public int get(int field)：返回给定日历字段的值。
• public void set(int field, int value)：将给定的日历字段设置为给定值。
• public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
• public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。

Calendar类中提供很多成员常量，代表给定的日历字段：

备注：

 西方星期的开始为周日，中国为周一。
 在Calendar类中，月份的表示是以0-11代表1-12月。
 日期是有大小关系的，时间靠后，时间越大。

System类

java.lang.System包，是一个工具类，本身被final修饰，不能被继承，构造方法被私有化，不能new对象。
这个类只能通过静态形式的调用方法：
public static long currentTime Millis():返回以毫秒为单位的返回值。

// 获取当前时间的毫秒值，从1970年1月1日0时0分0秒开始计算
System.out.println(System.currentTimeMillis()); // 1533187204892

public static void arraycope(Object src, int srcPos, Object dest, int destPos, int length):数组拷贝，将一个数组指定的数据cope到另一个数组中。

public static void main(String[] args) {
    String[] str = {"10", "20", "CF", "CS", "LOL"};
    String[] str1 = {"小胡", "小王", "小李", "老王", "小明"};
    System.arraycopy(str, 2, str1, 1, 3);
    System.out.println(Arrays.toString(str1)); // [小胡, CF, CS, LOL, 小明]
}

注意：
传入的数组长度不能超过接收数组的长度，否则会ArrayIndexOutOfBoundsException

StringBulider类

对于String字符进行拼接的时候：

• 对于n个字符串连接的场景，将会产生n-2个中间过程量，而中间过程量对最后的结果都没用（垃圾），这个过程既耗时，又浪费空间。底层是用StringBuilder实现的。

String str = "a";
str = str+"b"+"c"+"d";
System.out.println(str);
/**在这个过程中：
 * str = "a";
 * str = "ab"+"c"+"d"; // 过程量
 * str = "abc"+"d"; //过程量
 * str = "abcd";
 * */

StringBuilder类位于java.lang.StringBuilder包
StringBuilder是一个字符缓冲区，他是个容器，里面可以装很多个字符串，且可以对其中的字符串操作。
内部是一个数组用来存放字符串内容，进行字符串的拼接时，直接在数组中加入新内容，StringBuilder会自动进行数组扩充。（默认是16字符的空间，超过会自动 2倍 扩充）。

构造方法：
public StringBuilder(): 构造一个空的StringBuilder容器。
public StirngBuilder(String str): 构造一个有参的StringBuilder容器，将字符串传入进去。

StringBuilder sb = new StringBuilder();
System.out.println(sb); // 空
StringBuilder sb1 = new StringBuilder("abcdfg");
System.out.println(sb1); // abcdfg

追加内容：
public StringBuilder append (任意类型的数据)：添加任意类型的数据，并且返回当前对象自身，支持链式调用。

StringBuilder sb = new StringBuilder();
sb.append("AAA");
sb.append("BBB");
sb.append("CCC");
System.out.println(sb); // AAABBBCCC

sb.delete(0, sb.length()); // 清空容器内容
sb.append("ddd").append("fff").append("gggg");
System.out.println(sb); // dddfffgggg

类型转换：String — > StringBuilder：

• 1、public StirngBuilder(String str): 将String类型的直接传入StringBuilder的构造方法。
• 2、成员方法：append后续追加进去也行。
  类型转换：StringBuilder — > String：
  public String toString()：将当前StringBuilder对象转换成String对象。

StringBuilder sb = new StringBuilder();

// String --> StringBuilder 
String str = "aaa";
sb.append(str);
System.out.println(sb); // aaa

// StringBuilder --> String
String str1 = sb.toString();
System.out.println(str1); // aaa

包装类

包装类是引用类型，总共有八中，每一种都与基本类型对应。（Integer与Character比较特殊，其他都是首字母大写即可）

装箱与拆箱：

• 装箱：把基本类型转换成对应的引用类型。
• 拆箱：把引用类型转换成对应的基本类型。

//装箱
Integer i = 100;
System.out.println(i);
Integer ii = new Integer(200); // 此方法已过时
Integer i2 = Integer.valueOf(300);

//两种拆箱
int j = i;
System.out.println(j);

int k =i.intValue();
System.out.println(k);

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

基本类型与字符串之间的转换：

• 基本类型转换成String：
  
  • 基本类型直接与""相连即可，如：""+34(推荐字符串写最前面，因为优先级问题)。
• String转换成对应的基本类型：
  除了Character类之外，其他所有的包装类都具有parseXxx静态方法可以将字符串转换成对应的基本类型：

public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。

public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。

public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。

public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。

public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。

public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。

public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

public static void main(String[] args) {
    int i = Integer.parseInt("100");
    System.out.println(i);
}

注意：如果String转换成基本类型，格式对不上，会发生NumberFormatException异常。