/core/java/android/app/ContextImpl.java
/core/java/android/app/Instrumentation.java
/core/java/android/app/ActivityThread.java
/core/java/android/app/ActivityTaskManager.java
/core/java/android/app/IActivityTaskManager.aidl

context.startActivity(new Intent(context,XXXActivity.class));//XXXActivity是新页面的类名

public void startActivity(Intent intent, Bundle options) {
        warnIfCallingFromSystemProcess();
        // Calling start activity from outside an activity without FLAG_ACTIVITY_NEW_TASK is
        // generally not allowed, except if the caller specifies the task id the activity should
        // be launched in. A bug was existed between N and O-MR1 which allowed this to work. We
        // maintain this for backwards compatibility.
        final int targetSdkVersion = getApplicationInfo().targetSdkVersion;

        if ((intent.getFlags() & Intent.FLAG_ACTIVITY_NEW_TASK) == 0
                && (targetSdkVersion < Build.VERSION_CODES.N
                        || targetSdkVersion >= Build.VERSION_CODES.P)
                && (options == null
                        || ActivityOptions.fromBundle(options).getLaunchTaskId() == -1)) {
            throw new AndroidRuntimeException(
                    "Calling startActivity() from outside of an Activity "
                            + " context requires the FLAG_ACTIVITY_NEW_TASK flag."
                            + " Is this really what you want?");
        }
  			//mMainThread是ActivityThread的实例，getInstrumentation得到的是Instrumentation的实例
        mMainThread.getInstrumentation().execStartActivity(
                getOuterContext(), mMainThread.getApplicationThread(), null,
                (Activity) null, intent, -1, options);
}

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
  			//mParent也是Activity的实例
        if (mParent == null) {
            //......省略无关代码
          	//调用的还是Instrumentation的execStartActivity方法
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
						//......省略无关代码
        } else {
          	//startActivityFromChild方法最后也会调用到当前方法中
            if (options != null) {
                mParent.startActivityFromChild(this, intent, requestCode, options);
            } else {
                // Note we want to go through this method for compatibility with
                // existing applications that may have overridden it.
                mParent.startActivityFromChild(this, intent, requestCode);
            }
        }
}

public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        IApplicationThread whoThread = (IApplicationThread) contextThread;
       	//......省略
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess(who);
            int result = ActivityTaskManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
}

public class ActivityTaskManager{
  
  	......
  
		/*
		* 通过单例模式获取实例
		*/
    public static IActivityTaskManager getService() {
        return IActivityTaskManagerSingleton.get();
    }

    @UnsupportedAppUsage(trackingBug = 129726065)
    private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
            new Singleton<IActivityTaskManager>() {
                @Override
                protected IActivityTaskManager create() {
                    final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
                    return IActivityTaskManager.Stub.asInterface(b);
                }
            };
  
  	.......
}

//未重写equals版本
public class Person{}

//重写equals版本
public class Person{
    
    private String name;
    
    public Person(String name){
        this.name = name;
    }
    
    public String getName(){
        return name;
    }
    
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(!(obj instanceof Person)){
            return false;
        }
        return Objects.equals(name,obj.getName());
    }
    
}

int a = 1;
int b = 2;
int c = 1;
System.out.println(a == b);//输出false
System.out.println(a == c);//输出true

Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;
System.out.println(p1 == p2);//输出false
System.out.println(p1 == p3);//输出true

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

Person p1 = new Person("小强");
Person p2 = new Person("小强");
Person p3 = new Person("光头强");
System.out.println(p1 == p2);//输出false
System.out.println(p1.equals(p2));//输出true
System.out.println(p1 == p3);//输出false
System.out.println(p1.equals(p3));//输出false

 public boolean equals(Object obj) {
        if (obj instanceof Byte) {
            return value == ((Byte)obj).byteValue();
        }
        return false;
 }

 public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
 }

public boolean equals(Object obj) {
        return (obj instanceof Float)
               && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
}

