>>>>>>java中的原码，反码和补码以及~运算符理解
java中，正数的原码，反码和补码是一样的，
负数的反码为原码取反（符号位不变），负数的补码是反码加1，
比如，-10的原码是1000 1010，反码就是1111 0101，补码就是1111 0110，
~3运算过程：3的原码是0000 0011，~的意思是取反就是1111 1100，这个得到的是补码，然后转反码就是补码减1得到1111 1011，再取反得到原码（符号位不变）为1000 0100，也就是-4
>>>>>>java虚拟机和android的dalvik虚拟机、ART
JVM和Dalvik:
1）可执行程序的字节码不同，JVM是java字节码（.class文件），dalvik是dalvik字节码（.dex文件）；
2）JVM基于栈架构，dalvik基于寄存器架构，dalvik速度比JVM更快；
3）.class文件一般对应一个类，.dex一般对应大量类，dalvik对于各类中重复的字符串和常量进行了优化处理，减少了整个文件的体积，使IO读取速度加快
dalvik和ART
dalvik是在运行时通过JIT把dalvik字节码即时编译成机器码来运行的，而ART在7.0之前都是在安装的时候通过AOT把dalvik字节码全部转化为机器码的，这样在运行速度、电量消耗等都有很大提升；ART在7.0之后，在安装的时候也不会对dalvik字节码进行转化，而是在应用运行的时候通过JIT先把最常用的部分编译成机器码，并生成一个profile文件，然后，在应用空闲的时候定时的通过AOT把其他的部分编译成机器码并实时更新profile文件。
>>>>>>java中的几种算法：冒泡、快排、选择、插入
冒泡排序：依次比较对相邻元素进行比较，大的后移，小的前移
int[] arr = {....};
int tamp = 0;
for ( int i = 0;i < arr.length- 1;i++ ) {
for ( int j = 0;j < arr.length- 1 - i ; j++ ) {
if(arr[j] > arr[j+1]){
tamp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tamp;
}
}
}
选择排序：从待排的元素中选出一最小元素作为首元素
int[] arr = {....};
int min_index = 0;
for(int i=0;i<arr.length;i++){
min_index = i;
for(int j=i+1;j<arr.length;j++){
if(arr[j] < arr[min_index]){
min_index = j;
}
}
if(min_index != i){
arr[i] ^= arr[min_index];
arr[min_index] ^= arr[i];
arr[i] ^= arr[min_index];
}
}
插入排序：依次取出待排序的元素，插入到已排好序的序列中。
int[] arr = {9,0,3,7,8,2,3,6,5};
for (int i = 1; i < arr.length; i++) {
for (int j = i; j > 0 && arr[j - 1] > arr[j]; j--) {
arr[j] ^= arr[j - 1];
arr[j - 1] ^= arr[j];
arr[j] ^= arr[j - 1];
}
}
>>>>>>java泛型
为啥需要泛型：功能复用，风险前移
什么是泛型：为了参数化类型，即将类型当做参数传给类、方法。
类型擦除：为了兼容低版本JDK，泛型只在编译期起作用，在运行期是没有泛型概念的。造成的问题是可以通过反射绕过编译器检查。
运行时如何获取泛型信息：类定义
List<User> users = new ArrayList<User>(){};//注意这里的双大括号
Type type = users.getClass().getGenericSuperclass();
ParameterizedType parameterizedType = ParameterizedType.class.cast(type);
System.out.println(parameterizedType.getActualTypeArguments()[0].getTypeName());
>>>>>>Activity四种启动模式
>>>>>>android4.0到9.0每个版本变化
>>>>>>内存溢出、内存泄露，内存分析
内存溢出：某一时刻向系统申请的内存超过了系统能提供的最大值；
内存泄露：因为不当的编程操作导致该被回收的对象没有被GC及时回收，不断积累最终耗尽系统内存；在java中，虚拟机运行时内存区域主要包括如下几块：
1）程序计数器：行号指示器
2）虚拟机栈：主要包含局部变量表（基本数据类型）、操作栈、对象引用、返回值地址等；
3）java堆：对象实例和数组；
4）方法区：类信息、常量、静态变量、JIT编译的代码；
5）直接内存：一些IO操作；
其他还有如java本地虚拟机栈、常量池等。在java中，GC回收机制采用的不是一般的程序计数器模式，其用的是根搜索算法，根据根搜索算法，任何一个对象，只要其和gc roots之间不可达，那么该对象就会被标记为可回收对象。在java中，能够作为GC Roots的对象主要包括以下几种：
1）虚拟机栈中的引用的对象
2）方法区中的类静态属性引用的对象
3）方法区中的常量引用的对象
4）本地虚拟机栈中JNI引用的对象
所以，只要按照以上这四点来避免就可以了，比如不要在activity中使用非静态的handle之类的，这个就是因为在java中，非静态内部类会默认持有外部类的一个引用，而handle本身又会被message引用，导致的结果就是最终activity没有被及时释放；还比如不要在单例中去持有activity等context对象，单例的生命周期一般和应用的生命周期一致，这也导致context对象不能及时释放；还比如一些IO操作要及时close，直接内存也会导致内存泄露。
常用内存分析工具：MAT,LeakCanary,Memory Profiler
>>>>>>LeakCanary原理
1）首先要了解下Reference和ReferenceQueue，当需要检测某个对象是否被回收的时候，可以进行如下操作：首先是构建一个ReferenceQueue，然后创建Reference并和ReferenceQueue进行关联，那么，当某个对象要被回收的时候，Reference会被放置到ReferenceQueue中，所以，检测某个对象是否被回收只要到ReferenceQueue中去找对应的Reference，找到了，表示对象回收了，没找到，表示对象没有被回收；
2）虽然LeakCanary也能进行其他对象的检测（通过如下方式LeakCanary.install(this).watch(new Object());）这里仅以Activity检测为例，其先是通过application的registerActivityLifecycleCallbacks()方法注入了一个全局的activity生命周期监听器，然后把每个执行过onDestroy()的activity实例和Reference绑定并和ReferenceQueue进行了关联，并且为每个activity实例随机生成了一个key保存到Set集合中，然后由对应的WatchExecutor去判断对应的activity对象是否被回收，如果没有回收，就dump出相关的信息发送到通知栏。
LeakCanary也提供了Fragment的检测，但是要android8及以上平台才有用。
>>>>>>listview，recycleview，数据绑定实现
>>>>>>MVC、MVP、MVVM
>>>>>>IPC，binder和socket
0）binder驱动，其跟硬件没有任何关系，它只是一段运行在内核中的代码，通过一个名为/dev/binder的文件实现用户空间和内核空间数据交互；其主要职责包括：binder节点的建立、binder在进程间的传递、binder引用计数管理；
1）ServiceManager所在进程打开/dev/binder设备，将BINDER_SET_CONTEXT_MGR命令发送给Binder驱动，Binder驱动会为ServiceManager在内核中创建名为binder_context_mgr_node的节点，该节点即为ServiceManager的Binder实体，而该进程就成为ServiceManager；
2）在整个系统中只会存在一个binder_context_mgr_node节点，也就能为其固定访问的句柄（在android中该句柄为0），所以当某个客户端想要访问SM的时候，只要告诉Binder驱动其要访问的句柄为0即可；
3）每一个server提供者，都会将自己封装成数据包发送给binder驱动，binder驱动读取数据包的时候如果发现有binder实体，会为这些binder实体创建binder节点和访问句柄（大于0），然后将该句柄和名字发送给SM
4）client要访问某个服务的时候，因为其只知道要访问的服务的名字，所以它会把句柄为0的值和服务名打包发给binder驱动，binder驱动发现句柄为0，就会把请求交给ServiceManager，ServiceManager根据服务名找到对应的服务的访问句柄，通过binder驱动传给client。Client获取到访问的句柄后，把句柄和需要访问的服务再发给binder，根据句柄binder驱动能找到句柄所对应的服务，因为client和server在两个进程中，对象没法直接访问，这个问题还是需要借助binder驱动来处理，binder驱动会对服务做一层转换，给服务生成一个代理对象，然后把这个代理对象传给client，这个代理对象从client那里获取相关参数，然后交给被代理对象，最终完成特定功能并返回结果，这样一次完整的通信就完成了。
AIDL手动实现的一个简单例子：
服务：
package org.module.a.aidl;
import android.os.IInterface;
/**
* IInterface规定了Server进程对象具备什么样的服务
*/
public interface IAidlHello extends IInterface {
String sayHello(String message);
}
服务的抽象实现
package org.module.a.aidl;
import android.os.Binder;
import android.os.IBinder;
import android.os.IInterface;
import android.os.Parcel;
import android.os.RemoteException;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
/**
* 继承Binder（实现了IBinder ），表示其具备跨进程传输的能力
*/
public abstract class AbstractAidlHello extends Binder implements IAidlHello {
static final java.lang.String DESCRIPTOR = "org.module.a.aidl.IAidlHello";
static final int TRANSACTION_sayHello = IBinder.FIRST_CALL_TRANSACTION + 0;
public AbstractAidlHello() {
/**
* Binder和IInterface（服务）关联，并制定了服务名
*/
this.attachInterface(this,DESCRIPTOR);
}
/**
* 客户端通过这个方法获取服务
* @param binder
* @return
*/
public static IAidlHello asInterface(IBinder binder){
if(binder == null){
return null;
}
/**
* Client和Server在同一个进程中，那么直接使用对象引用就可以了
*/
IInterface localInterface = binder.queryLocalInterface(DESCRIPTOR);
if(localInterface != null && localInterface instanceof IAidlHello){
return (IAidlHello) localInterface;
}
/**
* Client和Server不在同一个进程中，则使用代理对象
*/
return new AidlHelloProxy(binder);
}
@Override
public IBinder asBinder() {
return this;
}
/**
* 如果涉及到跨进程交互，这里面的参数来自于AidlHelloProxy的传递，返回结果也是通过AidlHelloProxy传递给Client。
*/
@Override
protected boolean onTransact(int code, @NonNull Parcel data, @Nullable Parcel reply, int flags) throws RemoteException {
switch (code){
case INTERFACE_TRANSACTION:
reply.writeString(DESCRIPTOR);
return true;
case TRANSACTION_sayHello:
// 获取参数
String message = data.readString();
// 处理逻辑
String result = sayHello(message);
// 返回结果
reply.writeNoException();
reply.writeString(result);
return true;
}
return super.onTransact(code, data, reply, flags);
}
}
服务的代理实现
package org.module.a.aidl;
import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteException;
/**
* 服务的代理，用于跨进程通信中binder驱动和客户端交互，
* 其作用主要是参数传递和返回值传递
*/
public class AidlHelloProxy implements IAidlHello {
private IBinder mRemote;
public AidlHelloProxy(IBinder iBinder) {
this.mRemote = iBinder;
}
@Override
public String sayHello(String message) {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
// 1、设置代理的是哪个服务
_data.writeInterfaceToken(AbstractAidlHello.DESCRIPTOR);
// 2、设置参数
_data.writeString(message);
//
try {
/**
* Proxy的作用，仅仅是为了传参和接收返回值，AbstractAidlHello 才是真正的接口实现者。
* 这里参数最终也是传给AbstractAidlHello的onTransact方法，返回值也是onTransact方法的返回值。
*/
// 3、传参
mRemote.transact(AbstractAidlHello.TRANSACTION_sayHello,_data,_reply,0);
_reply.readException();
// 4、接收返回值
return _reply.readString();
} catch (RemoteException e) {
e.printStackTrace();
} finally {
_data.recycle();
_reply.recycle();
}
return null;
}
@Override
public IBinder asBinder() {
return mRemote;
}
public String getInterfaceDescriptor() {
return AbstractAidlHello.DESCRIPTOR;
}
}
