基础篇Object对象

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

Object 的实例数据内存应用三局部组成的，对象头 ， 理论数据区域 、 内存对齐区
对象头布局如下：次要和锁，hashcode，垃圾回收无关；因为锁机制的内容篇幅过长，这里就不多解释了；和锁相干的 markWord（markOop）内存布局如下

内存对齐 区是什么? HotSpot VM 的主动内存管理系统要求对象起始地址必须是 8 字节的整数倍，换句话说就是对象的大小必须是 8 字节的整数倍。因而当对象实例数据局部没有对齐的话，就须要通过对齐填充来补全。
内存对齐 益处
- 有利于内存的治理
- 更快的 CPU 读取，CPU 从内存获取数据，并不是一个个字节的读取，而是按 CPU 能解决的长度获取，如 32 位机，是 4 个字节的内存块；当只需其中两个字节时，则由内存处理器解决筛选。如果须要三个字节散布在两个不同内存块（四字节的内存块），则须要读取内存两次（如果是存在同一内存块只需一次读取）。而当对象按肯定的规定正当对齐时，CPU 就能够起码地申请内存，放慢 CPU 的执行速度
指针压缩
- 在上图能够看到，在 64 位 jvm 里 Object 的 MarkWord 会比 32 位的大一倍；其实 klassOop 也扩充一倍占了 64 位（数组长度局部则是固定四字节）。指针的宽度增大，然而对于堆内存小于 4G 的，如同也用不到 64 位的指针。这能够优化吗？答案是就是指针压缩
- 指针压缩的原理是利用 jvm 植入压缩指令，进行编码、解码
- 哪些信息会被压缩
  - 会被压缩对象：类属性、对象头信息、对象援用类型、对象数组类型
  - 不被压缩对象：本地变量，堆栈元素，入参，返回值，NULL 这些指针
- 指针压缩开启，klassOop 大小能够由 64bit 变成 32bit；对象的大小能够看看上面的具体比照:JVM – 分析 JAVA 对象头 OBJECT HEADER 之指针压缩
```
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
}
```
- 为什么开启指针压缩时，堆内存最好不要超过 32G，指针应用 32 个 bit，为什么最大可应用内存不是 4G 而是 32G

<br/>jvm 要求对象起始地位对齐 8 字节的倍数，能够利用这点晋升选址范畴，实践上能够晋升到 `2^11 * 4G`。不过 jvm 只是将指针左移三位，因而 `2^3 * 4G = 32G`。如果 ** 大于 32G**, 指针压缩会生效。如果 GC 堆大小在 **4G 以下 **，间接砍掉高 32 位，防止了编码解码过程
- 启用指针压缩 `-XX:+UseCompressedOops`(** 默认开启 **)，禁止指针压缩:`-XX:-UseCompressedOops`

本地办法
- private static native void registerNatives() 将 Object 定义的本地办法和 java 程序链接起来。Object 类中的 registerNatives
- public final native Class<?> getClass() 获取 java 的 Class 元数据
- public native int hashCode() 获取对象的哈希 Code
- protected native Object clone() throws CloneNotSupportedException 取得对象的克隆对象，浅复制
- public final native void notify() 唤醒期待对象锁 waitSet 队列中的一个线程
- public final native void notifyAll() 相似 notify(), 唤醒期待对象锁 waitSet 队列中的全副线程
- public final native void wait(long timeout) 开释对象锁, 进入对象锁的 waitSet 队列

一般办法

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;

如不指定排序程序，java 里的默认排序程序是升序的，从小到大

==，(A)对于根本类型之间的比拟是值 (B)根本类型和封装类型比拟也是值比拟 (C)对于援用类型之间的比拟则是内存地址
equals(Object o)，在 Object 根本办法里能够看到public boolean equals(Object obj) {return (this == obj);} 是应用 == 去比拟的。equals 办法的益处是咱们能够重写该办法

Comparable.compareTo 是接口 Comparable 里的形象办法；如果对象实现该接口，可应用 Collections.sort(List< T> col)进行排序。接下来看看源码怎么实现的

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 的 sort 则调用了 Arrays.sort

List.java
default 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);
    }
}

如果 Comparator c 为 null, 则是调用 Arrays.sort(Object[] a)；最终调用 LegacyMergeSort(归并排序)办法解决

Arrays.java
public 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);
    }
}

LegacyMergeSort 办法里的一段代码；最终底层是应用 归并排序 和 compareTo 来排序

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;
    }

Comparator 也是一个接口，不过提供了更丰盛的操作，须要实现 int compare(T o1, T o2) 办法
 Comparator 提供了罕用的几个静态方法 thenComparing、reversed、reverseOrder（操作对象须要实现 Comparator 或者 Comparable）；可配合 List.sort、Stream.sorted、Collections.sort 应用。

@Data
@AllArgsConstructor
static 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());
    System.out.println("----------------");
    col.stream().sorted(Comparator.comparing(Pair::getOne).thenComparing(Pair::getTwo))
            .forEach(item ->  System.out.println(item.toString()) );
}

Collections.sort 默认是升序排序的，能够看到 reverseOrder 将程序反过来了；用了 thenComparing 的 col 则是先判断 Pair::getOne 的大小，如果相等则判断 Pair::getTwo 大小来排序

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

