Object类和String类的常用方法

Object类

Object类是Java中所有类的父类，也就是所有类的祖宗，所有类都是继承自Object类，所以，在这个类里面，会包含一些所有对象共有的方法。

常用方法：
1) clone

• 定义
  clone方法可以得到一个和原始对象A完全相同新对象B，并且此后对B 任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。
• 说明：
  1. 拷贝对象返回的是一个新对象，而不是一个引用。
  2. 拷贝对象与用 new操作符返回的新对象的区别就是这个拷贝已经包含了一些原来对象的信息，而不是对象的初始信息。
• 用法

class CloneClass implements Cloneable {
    public int aInt;
    public Object clone() {
        CloneClass o = null;
        try {
            o = (CloneClass) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }
}

• 影子clone

package clone;
 
class UnCloneA {
    private int i;
 
    public UnCloneA(int ii) {
        i = ii;
    }
 
    public void doublevalue() {
        i *= 2;
    }
 
    public String toString() {
        return Integer.toString(i);
    }
}
 
class CloneB implements Cloneable {
    public int aInt;
    public UnCloneA unCA = new UnCloneA(111);
 
    public Object clone() {
        CloneB o = null;
        try {
            o = (CloneB) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }
}
 
public class CloneMain {
    public static void main(String[] a) {
        CloneB b1 = new CloneB();
        b1.aInt = 11;
        System.out.println("before clone,b1.aInt = " + b1.aInt); //11
        System.out.println("before clone,b1.unCA = " + b1.unCA);  //111
 
        CloneB b2 = (CloneB) b1.clone();
        b2.aInt = 22;
        b2.unCA.doublevalue();
        System.out.println("=================================");
        System.out.println("after clone,b1.aInt = " + b1.aInt); //11
        System.out.println("after clone,b1.unCA = " + b1.unCA); //222
        System.out.println("=================================");
        System.out.println("after clone,b2.aInt = " + b2.aInt); //22
        System.out.println("after clone,b2.unCA = " + b2.unCA); //222
    }
}

在对b2中b2.aInt进行赋值后，原b1中的b1.aInt的值不会发生改变，而b2.unCA的值会改变，这是因为b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用，所以调用Object类中clone()方法对于基本数据类型来说可以得到新的内存空间而对于引用数据类型来说只是生成了一个新的引用，这种被称为"影子clone"

• 深度clone

package ss;
 
class UnCloneA implements Cloneable {
    private int i;
 
    public UnCloneA(int ii) {
        i = ii;
    }
 
    public void doublevalue() {
        i *= 2;
    }
 
    public String toString() {
        return Integer.toString(i);
    }
 
    public Object clone() {
        UnCloneA o = null;
        try {
            o = (UnCloneA) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }
}
 
class CloneB implements Cloneable {
    public int aInt;
    public UnCloneA unCA = new UnCloneA(111);
 
    public Object clone() {
        CloneB o = null;
        try {
            o = (CloneB) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        o.unCA = (UnCloneA) unCA.clone();
        return o;
    }
}
 
public class CloneMain {
    public static void main(String[] a) {
        CloneB b1 = new CloneB();
        b1.aInt = 11;
        System.out.println("before clone,b1.aInt = " + b1.aInt); //11
        System.out.println("before clone,b1.unCA = " + b1.unCA); //111
 
        CloneB b2 = (CloneB) b1.clone();
        b2.aInt = 22;
        b2.unCA.doublevalue();
        System.out.println("=================================");
        System.out.println("after clone,b1.aInt = " + b1.aInt); //11
        System.out.println("after clone,b1.unCA = " + b1.unCA); 111
        System.out.println("=================================");
        System.out.println("after clone,b2.aInt = " + b2.aInt); //22
        System.out.println("after clone,b2.unCA = " + b2.unCA); //222
    }
}

b1.unCA与b2.unCA指向了两个不同的UnCloneA实例

2) equals

用于判断两个数据是否相等。

• equals 与 == 操作符的区别总结如下：

