Object的十二个知识点 ，你记住了吗?

//hotspot的oop.hpp文件中class oopDescclass oopDesc {
  friend class VMStructs;  private:  volatile markOop  _mark; //对象头部分
  union _metadata {  // klassOop 类元数据指针
    Klass*      _klass;  
    narrowKlass _compressed_klass;
  } _metadata;

    public static void main(String[] args){
       Object a = new Object(); // 16B   关闭压缩还是16B，需要是8B倍数;12B+填充的4B
       int[] arr = new int[10]; // 24B   关闭压缩则是16B     }     public class ObjectNum {       //8B mark word       //4B Klass Pointer   如果关闭压缩则占用8B       //-XX:-UseCompressedClassPointers或-XX:-UseCompressedOops，
       int id;        //4B
       String name;   //4B  如果关闭压缩则占用8B
       byte b;        //1B  实际内存可能会填充到4B
       Object o;      //4B  如果关闭压缩则占用8B     }

public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode());}public boolean equals(Object obj) { return (this == obj);}public final void wait(long timeout, int nanos) throws InterruptedException;//都是基于native void wait(long timeout)实现的public final void wait() throws InterruptedException;
wait(long timeout, int nanos)、wait()
//jvm回收对象前，会特意调用此方法 protected void finalize() throws Throwable;

Collections.java//Collections.sort(List<T> list),调用的是List的sort方法public static <T extends Comparable<? super T>> void sort(List<T> list) {
    list.sort(null);
}

List.javadefault void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    Arrays.sort(a, (Comparator) c);
    ListIterator<E> i = this.listIterator();    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}

Arrays.javapublic static <T> void sort(T[] a, Comparator<? super T> c) {    if (c == null) {
        sort(a);
    } else {        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, c);        else
            TimSort.sort(a, 0, a.length, c, null, 0, 0);
    }
}

Arrays.java
......    if (length < INSERTIONSORT_THRESHOLD) {        for (int i=low; i<high; i++)            for (int j=i; j>low &&
                     ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                swap(dest, j, j-1);        return;
    }

@Data
@AllArgsConstructorstatic class Pair implements Comparator<Pair>, Comparable<Pair> {
    Integer one;
    Integer two;
    @Override    public String toString() { return one + "-" + two; }
    @Override    public int compareTo(Pair o) { return one.compareTo(o.one);  }
    @Override    public int compare(Pair o1, Pair o2) {return o1.compareTo(o2);}
}public static void main(String[] args) {
    List<Pair> col = Arrays.asList( new Pair(4, 6), new Pair(4, 2),new Pair(1, 3));
    col.sort(Comparator.reverseOrder());
    col.stream().sorted(Comparator.comparing(Pair::getOne).thenComparing(Pair::getTwo))
            .forEach(item ->  System.out.println(item.toString()) );
}

result:4-6
4-2
1-3
----------------
1-3
4-2
4-6

public class TestEquals {    int i;    public TestEquals() {   i = 0; }    //构造方法重载
    public TestEquals(int i) {   this.i = i }
}

String one = "hello";
    String two = new String("hello");
    String three = one.intern();
    System.out.println(two == one);
    System.out.println(three == one);
    
    result:    false  // one虽然不等于two;但是它们具体的char[] value 还是指向同一块内存的
    true  // one 和 three 引用相同

@Getterstatic class A implements Cloneable{    private B b;
    private int index;    public A(){
        b = new B(); index = 1000;
    }    public A clone()throws CloneNotSupportedException{  return (A)super.clone(); }
}static class B{
}public static void main(String[] args) throws Exception{
    A a = new A();
    A copyA = a.clone();
    System.out.println( a.getIndex() == copyA.getIndex() );
    System.out.println( a.getB() == copyA.getB() );
}
@Getterstatic class A implements Cloneable{    private B b;
    private int index;    public A(){
        b = new B(); index = 1000;
    }    public A clone()throws CloneNotSupportedException{  return (A)super.clone(); }
}static class B{
}public static void main(String[] args) throws Exception{
    A a = new A();
    A copyA = a.clone();
    System.out.println( a.getIndex() == copyA.getIndex() );
    System.out.println( a.getB() == copyA.getB() );
}

//返回结果都是true,引用类型只是复制了引用值truetrue

public A clone() throws CloneNotSupportedException {        try {
            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(byteOut);
            out.writeObject(this);
            ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
            ObjectInputStream inputStream = new ObjectInputStream(byteIn);            return (A) inputStream.readObject();
        } catch (Exception e) {
            e.printStackTrace();            throw new CloneNotSupportedException(e.getLocalizedMessage());
        }
    }