办法的重写是指子类定义和父类办法的 名称、参数及程序统一 的办法；须要留神的是，子类重写办法 修饰符 不能更加严格，就是说父类办法的修饰符是 protected，子类不能应用 private 润饰而可用 public, 抛出的异样也不能比父类办法定义的更广
办法的重载则是同一个类中定义和已有办法的 名称统一而参数或者参数程序不统一 的办法，(返回值不能决定办法的重载)
重载的办法在编译时就可确定(编译时多态)，而重写的办法须要在运行时确定(运行时多态，咱们常说的多态)
 多态的三个必要条件 1、有继承关系 2、子类重写父类办法 3、父类援用指向子类对象

构造方法是每一个类独有的，并不能被子类继承，因为构造方法没有返回值，子类定义不了和父类的构造方法一样的办法。然而在同一个类中，构造方法能够重载

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

equals 是用来比拟两个对象是否相等的，能够重写该办法来实现自定义的比拟办法；而 hashCode 则是用来获取对象的哈希值，也能够重写该办法。当对象存储在 Map 时, 是首先利用 Object.hashCode 判断是否映射在同一地位，若在同一映射位，则再应用 equals 比拟两个对象是否雷同。

如果重写 equals 导致对象比拟雷同而 hashCode 不一样，是违反 JDK 标准的；而且当用 HashMap 存储时，可能会存在多个咱们自定义认为雷同的对象，这样会为咱们代码逻辑埋下坑。

Object.wait 是须要在 synchronized 润饰的代码内应用，会让出 CPU, 并放弃对对象锁的持有状态。而 Thread.sleep 则简略的挂起，让出 CPU, 没有开释任何锁资源

如果对象重写了 finalize 办法，jvm 会把以后对象注册到 FinalizerThread 的 ReferenceQueue 队列中。对象没有其余强援用被当垃圾回收时，jvm 会判断 ReferenceQueue 存在该对象，则临时不回收。之后 FinalizerThread（独立于垃圾回收线程）从 ReferenceQueue 取出该对象，执行自定义的 finalize 办法，完结之后并从队列移除该对象，以便被下次垃圾回收
finalize 会造成对象延后回收，可能导致内存溢出，慎用
finally 和 finalize 区别
- finally 是 java 关键字，用来解决异样的，和 try 搭配应用
- 如果在 finally 之前 return，finally 的代码块会执行吗？ try 内的 continue,break,return 都不能绕过 finally 代码块的执行，try 完结之后 finally 是肯定会被执行的
类似的关键字 final
- final 润饰类，该类不能被继承；润饰办法，办法不能被重写；润饰变量，变量不能指向新的值；润饰数组，数组援用不能指向新数组，然而数组元素能够更改
- 如果对象被 final 润饰，变量有哪几种申明赋值形式？
- fianl 润饰一般变量：1、定义时申明 2、类内代码块申明 3、结构器申明
- fianl 润饰动态变量：1、定义时申明 2、类内动态代码块申明

1、应用 new 创立
2、使用反射获取 Class, 在 newInstance()
3、调用对象的 clone()办法
4、通过反序列化失去，如:ObjectInputStream.readObject()

String one = new String("Hello");

两个对象 和一个 栈变量 ：一个栈变量 one 和一个 new String() 实例对象、一个 ”hello” 字符串对象

题外话:string.intern();intern 先判断常量池是否存雷同字符串, 存在则返回该援用；否则在常量池中记录堆中首次呈现该字符串的援用，并返回该援用。

如果是先执行 String s = "hello" ;相当于执行了 intern(); 先在常量池创立 ”hello”, 并且将援用 A 存入常量池，返回给 s。此时 String(“hello”).intern()会返回常量池的援用 A 返回

    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 援用雷同

援用对象的 赋值复制 是复制的援用对象，A a = new A(); A b = a; 此时 a 和 b 指向同一块内存的对象

应用 Object.clone()办法，如果字段是值类型 (根本类型) 则是复制该值，如果是援用类型则复制对象的援用而并非对象

@Getter
static 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, 援用类型只是复制了援用值
true
true

深复制：重写 clone 办法时应用序列化复制,(留神须要实现 Cloneable，Serializable)

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());
        }
    }

Object 类中的 registerNatives
在 java 中为什么不举荐应用 finalize
一个 Java 对象到底占用多大内存？
java 对象在内存的大小
为什么须要内存对齐以及对齐规定的简略剖析
JVM – 分析 JAVA 对象头 OBJECT HEADER 之指针压缩
几张图轻松了解 String.intern()

基础篇Object对象

1 Object 的内存构造和指针压缩理解一下

2 Object 的几种根本办法

3 ==、equals、Comparable.compareTo、Comparator.compara 四种比拟办法

4 办法的重写和重载

5 构造方法是否可被重写

6 Object 的 equals 和 hashCode

7 equals 一样，hashCode 不一样有什么问题？

8 Object.wait 和 Thread.sheep

9 finalize 办法的应用

10 创建对象有哪几种办法

11 猜猜创建对象的数量

12 对象拷贝问题

关注公众号，大家一起交换

参考文章

Just My Socks（注册教程内含优惠码）

基础篇Object对象

1 Object 的内存构造和指针压缩理解一下

2 Object 的几种根本办法

3 ==、equals、Comparable.compareTo、Comparator.compara 四种比拟办法

4 办法的重写和重载

5 构造方法是否可被重写

6 Object 的 equals 和 hashCode

7 equals 一样，hashCode 不一样有什么问题？

8 Object.wait 和 Thread.sheep

9 finalize 办法的应用

10 创建对象有哪几种办法

11 猜猜创建对象的数量

12 对象拷贝问题

关注公众号，大家一起交换

参考文章

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）