public boolean equals(Object obj) {
        return (obj instanceof Double)
               && (doubleToLongBits(((Double)obj).value) ==
                      doubleToLongBits(value));
}

public class Object{
    
    ...
    
    /**
     * Returns a hash code value for the object. This method is
     * supported for the benefit of hash tables such as those provided by
     * {@link java.util.HashMap}.
     * <p>
  	 */   
	public native int hashCode();
}

public class Event { 
}

public class Activity extends AppCompatActivity{
  
  @Override
  public void onCreate(Bundle savedInstanceState){
    super.onCreate(savedInstanceState);
    EventBus.getDefault().register(this);//注册订阅者
  }
  
  /*
  * 必须只有一个参数，并且方法访问权限必须是public的，返回值必须是void
  */
  @Subscribe
  public void onEvent(Event event){
    //后续逻辑
  }
  
  @Override
  public void onDestroy(){
    super.onDestroy();
    EventBus.getDefault().unregister(this);//取消当前Activity的订阅，不取消会内存泄漏
  }
  
}

EventBus.getDefault().post(new Event());//步骤二中的onEvent方法将会被调用

public enum ThreadMode{
  //在哪个线程post的的就在哪个线程运行
  POSTING,
  //如果当前运行环境是Android，则运行在主线程，并且onEvent方法运行时会阻塞主线程；如果运行环境是Java则和POSTING一样
  MAIN,
  //运行在主线程，并且按顺序运行
  MAIN_ORDERED,
  //如果当前post时是主线程则运行在后台线程，否则的话运行在当前线程上
  BACKGROUND,
  //总是运行在异步线程
  ASYNC
}

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})//只用于方法上
public @interface Subscribe{
  
  //代表注解的方法运行在哪个线程，默认是那个线程发送的事件那么就在哪个线程运行
  ThreadMode threadMode() default ThreadMode.POSTING;
  
  //是否是粘滞事件，默认不是
  boolean sticky() default false;
  
  //事件优先级
  int priority() default 0;
  
}

public class SubscriberMethod{
  final Method method;//通过反射获取的方法
  final Class<?> eventType;//事件类型
  final ThreadMode threadMode;
  final boolean sticky;
  final int priority;
}

public class Subscription{
  final Object subscriber;//订阅者对象
  final SubscriberMethod subscriberMethod;//订阅方法对象
}

public class EventBus{
  
  //单例对象
  static volatile EventBus defaultInstance;
  //默认建造者
  private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
  //存储Event的类和注册此类型的订阅信息列表的map对象
  private final Map<Class<?>,CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
  //存储订阅者和订阅者注册的所有event的class的map对象，用于取消订阅
  private final Map<Object,List<Class<?>>> typesBySubscriber;
  //粘滞事件（一注册就会收到的那种）
  private final Map<Class<?>,Object> stickyEvents;
  
  public static EventBus getDefault(){
    if(defaultInstance == null){
      synchronized(EventBus.class){
        if(defaultInstance == null){
          defaultInstance = new EventBus();
        }
      }
    }
    return defaultInstance;
  }
  
  public EventBus(){
    this(DEFAULT_BUILDER);
  }
  
}

HashMap<String,String> map = new HashMap<>();//初始化HashMap
map.put("a","hahaha");//把“a”处映射的value设为“hahaha”
String value = map.get("a");//取出key为“a”的数据，此时value就是上面的“hahaha”

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
  static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;//默认的初始容量为16
  static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认负载因子为0.75
  static final int TREEIFY_THRESHOLD = 8;//链表转化为红黑树的容量阈值
  static final int UNTREEIFY_THRESHOLD = 6;//红黑树转化为链表的容量阈值
  //节点数组，用于保存所有的数据,数组的实际容量只能是2的幂次方，每次扩容增长为原来的两倍
  transient Node<K,V> [] table;
  final float loadFactor;//负载因子
  int threshold;//数组扩容的数据量阈值，值等于capacity*loadFactor
  int size;//数据量大小，注意这个不是table的长度，每put一个数据size要加1
  ...
}

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
  //...
  public static class Node<K,V> implements Map.Entry<K,V>{
    final K key;
    V value;
    final int hash;
    Node<K,V> next;
    //其他方法省略，就是一些很普通的针对Object类方法的重写（譬如equals和hashCode）
    ...
  }
}

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
  TreeNode<K,V> parent;
  TreeNode<K,V> left;
  TreeNode<K,V> right;
  TreeNode<K,V> prev;
  boolean red;
  //...其他则是红黑树的一些常用方法
}