  • 若 == 两侧都是基本数据类型，则判断的是左右两边操作数据的值是否相等
  • 若 == 两侧都是引用数据类型，则判断的是左右两边操作数的内存地址是否相同。若此时返回 true , 则该操作符作用的一定是同一个对象。
  • Object 基类的 equals 默认比较两个对象的内存地址，在构建的对象没有重写 equals 方法的时候，与 == 操作符比较的结果相同。
  • equals 用于比较引用数据类型是否相等。在满足equals 判断规则的前体系，两个对象只要规定的属性相同我们就认为两个对象是相同的。

public class Test {
     public static void main(String[] args) {
        String a = "abc";
        String b = "abc";
        String c = new String("abc"); 
        String d = new String("abc");
        System.out.println(a==b);//true
        System.out.println(c==d);//false
        System.out.println(a.equals(b));//true
        System.out.println(c.equals(d));//true
        System.out.println(b.equals(d));//true
        System.out.println(a.hashCode()); //96354
        System.out.println(b.hashCode()); //96354
        System.out.println(c.hashCode()); //96354
        System.out.println(d.hashCode()); //96354
    }
}

3) hashCode

- 作用
为了配合基于散列的集合会根据对象的hashCode返回值来初步确定对象在容器中的位置,然后内部再根据一定的 hash 算法来实现元素的存取。这样的散列集合包括HashSet、HashMap以及HashTable。

不能根据hashcode值判断两个对象是否相等，但是可以直接根据hashcode值判断两个对象不等，如果两个对象的hashcode值不等，则必定是两个不同的对象。

4) getClass
在Java中获得类名的方法,getClass() 是一个类的实例所具备的方法，而class() 方法是一个类的方法。getClass() 是在运行时才确定的，而class() 方法是在编译时就确定了。

class A{
    public void func(){

    }
}

class B extends A{

}
public class Test {

    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        A ab = new B();
        System.out.println(a.getClass()+" "+A.class); //class A class A
        System.out.println(b.getClass()+" "+B.class); //class B class B
        System.out.println(ab.getClass()); //class B
        ab = a;
        System.out.println(ab.getClass()); //class B
    }

}

5) toString

该方法返回的是该Java对象的内存地址经过哈希算法得出的int类型的值在转换成十六进制。这个输出的结果可以等同的看作Java对象在堆中的内存地址。

public class Test {
    public static void main(String[] args) {

        Object o1 = new Object();
        System.out.println(o1.toString()); //java.lang.Object@16d3586
    }

}

String类

常用方法：

1) compareTo

按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。如果这两个字符串相等，则结果为 0；compareTo 只在方法 equals(Object) 返回 true 时才返回 0。

字典排序：如果这两个字符串不同，那么它们要么在某个索引处的字符不同（该索引对二者均为有效索引），要么长度不同，或者同时具备这两种情况。如果它们在一个或多个索引位置上的字符不同，假设 k 是这类索引的最小值；则在位置 k 上具有较小值的那个字符串（使用 < 运算符确定），其字典顺序在其他字符串之前。在这种情况下，compareTo 返回这两个字符串在位置 k 处两个char 值的差，即值：

 this.charAt(k)-anotherString.charAt(k)

举例：

public class Test {
    public static void main(String[] args) {
        String a="abc";
        String b="abc";
        String c="abcde";
        String d="abbcde";

        System.out.println(a.compareTo(b)); //0
        System.out.println(a.compareTo(c)); //-2
        System.out.println(a.compareTo(d)); //1
        
    }
}

2) concat方法

连接两个String类型数据，不会改变原数据

public class Son1 extends Father1 {
    public static void main(String[] args) {
        String a = "abc";
        String b = "bc";
        String c = a.concat(b);
        System.out.println(a); //abc
        System.out.println(b); //bc
        System.out.println(c); //abcbc

    }
}

3) join方法

将一个数组或者List的各项通过分隔符连接成字符串

public class Son1 extends Father1 {
    public static void main(String[] args) {

        String[] a = {"abc","ef","gh"};
        List<String> listStr = new LinkedList<String>();
        listStr.add("a");
        listStr.add("b");
        listStr.add("c");
        String b = String.join("",listStr); //连接List为字符串，没有分隔符
        String c = String.join(",",a); //连接Array为字符串，以逗号为分隔符
        System.out.println(b); //abc
        System.out.println(c); //abc,ef,gh

    }
}