【Java八股文之基础篇（十六）】Object类、String类、equals方法、hashcode方法

Object

概述

在JDK的java.lang包下定义了Object这个类。

​ java中所有的类都直接或者间接的继承Object。所以任意类的对象都可以使用Object中定义的方法。不过方法内部的实现可能在不同的子类中有不同的重写。
​ 我们可以直接使用空参构造创建Object的对象，但是一般我们不会直接创建Object对象，更多的是使用多态的写法。

常用方法

toString方法

取得对象信息，返回该对象的字符串表示。Object的toString方法返回值的是类的全类名和对象hash值的拼接。

内部实现如下：

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

正常情况下Object的toString的返回值对我们是没有什么意义的。所以如果有需要的话我们都会在自己的类中重写toString方法。可以用自动生成，具体实现是拼接各个属性的值。String的重写是返回字符串本身，如：“kplusone”。

getClass方法

方法的具体实现是C++写的，这是一个本地方法。返回值是对象的运行时字节码对象。 这个方法不会被重写。

public final native Class<?> getClass();

hashCode方法

方法的具体实现是C++写的，这是一个本地方法。返回值不是对象的内存地址，有很多生成方法，哈希值的作用是将对象分配到哈希表对应的位置，分配机制是哈希算法。 这个方法String类重写了，一般重写了equals方法，也要把hashCode重写了，这是一种强制规范。这个重写hashCode保证了两个equals返回true的两个字符串，他们的哈希值也是一样的。打消了上一篇博客的顾虑（哈希值不同，但是equals返回true）

public native int hashCode();

JDK8中String类对hashCode()的重写：

equals方法

比较两个对象是否相同。
内部实现如下：

 public boolean equals(Object obj) {
        return (this == obj);
    }

很多情况下判断两个对象是否相同的时候不能单纯的使用==去判断。这种情况下就可以重写equals方法。实现自己的判断逻辑。根据自己的业务需求去重写，比如String类就重写为如果是两个一模一样的字符串就返回true。

String

概述

Java提供的用于描述字符串的类。在JDK的java.lang包下定义了String这个类。在该类中定义了很多我们常用的成员方法，用于对字符串进行常用操作。

对象创建

直接使用字面值

可以直接定义String类型的变量直接给其赋值一个字符串字面值。

String a = "123";

使用构造方法

可以使用String中定义的构造方法来创建对象。String有10多个构造方法。我们就针对其中比较常用的几个进行演示。

String()
String(byte[] bytes)  
String(byte[] bytes, int offset, int length)
String(char[] value)
String(char[] value, int offset, int count)

演示：

public static void main(String[] args) {
		//使用无参构造创建。字符串的内容为空 相当于 ""
        String s1 = new String();
        String s2 = new String("kplusone");
    }

public static void main(String[] args) {
		
        byte[] bytes = {97,98,99};
        String s = new String(bytes);
        System.out.println(s);//输出结果为  abc
    }

public static void main(String[] args) {
        byte[] bytes = {97,98,99};
        String s = new String(bytes,0,2);
        System.out.println(s);//输出结果为ab
        String s2 = new String(bytes,0,1);
        System.out.println(s2);//输出结果为a
    }

 public static void main(String[] args) {
        char[] chars = {'a','b','c'};
        String s = new String(chars);
        System.out.println(s);//输出结果为  abc
    }

public static void main(String[] args) {
        char[] chars = {'a','b','c'};
        String s = new String(chars,0,1);
        System.out.println(s);//输出结果为  a
        String ss = new String(chars,0,2);
        System.out.println(s2);//输出结果为  ab
    }

疑问：String a = "123";   String b = "123";  a==b返回 ？
String a = new String("123"); String b = new String("123"); a==b返回？

答：true false

字符串创建之后不可改变，但可以共享相同内容（常量池）。不管是双引号创建还是new关键字创建，字符串的值存放在常量池中。
private final char value[];//属性被final修饰了，所以改变不了
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
双引号对象在字符串常量池中，只有一个相同对象存在，可以多个变量指向相同对象。
new关键字在堆内存中创建新对象，但还是指向常量池里的值。每new一次将创建一次新对象。

String a =“abc”; String b =new String(“a”); String d =b+“bc”;
System.out.println(d == a); //结果false
变量+双引号常量对象，系统底层会调用StringBuilder方法实现，完成拼接后再转为String，拼接后的对象实际在堆内存中；

String a =“abc”; String b =“a”; String c = b+“bc”;
System.out.println(c == a); //结果true
字符串常量对象拼接，存在常量优化机制，仍在常量池中。

常用方法

String[] split(String regex) 把一个字符串按照指定的分隔符切割成多个字符串，把多个字符串放在一个字符串数组中返回

char[] toCharArray(); 把一个字符串的内容转换成一个字符数组

byte[] getBytes(); 把一个字符串的内容转换成一个byte数组

String substring(int index); 把某个字符串从index索引开始截取到最后

String substring(int begin,int end) 把某个字符串索引begin到索引end截取出来

boolean equals(Object anObject) 判断两个字符串的内容是否相同

split方法演示：

public static void main(String[] args) {
        String s = "kplusone,15,男";
        String[] strs = s.split(",");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
    }

toCharArray方法演示:

public static void main(String[] args) {
        String s = "kplusone,15,男";
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
    }

getBytes方法演示:

public static void main(String[] args) {
        String s = "abcd";
        byte[] bytes = s.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);//97 98 99 100 
        }
    }

substring方法演示:

public static void main(String[] args) {
        String s = "abcd";
        String substring = s.substring(1);
        System.out.println(substring);//bcd
    }

 public static void main(String[] args) {
        String s = "abcd";
        String substring = s.substring(1,2);
        System.out.println(substring);//bc
    }

equals方法演示:

public static void main(String[] args) {
        String s = "abcd";
        String s2 = "abcd";
        boolean flag = s.equals(s2);
        System.out.println(flag);//输出true
    }

特点

1. 一个字符串一旦创建其内容是永远不会变的（说的是常量池里的不会变，都叫常量池了，里面的当然都是final修饰的常量啦）
2. 字符串效果上相当于是char[]字符数组，但是底层其实是byte[]字节数组，就是将二进制编码为字符，常见的编码方法有：ASCII、UTF-8、GBK等。