>>>>>>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
插入排序:依次取出待排序的元素,插入到已排好序的序列中。
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 users = new ArrayList(){};//注意这里的双大括号
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;
}
}