Node<K,V> resize(){
  Node<K,V> newTable = table;
  int oldCap = table == null ? 0 : table.size();//获取当前数组容量
  int oldThr = threshold;//获取当前阈值
  int newCap,newThr = 0;//定义新的容量和新的阈值
  if(oldCap > 0){
    newCap = oldCap << 1;//扩容为原来的两倍
    newThr = newCap * loadFactor;//阈值也变为原来的两倍
  }else if(oldThr > 0){
    newCap = oldThr;//这种情况一般是用户初始化HashMap时自己定义了初始容量
  }else{
    //用户使用的是默认构造函数
    newCap = DEFAULT_INITIAL_CAPACITY;
    newThr = newCap * DEFAULT_LOAD_FACTOR;
  }
  if(newThr == 0){
    newThr = newCap * loadFactor;
  }
  threshold = newThr;//重新赋值阈值
  //遍历整个table，做移动数据等操作，这里省略
  return newTable;
}

public V put(K key,V value){
  int hash = hash(key);//通过内部hash方法获取key的hash值
  Node<K,V> p;
  if(table == null || table.length == 0){
    resize();//如果当前数组是null或者数组长度为空则进行扩容
  }
  int index = (table.length-1) & hash;
  p = table[index];//根据hash值找到Node对应的桶，并返回桶中链表的头指针或者红黑树的根节点
  if(p == null){
    //如果当前的桶内没有数据则直接新建一个Node放入桶内
    table[index] = new Node<>(hash,key,value,null);
  }else{
    //当前桶内已经有数据了
    Node<K,V> result;
    if(hash == p.hash && key.equals(p.key)){
      //如果桶内第一个元素的key和当前要找的key是一样的（hash值相等并且key的equals为true），那么说明数据已经找到，只需要把新值赋进去就行
      result = p;
    }else if(p instanceof TreeNode){
      //当前桶内数据结构是红黑树
      result = 红黑树的相关方法;
    }else{
      //当前桶内是一个链表，遍历这个链表找key是当前搜索key的节点，如果
      int count = 0;
      for(int i=0;;i++){
        if((result = p.next) == null){
          result = new Node<hash,key,value,null>;
          if(i >= TREEIFY_THRESHOLD - 1){
            //如果当前链表长度大于规定的阈值则把链表转化为树
            treeifyBin(tab, hash);
          }
          break;
        }
        if(hash == result.hash && key.equals(result.key)){
          //找到对应的数据，直接break
          break;
        }
        p = result;
      }
    }
    if(result != null){
      //当前桶内已经有这个key对应的数据
      V oldValue = result.value;
      result.value = value;//赋新值
      return oldValue;
    }
  }
  //当前桶内没有这个key对应的数据并且如果数据量大于扩容的阈值则进行一次扩容
  if(++size > threshold){
    resize();
  }
  return null;
}

public V get(K key){
  int hash = hash(key);
  int index = (table.length - 1) & hash;//找桶的位置
  Node<K,V> bucket = table[index];
  if(bucket == null){
    //没找到数据，返回null
    return null;
  }else{
    if(bucket.hash == hash && key.equals(bucket.key)){
      //桶内第一个元素就是要找的数据
      return bucket.value;
    }else if(bucket instanceof TreeNode){
      //桶内的数据结构是红黑树
     	...用红黑树的查找方法查找数据并返回值
    }else{
      //桶内数据结构是链表
      ...用链表的查找方法查找数据并返回值
    }
  }
}