java之常用Object、System类、StringBuilder类和包装类

1 Object类

类是java语言中的根类，即所有类的父类。它描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。
如果没有一个类没有特别指定父类，那么默认继承自Object类。
Object类中常用的两个类为：

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

1.1 toString方法

public String toString():返回该对象的字符串表示。
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

覆盖重写
如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：

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

1.2 equals方法

public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。

调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否相同。这里的“相同”有默认和自定义两种方式。

默认地址比较
如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。

对象内容比较
如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。

 @Override
    public boolean equals(Object o) {
     // 如果对象地址一样，则认为相同
        if (this == o) return true;
        // 如果参数为空，或者类型信息不一样，则认为不同
        if (o == null || getClass() != o.getClass()) return false;
        // 转换为当前类型
        Person person = (Person) o;
          // 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果
        return age == person.age &&
                Objects.equals(name, person.name);
    }

2 System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：
public static long currenTimeMills():返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)将数组中指定的数据拷贝到另一个数组中。

2.1 currentTimeMills方法

实际上，currentTimeMills方法就是获取当前系统时间与1970年01月01日00:00点之间的毫秒值。

2.2 arraycopy方法

public static arraycopy(Object src, int srcPos, Object dest, int destPos, int length):将数组中指定的数据拷贝到另一个数组中。
代码实现如下：

package Demo05;

import java.util.Arrays;

public class Demo01System {
    public static void main(String[] args) {
        demo01();
        demo02();
    }
    public static void demo02(){
        int[] src = {1,2,3,4,5};
        int[] dest = {6,7,8,9,10};
        System.out.println("复制前src数组："+ Arrays.toString(src));
        System.out.println("复制前dest数组："+Arrays.toString(dest));
        System.arraycopy(src,0,dest,0,3);
        System.out.println("复制后src数组："+Arrays.toString(src));
        System.out.println("复制后dest数组："+Arrays.toString(dest));
    }
    public static void demo01(){
        long s = System.currentTimeMillis();
        for (int i = 0; i < 999; i++) {
            System.out.println(i);
        }
        long e = System.currentTimeMillis();
        System.out.println("耗时："+(e-s)+"毫秒");
    }

}

运行结果如下：

3 StringBuilder类

3.1 字符串拼接问题

由于String类的对象内容不可改变，所有每当进行字符串拼接时，总是在内存中创建一个新的对象。例如：

public class StringDemo{
	public static void main(String[] args){
		String s = "Hello";
		s += "World";
		System.out.println(s); 
    }
}

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。
根据这句话分析我们的代码，其实总共产生了三个字符串，即“Hello”、“world”和HelloWorld。引用变量s首先指向Hello对象，最终指向拼接出来的新字符串对象，即Helloworld。

由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为解决这一问题，可以使用java.lang.StringBuilder类。

3.2 StringBuilder概述

StringBuilder又称为可变字符序列，它是一个类似于String的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

原来StringBuilder是个字符串的缓冲区，即是一个容器，容器中可以装很多字符串，并且能够对其中的字符串进行各种操作。

它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容，StringBuilder会自动 维护数组的扩容。原理如下图所示：

构造方法
常用构造方法有两个：
public StringBuilder():构造一个空的StringBuilder容器，其初始容量为 16 个字符。
public StringBuilder(String str):构造一个StringBuilder容器，并将字符串添加进去。

常用方法
public StringBuilder append(...):添加任意类型数据的子字符串形式，并返回当前对象自身。
public String toString():将当前StringBuilder对象转换为String对象。

append方法具有多种重载形式，可以接受任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。

StringBuilder已经覆盖重写了Object当中的toString方法，通过toString方法，StringBuilder对象将会转换为不可变的String对象。

StringBuilder和String可以相互转换:
String->StringBuilder:可以使用StringBuilder的构造方法
StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。
StringBuilder->String:可以使用StringBuilder中的toString方法
public String toString()：将当前StringBuilder对象转换为String对象。

代码运行如下：

package Demo06;
/*
           链式编程:方法返回值是一个对象,可以继续调用方法
        */
public class Demo02StringBuilder {
    public static void main(String[] args) {
        show01();
        show02();
        show03();
    }
    public static void show01(){
        System.out.println("=====show01=====");
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:"+bu1);

        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:"+bu2);
    }
    public static void show02(){
        System.out.println("=====show02=======");
        StringBuilder bu = new StringBuilder();
        bu.append("abc".toUpperCase()).append("ABC").append(10086).append('Y');
        System.out.println(bu);
    }
    public static void show03(){
        System.out.println("========show03=========");
        //String->StringBuilder
        String str = "hello";
        System.out.println("str:"+str);
        StringBuilder bu = new StringBuilder(str);
        bu.append("world");
        System.out.println("bu:"+bu);

        //StringBuilder->String
        String s = bu.toString();
        System.out.println("s:"+s);
    }
}

运行结构如下:

4 包装类

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

4.1 装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

• 装箱：从基本类型转换为对应的包装类对象。
• 拆箱：从包装类对象转换为对应的基本类型。

装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
构造方法:
Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
传递的字符串,必须是基本类型的字符串,否则会抛出异常 “100” 正确 “a” 抛异常
静态方法:
static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。
拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
成员方法:
int intValue() 以 int 类型返回该 Integer 的值。

代码如下：

public class Demo01Integer {
    public static void main(String[] args) {
        //装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
        //构造方法
        Integer in1 = new Integer(1);//方法上有横线,说明方法过时了
        System.out.println(in1);//1 重写了toString方法

        Integer in2 = new Integer("1");
        System.out.println(in2);//1

        //静态方法
        Integer in3 = Integer.valueOf(1);
        System.out.println(in3);

        //Integer in4 = Integer.valueOf("a");//NumberFormatException数字格式化异常
        Integer in4 = Integer.valueOf("1");
        System.out.println(in4);

        //拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
        int i = in1.intValue();
        System.out.println(i);
    }
}

4.2 自动装箱与自动拆箱

/*
    自动装箱与自动拆箱:基本类型的数据和包装类之间可以自动的相互转换
    JDK1.5之后出现的新特性
 */
public class Demo02Ineger {
    public static void main(String[] args) {
        /*
            自动装箱:直接把int类型的整数赋值包装类
            Integer in = 1; 就相当于 Integer in = new Integer(1);
         */
        Integer in = 1;

        /*
            自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本数据类型,在进行计算
            in+2;就相当于 in.intVale() + 2 = 3
            in = in.intVale() + 2 = 3 又是一个自动装箱
         */
        in = in+2;

        ArrayList<Integer> list = new ArrayList<>();
        /*
            ArrayList集合无法直接存储整数,可以存储Integer包装类
         */
        list.add(1); //-->自动装箱 list.add(new Integer(1));

        int a = list.get(0); //-->自动拆箱  list.get(0).intValue();
    }
}

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

基本类型与字符串类型之间的相互转换
基本类型->字符串(String)
1.基本类型的值+"" 最简单的方法(工作中常用)
2.包装类的静态方法toString(参数),不是Object类的toString() 重载
static String toString(int i) 返回一个表示指定整数的 String 对象。
3.String类的静态方法valueOf(参数)
static String valueOf(int i) 返回 int 参数的字符串表示形式。

字符串(String)->基本类型
使用包装类的静态方法parseXXX(“字符串”);
Integer类: static int parseInt(String s)
Double类: static double parseDouble(String s)

public class Demo03Integer {
    public static void main(String[] args) {
        //基本类型->字符串(String)
        int i1 = 100;
        String s1 = i1+"";
        System.out.println(s1+200);//100200

        String s2 = Integer.toString(100);
        System.out.println(s2+200);//100200

        String s3 = String.valueOf(100);
        System.out.println(s3+200);//100200

        //字符串(String)->基本类型
        int i = Integer.parseInt(s1);
        System.out.println(i-10);

        int a = Integer.parseInt("a");//NumberFormatException
        System.out.println(a);
    }
}