Android培训
美国上市Android培训机构

400-111-8989

热门课程

andriod培训分享之代码、图片和布局优化

  • 发布:豌豆射手_BiuBiu
  • 来源:安卓巴士Android开发者门户
  • 时间:2018-06-11 18:22

今天android培训带给大家的是Android优化系列——代码、图片和布局优化,这篇文章分为三个部分代码优化、图片优化、布局优化,尽量每个方法都写了小的Demo,希望对大家有所帮助!

Android优化系列——代码、图片和布局优化

代码优化:不要做多余的工作,尽量避免次数过多的内存的分配,(需要对api有一定的熟悉)

数据集合的使用:建议最佳的做法是可能使用ArrayList作为首选,只要你需要使用额外的功能的时候,或者当程序性能由于经常从表的中间进行插入和删除而变差的时候,才会去选择LinkedList。HashMap性能上于HashTable相当,因为HashMap和HashTable在底层的存储和查找机制是一样的,但是TreeMap通常比HashMap要慢。HashSet总体上的性能比TreeSet好,特别实在添加和查询元素的时候,而这两个操作也是最重要的操作。TreeSet存在的唯一的原因是它可以维持元素的排序的状态,所以当需要一个排好序的Set,才使用TreeSet。因为其内部的结果欧支持排序,并且因为迭代是我们更有可能执行的操作,所以,用TreeSet迭代通常比用HashSet要快。

/**

* 建议最佳的做法是可能使用ArrayList作为首选,只要你需要使用额外的功能的时候,或者当程序性能由于经常从表的中间进行

* 插入和删除而变差的时候,才会去选择LinkedList

*/

//数据结构的选择,对于ArrayList,插入的操作特别高昂,并且其代价将随着列表的尺寸的增加而增加

ArrayList list=new ArrayList();

//需要执行大量的随机的访问,这个不是一个好的选择,如果是使用迭代器在列表中插入新的数据,使用这个,比较低廉(插入和移除的代价比较低廉)

LinkedList linkedList=new LinkedList();

//HashMap性能上于HashTable相当,因为HashMap和HashTable在底层的存储和查找机制是一样的,但是TreeMap通常比HashMap要慢

HashMap<String,String> hashMap=new HashMap<>();

/**

* HashSet总体上的性能比TreeSet好,特别实在添加和查询元素的时候,而这两个操作也是最重要的操作。TreeSet存在的唯一的原因是它

* 可以维持元素的排序的状态,所以当需要一个排好序的Set,才使用TreeSet。因为其内部的结果欧支持排序,并且因为迭代是我们更有可能

* 执行的操作,所以,用TreeSet迭代通常比用HashSet要快

*/

HashSet<String> hashSet=new HashSet<>();

TreeSet<String> treeSet=new TreeSet<>();

SparseArray是Android特有的稀疏数组的实现,他是Integer和Object的为例进行的一个映射用于代替 HsahMap<Integer,<E>>,提高性能。

SparseArray

线程不安全(多线程中需要注意)

由于要进行二分查找,(可以是有序的),SparseArray会对插入的数据按照Key的大小顺序插入

SparseArray对删除操作做了优化,它并不会立刻删除这个元素,而是通过设置标记位(DELETED)的方法,后面尝试重用。

内部核心的实现(二分查找)

/**

* 二分查找也称折半查找(Binary Search),它是一种效率较高的查找方法。

* 但是,折半查找要求线性表必须采用顺序存储结构,而且表中元素按关键字有序排列。

* @param array

* @param size

* @param value

* @return

*/

//二分查找

static int binarySearch(int[] array, int size, int value) {

int lo = 0;

int hi = size - 1;

while (lo <= hi) {

/**

* >>>与>>唯一的不同是它无论原来的最左边是什么数,统统都用0填充。

* —比如你的例子,byte是8位的,-1表示为byte型是11111111(补码表示法)

* b>>>4就是无符号右移4位,即00001111,这样结果就是15。

* 这里相当移动一位,除以二

*/

final int mid = (lo + hi) >>> 1;

final int midVal = array[mid];

if (midVal < value) {

lo = mid + 1;

} else if (midVal > value) {

hi = mid - 1;

} else {

return mid; // value found

}

}

//按位取反(~)运算符 ,没有找到,这个数据

return ~lo; // value not present

}

SpareArray 家族有以下的四类

//SpareArray 家族有以下的四类

//用于替换 HashMap<Integer,boolean>

SparseBooleanArray sparseBooleanArray=new SparseBooleanArray();

sparseBooleanArray.append(1,false);

//用于替换 HashMap<Integer,Interger>

SparseIntArray SparseIntArray=new SparseIntArray();

SparseIntArray.append(1,1);

//用于替换 HashMap<Integer,boolean>

@SuppressLint({"NewApi", "LocalSuppress"})

SparseLongArray SparseLongArray=new SparseLongArray();

SparseLongArray.append(1,1111000L);

//用于替换 HashMap<Integer,boolean>

SparseArray<String> SparseArray11=new SparseArray<String>();

SparseArray11.append(1,"dd");

SpareArray中的设计模式:原型模式:这里有使用到了的,原型模式内存中复制数据的,不会调用到类的构造的方法,而且访问的权限对原型模式无效

优点: 1、性能提高。 2、逃避构造函数的约束。

缺点:

1、配备克隆方法需要对类的功能进行通盘考虑,这对于全新的类不是很难,但对于已有的类不一定很容易,特别当一个类引用不支持串行化的间接对象,或者引用含有循环结构的时候。

2、必须实现 Cloneable 接口。

SparseArray<String> clone = sparseArray.clone();

Handler正确的使用姿势

下面的代码是很多人都会这样写,这样会造成内存泄漏

原因:Handler是和Looper以及MessageQueue一起工作的,在安卓中,一个 应用启动了,系统会默认创建一个主线程服务的Looper对象 ,该Looper对象处理主线程的所有的Message消息,他的生命周期贯穿整个应用。在主线程中使用的Handler的都会默认的绑定到这个looper的对象,咋主线程中创建handler的时候,它会立即关联主线程Looper对象的MessageQueue,这时发送到的MessageQueue 中的Message对象都会持有这个Handler的对象的引用,这样Looper处理消息时Handler的handlerMessage的方法,因此,如果Message还没有处理完成,那么handler的对象不会立即被垃圾回收

/*-------------old ide 已经告诉我们这里可能内存泄露-------------------*/

@SuppressLint("HandlerLeak")

private final Handler mHandler=new Handler(){

@Override

public void handleMessage(Message msg) {

super.handleMessage(msg);

}

};

// mHandler.postDelayed(new Runnable() {

// @Override

// public void run() {

// // TODO: 2018/4/28 用户即使退出了应用的话,这里也是会执行的 ,通过日记的观察

// //这里有可能用户退出了Activity

// System.out.println("shiming mHandler --todo");

// }

// },5000);

如何避免,有两点的可以尝试

1、在子线程中使用Handler,但是Handler不能再子线程中使用,需要开发者自己创建一个Looper对象,实现难,方法怪

2、将handler声明为静态的内部类,静态内部类不会持有外部类的引用,因此,也不会引起内存泄露,

InnerHandler innerHandler = new InnerHandler(this);

innerHandler.postDelayed(new Runnable() {

@Override

public void run() {

//这里这要 退出了 就不会执行了

System.out.println("shiming innerHandler --todo");

}

},5000);

public class InnerHandler extends Handler{

//弱应用,在另外一个地方会讲到

private final WeakReference<HandlerActivity> mActivityWeakReference;

public InnerHandler(HandlerActivity activity){

mActivityWeakReference=new WeakReference<HandlerActivity>(activity);

}

}

Context正确的姿势

//Context的种类

//Application 全局唯一的Context实例

Application application = getApplication();

Context applicationContext = application.getApplicationContext();

//不同的Activity,得到这个Context,是独立的,不会进行复用

Context baseContext = this.getBaseContext();

MyBroadcaseRecriver myBroadcaseRecriver = new MyBroadcaseRecriver();

//ContentProvider 中的Context

/**

*如果创建单利必须需要使用到context对象

*/

//这样不会内存泄露,不用改动单利类中代码

SingleInstance.getSingleInstance(getApplication().getApplicationContext());

单例模式,如果不得不传入Context,由于单例一直存在会导致Activity或者是Service的单例引用,从而不会被垃圾回收, Activity中的关联的View和数据结构也不会被释放,正确的方式应该使用Application中的Context

class SingleInstance {

private static SingleInstance sSingleInstance;

private final Context mContext;

private SingleInstance(Context context){

mContext = context;

}

// 因为每次调用实例都需要判断同步锁,很多项目包括很多人都是用这种的

// 双重判断校验的方法,这种的方法看似很完美的解决了效率的问题,但是它

// 在并发量不多,安全性不太高的情况下能完美的运行,但是,

// 在jvm编译的过程中会出现指令重排的优化过程,这就会导致singleton实际上

// 没有被初始化,就分配了内存空间,也就是说singleton!=null但是又没有被初始化,

// 这就会导致返回的singletonthird返回的是不完整的

public static SingleInstance getSingleInstance(Context context){

if (sSingleInstance==null){

synchronized (SingleInstance.class){

if (sSingleInstance==null) {

// TODO: 2018/4/28 注意外面传入的conext对象是否,是哪个

sSingleInstance= new SingleInstance(context);

//第二种是改动代码,使用application 中的context变量

sSingleInstance= new SingleInstance(context.getApplicationContext());

}

}

}

return sSingleInstance;

}

}

java 四种引用方式和引用队列的解释

和java一样,Android也是基于垃圾回收(GC)机制实现内存的自动的回收,垃圾回收的算法“标记-清除(Mark-Sweep)” “标记压缩(Mark-Compact)“复制算法(Copying)以及引用计数算法(Reference-Counting),安卓的虚拟机(Dalvik还是Art),都是使用标记清除算法。 在Android中,内存泄露是指不再使用的对象依然占有内存,或者是他们占用的内存没有得到释放, 从而导致内存空间不断的减少,由于可用的空间比较少,发生内存泄露会使得内存更加的紧张,甚至最终由于内存耗尽而发生的OOM,导致应用的崩溃。

* 和java一样,Android也是基于垃圾回收(GC)机制实现内存的自动的回收,垃圾回收的算法“标记-清除(Mark-Sweep)”

* “标记压缩(Mark-Compact)“复制算法(Copying)以及引用计数算法(Reference-Counting),安卓的虚拟机(Dalvik还是Art),

* 都是使用标记清除算法”

*

mTextView1.setText(des1);

/**

* 在Android中,内存泄露是指不再使用的对象依然占有内存,或者是他们占用的内存没有得到释放,

* 从而导致内存空间不断的减少,由于可用的空间比较少,发生内存泄露会使得内存更加的紧张,

* 甚至最终由于内存耗尽而发生的OOM,导致应用的崩溃

*/

mTextView2.setText(des2);

强引用:Java中里面最广泛的使用的一种,也是对象默认的引用类型,如果又一个对象具有强引用,那么垃圾回收器是不会对它进行回收操作的,当内存的空间不足的时候,Java虚拟机将会抛OutOfMemoryError错误,这时应用将会被终止运行

软引用:一个对象如果只有一个软引用,那么当内存空间充足是,垃圾回收器不会对他进行回收操作,只有当内存空间不足的时候,这个对象才会被回收,软引用可以用来实现内存敏感的高速缓存,如果配合引用队列(ReferenceQueue使用,当软引用指向对象被垃圾回收器回收后,java会把这个软引用加入到与之关联的引用队列中)

弱引用:弱引用是比软引用更弱的一种的引用的类型,只有弱引用指向的对象的生命周期更短,当垃圾回收器扫描到只有具有弱引用的对象的时候,不敢当前空间是否不足,都会对弱引用对象进行回收,当然弱引用也可以和一个队列配合着使用

引用队列:ReferenceQueue一般是作为WeakReference SoftReference 的构造的函数参数传入的,在WeakReference 或者是 softReference 的指向的对象被垃圾回收后,ReferenceQueue就是用来保存这个已经被回收的Reference

String des3="强引用:Java中里面最广泛的使用的一种,也是对象默认的引用类型,如果又一个对象具有强引用,那么垃圾回收器是不会对它进行回收操作的,当内存的空间不足的时候,Java虚拟机将会抛出OutOfMemoryError错误,这时应用将会被终止运行";

mTextView3.setText(des3);

String des4="软引用:一个对象如果只有一个软引用,那么当内存空间充足是,垃圾回收器不会对他进行回收操作,只有当内存空间不足的时候,这个对象才会被回收,软引用可以用来实现内存敏感的高速缓存,如果配合引用队列(ReferenceQueue使用,当软引用指向对象被垃圾回收器回收后,java会把这个软引用加入到与之关联的引用队列中)";

Object obj=new Object();

SoftReference<Object> sr = new SoftReference<>(obj);//这里使用了软引用...

/*

*在这个期间,有可能会出现内存不足的情况发生,那么GC就会直接把所有的软引用全部清除..并释放内存空间

*如果内存空间足够的话,那么就GC就不会进行工作...

*GC的工作取决于内存的大小,以及其内部的算法,,,,

*/

if(sr!=null){

//如果软引用还存在,那么直接就可以获取这个对象的相关数据...这样就实现了cache...

obj = sr.get();

}else{

//如果已经不存在,表示GC已经将其回收,我们需要重新实例化对象,获取数据信息...

obj = new Object();

sr = new SoftReference<>(obj);

}

mTextView4.setText(des4);

String des5="弱引用:弱引用是比软引用更弱的一种的引用的类型,只有弱引用指向的对象的生命周期更短,当垃圾回收器扫描到只有具有弱引用的对象的时候,不敢当前空间是否不足,都会对弱引用对象进行回收,当然弱引用也可以和一个队列配合着使用";

Object obj1 = new Object();

WeakReference<Object> weakProductA = new WeakReference<>(obj1);

mTextView5.setText(des5);

String des6="虚引用:和软引用和弱引用不同,虚引用并不会对所指向的对象生命周期产生任何影响,也就是对象还是会按照它原来的方式别垃圾回收期回收,虚引用本质上只是有一个标记作用,主要用来跟踪对象被垃圾回收的活动,虚引用必须和引用队列配合使用,当对象被垃圾回收时,如果存在虚引用,那么Java虚拟机会将这个虚引用加入到与之关联的引用队列中";

mTextView6.setText(des6);

/**

* 如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。

* 虚引用主要用来跟踪对象被垃圾回收器回收的活动

*/

// TODO: 2018/5/2 程序可以通过判断引用队列中是否已经加入了虚引用,

// 来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,

// 那么就可以在所引用的对象的内存被回收之前采取必要的行动。

ReferenceQueue queue = new ReferenceQueue ();

PhantomReference pr = new PhantomReference<Object>(obj1, queue);

String des7="引用队列:ReferenceQueue一般是作为WeakReference SoftReference 的构造的函数参数传入的,在WeakReference 或者是 softReference 的指向的对象被垃圾回收后,ReferenceQueue就是用来保存这个已经被回收的Reference";

mTextView7.setText(des7);

将HashMap封装成一个线程安全的集合,并且使用软引用的方式防止OOM(内存不足)。由于在ListView中会加载大量的图片.那么为了有效的防止OOM导致程序终止的情况

/**

* list中使用大量的bitmap,这种情况的话,我自己感觉使用的比较少

*/

public class MemoryCache {

//将HashMap封装成一个线程安全的集合,并且使用软引用的方式防止OOM(内存不足)...

//由于在ListView中会加载大量的图片.那么为了有效的防止OOM导致程序终止的情况...

private Map<String,SoftReference<Bitmap>> cache=Collections.synchronizedMap(new HashMap<String, SoftReference<Bitmap>>());

public Bitmap get(String id){

if(!cache.containsKey(id))

return null;

SoftReference<Bitmap>ref=cache.get(id);

return ref.get();

}

public void put(String id,Bitmap bitmap){

cache.put(id, new SoftReference<Bitmap>(bitmap));

}

public void clear(){

cache.clear();

}

}

一个简单的Demo

/**

* author: Created by shiming on 2018/5/2 14:50

* mailbox:lamshiming@sina.com

*/

public class EmployeeCache {

static private EmployeeCache cache;// 一个Cache实例

private Hashtable<String, EmployeeRef> employeeRefs;// 用于Chche内容的存储

private ReferenceQueue<Employee> q;// 垃圾Reference的队列

// 继承SoftReference,使得每一个实例都具有可识别的标识。

// 并且该标识与其在HashMap内的key相同。

public class EmployeeRef extends SoftReference<Employee> {

private String _key = "";

public EmployeeRef(Employee em, ReferenceQueue<Employee> q) {

super(em, q);

_key = em.getID();

}

}

// 构建一个缓存器实例

private EmployeeCache() {

employeeRefs = new Hashtable<String, EmployeeRef>();

q = new ReferenceQueue<Employee>();

}

// 取得缓存器实例

public static EmployeeCache getInstance() {

if (cache == null) {

cache = new EmployeeCache();

}

return cache;

}

// 以软引用的方式对一个Employee对象的实例进行引用并保存该引用

private void cacheEmployee(Employee em) {

cleanCache();// 清除垃圾引用

EmployeeRef ref = new EmployeeRef(em, q);

employeeRefs.put(em.getID(), ref);

}

// 依据所指定的ID号,重新获取相应Employee对象的实例

public Employee getEmployee(String ID) {

Employee em = null;

// 缓存中是否有该Employee实例的软引用,如果有,从软引用中取得。

if (employeeRefs.containsKey(ID)) {

EmployeeRef ref = (EmployeeRef) employeeRefs.get(ID);

em = (Employee) ref.get();

}

// 如果没有软引用,或者从软引用中得到的实例是null,重新构建一个实例,

// 并保存对这个新建实例的软引用

if (em == null) {

em = new Employee(ID);

System.out.println("Retrieve From EmployeeInfoCenter. ID=" + ID);

this.cacheEmployee(em);

}

return em;

}

// 清除那些所软引用的Employee对象已经被回收的EmployeeRef对象

private void cleanCache() {

EmployeeRef ref = null;

while ((ref = (EmployeeRef) q.poll()) != null) {

employeeRefs.remove(ref._key);

}

}

// 清除Cache内的全部内容

public void clearCache() {

cleanCache();

employeeRefs.clear();

//告诉垃圾收集器打算进行垃圾收集,而垃圾收集器进不进行收集是不确定的

System.gc();

//强制调用已经失去引用的对象的finalize方法

System.runFinalization();

}

/**

* 当垃圾收集器认为没有指向对象实例的引用时,会在销毁该对象之前调用finalize()方法。

* 该方法最常见的作用是确保释放实例占用的全部资源。java并不保证定时为对象实例调用该方法,

* 甚至不保证方法会被调用,所以该方法不应该用于正常内存处理。

* @throws Throwable

*/

@Override

protected void finalize() throws Throwable {

super.finalize();

}

}

/**

* author: Created by shiming on 2018/5/2 14:49

* mailbox:lamshiming@sina.com

*/

public class Employee {

private String id;// 雇员的标识号码

private String name;// 雇员姓名

private String department;// 该雇员所在部门

private String Phone;// 该雇员联系电话

private int salary;// 该雇员薪资

private String origin;// 该雇员信息的来源

// 构造方法

public Employee(String id) {

this.id = id;

getDataFromlnfoCenter();

}

// 到数据库中取得雇员信息

private void getDataFromlnfoCenter() {

// 和数据库建立连接井查询该雇员的信息,将查询结果赋值

// 给name,department,plone,salary等变量

// 同时将origin赋值为"From DataBase"

}

public String getID() {

return id;

}

}

其他需要注意到的地方:

1、不要重复的创建相同的对象,对象的创建都是需要内存分配的,对象的销毁需要垃圾回收,这些都在一定程度上影响程序的性能

2、对常量使用static final修饰,对于基本类型和String类型的常量,建议使用常量static final 修饰,因为final类型的常量会在静态dex文件的域初始化部分,这时对基本数据类型和String类型常量的调用不会涉及类的初始化,而是直接调用字面量

3、避免内部的get set方法的调用,get set的作用是对以外屏蔽具体的变量定义,从而达到更好的封装性,如果在类的内部调用get set的方法访问变量的话,会降低访问的速度,根据在安卓的官方的文档,在没有jit编译器时,直接访问变量的速度是调用get方法的3倍,在jit编译器,直接访问变量是调用get方法的7倍,当然使用了ProGuard的话,perGuard会对get set 进行内联的操作,从而达到直接访问的效果

关于JIT:

JIT是”Just In Time Compiler”的缩写,就是”即时编译技术”,与Dalvik虚拟机相关,JIT是在2.2版本提出的,目的是为了提高Android的运行速度,一直存活到4.4版本,因为在4.4之后的ROM中,就不存在Dalvik虚拟机了。

编译打包APK文件:1、Java编译器将应用中所有Java文件编译为class文件,2、dx工具将应用编译输出的类文件转换为Dalvik字节码,即dex文件

Google在2.2版本添加了JIT编译器,当App运行时,每当遇到一个新类,JIT编译器就会对这个类进行编译,经过编译后的代码,会被优化成相当精简的原生型指令码(即native code),这样在下次执行到相同逻辑的时候,速度就会更快。

dex字节码翻译成本地机器码是发生在应用程序的运行过程中的,并且应用程序每一次重新运行的时候,都要做重做这个翻译工作,所以这个工作并不是一劳永逸,每次重新打开App,都需要JIT编译,Dalvik虚拟机从Android一出生一直活到4.4版本,而JIT在Android刚发布的时候并不存在,在2.2之后才被添加到Dalvik中。

AOT是”Ahead Of Time”的缩写,指的就是ART(Anroid RunTime)这种运行方式。

JIT是运行时编译,这样可以对执行次数频繁的dex代码进行编译和优化,减少以后使用时的翻译时间,虽然可以加快Dalvik运行速度,但是还是有弊病,那就是将dex翻译为本地机器码也要占用时间,所以Google在4.4之后推出了ART,用来替换Dalvik。

ART的策略与Dalvik不同,在ART 环境中,应用在第一次安装的时候,字节码就会预先编译成机器码,使其成为真正的本地应用。之后打开App的时候,不需要额外的翻译工作,直接使用本地机器码运行,因此运行速度提高。

当然ART与Dalvik相比,还是有缺点的。

ART需要应用程序在安装时,就把程序代码转换成机器语言,所以这会消耗掉更多的存储空间,但消耗掉空间的增幅通常不会超过应用代码包大小的20%

由于有了一个转码的过程,所以应用安装时间难免会延长

但是这些与更流畅的Android体验相比而言,不值一提。

图片优化

四种图片格式

JPEG

是一种广泛使用的有损压缩图像标准格式,它不支持透明和多帧动画,一般摄影的作品是JEPG格式的,通过控制压缩比,可以调整图片的大小

PNG

是一种无损压缩的图片格式,他支持完整的透明通道,从图片处理的领域来讲,JEPG只有RGB三个通道,而PNG有ARGB四个通道,因此PNG图片占用空间一般比较大,会无形的增加app的大小,在做app瘦身时一般都要对PNG图片进行梳理以减小其占用的体积

GIF

是一种古老的图片的格式,诞生于1987年,随着初代互联网流行开来,他的特别是支持多帧动画,表情图,

Webp

google于2010年发布,支持有损和无损、支持完整的透明通道、也支持多帧动画,目前主流的APP都已经使用了Webp,淘宝,微信,即保证了图片的大小和质量

在安卓应用开发中能够使用编解码格式的只有三种 JEPG PNG WEBP

/**

* 在安卓应用开发中能够使用编解码格式的只有三种 JEPG PNG WEBP

*/

public enum CompressFormat {

JPEG (0),

PNG (1),

WEBP (2);//安卓4.0后开始支持

CompressFormat(int nativeInt) {

this.nativeInt = nativeInt;

}

final int nativeInt;

}

推荐几种图片处理网站

无损压缩ImageOptin,在不牺牲图片质量的前提下,即减下来PNG图片占用的空间,又提高了图片的加载速度 https://imageoptim.com/api

推荐几种图片处理网站

有损压缩ImageAlpha,图片大小得到极大的缩小,如果需要使用的话,一定要ui设计师看能否使用 https://pngmini.com/

有损压缩TinyPNG 比较知名的png压缩的工具,也需要ui设计师看能够使用不 https://tinypng.com/

PNG/JPEG 转化为 wepb :http://zhitu.isux.us/

如果ui设计师工作量不饱和的话,可以推荐, 尽量使用 .9.png 点9图 小黑点表示 可拉伸区域,黑边表示纵向显示内容的范围

布局优化:如果创建的层级结构比较复杂,View树嵌套的层次比较深,那么将会使得页面的响应的时间变长,导致运行的时候越来越慢

merge标签(对安卓的事件传递要达到源码级的熟悉才可以理解) 在某些场景下可以减少布局的层次,由于所有的Activity的根布局都是FrameLayout Window PhoneWindow DecorView 事件的传递,包括设置setContentView 等的方法---> 我会写一篇文章独立解释安卓事件的源码解析,会更加清楚的介绍这个类,(对安卓的事件传递要达到源码级的熟悉才可以理解)todo<-----所以,当独立的一个布局文件最外层是FrameLayout的时候,并且和这个布局不需要设置 background 或者 padding的时候,可以使用

标签来代替FrameLayout布局。另外一种的情况可以使用《merge》便签的情况是当前布局作为另外一个布局的子布局

<include android:layout_height="50dp"

android:layout_width="match_parent"

layout="@layout/layout_include_merge"

/>

<?xml version="1.0" encoding="utf-8"?>

<merge xmlns:android="http://schemas.android.com/apk/res/android"

android:layout_width="match_parent"

android:layout_height="match_parent">

<TextView android:gravity="center"

android:text="merge 标签 在某些场景下可以减少布局的层次,由于所有的"

android:layout_width="match_parent"

android:layout_height="match_parent" />

</merge>

在安卓中经常会使用到相同的布局,比如说title,最佳的实践的方法就是把相同的布局抽取出来,独立成一个xml文件,需要使用到的时候,就把这个布局include进来,不仅减少了代码量,而且修改这个相同的布局,只需要修改一个地方即可.

ViewStub 是一种不可见的并且大小为0的试图,它可以延迟到运行时才填充inflate 布局资源,当Viewstub设为可见或者是inflate的时候,就会填充布局资源,这个布局和普通的试图就基本上没有任何区别,比如说,加载网络失败,或者是一个比较消耗性能的功能,需要用户去点击才可以加载,参考我的开源的项目 WritingPen

注意事项:如果这个根布局是个View,比如说是个ImagView,那么找出来的id为null,得必须注意这一点

修正这个说法,以前我说的是错误的,根本上的原因是ViewStub设置了 inflateid ,这才是更本身的原因,对不起!搞错了,还是要看源码

<ViewStub

android:padding="10dp"

android:background="@color/colorPrimary"

android:layout_gravity="center"

android:inflatedId="@+id/find_view_stub"

android:id="@+id/view_stub"

android:layout="@layout/view_stub_imageview"

android:layout_width="wrap_content"

android:layout_height="wrap_content" />

<?xml version="1.0" encoding="utf-8"?>

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"

android:padding="10dp"

android:src="@drawable/ic_launcher_background"

android:layout_width="match_parent"

android:layout_height="match_parent">

<TextView

android:text="如果这个根布局是个View,比如说是个ImagView,那么找出来的id为null,得必须注意这一点"

android:layout_width="wrap_content"

android:layout_height="wrap_content" />

<!--如果这个根布局是个View,比如说是个ImagView,那么找出来的id为null,得必须注意这一点-->

<ImageView

android:layout_marginTop="20dp"

android:id="@+id/imageview"

android:padding="10dp"

android:src="@drawable/ic_launcher_background"

android:layout_width="match_parent"

android:layout_height="match_parent"/>

</FrameLayout>

调用todo: 2018/5/4 為啥為null 原因是布局文件中根布局只有View,没有ViewGroup,ViewStub.inflate() 的方法和 setVisibility 方法是差不多,因为 setVisibility方法会(看源码)走这个inflate的方法

if (null!=mViewStub.getParent()){

/*

android:inflatedId 的值是Java代码中调用ViewStub的 inflate()或者是serVisibility方法返回的Id,这个id就是被填充的View的Id

*/

/**

* ViewStub.inflate() 的方法和 setVisibility 方法是差不多,因为 setVisibility方法会(看源码)走这个inflate的方法

*/

// View inflate = mViewStub.inflate();

mViewStub.setVisibility(View.VISIBLE);

//inflate--->android.support.v7.widget.AppCompatImageView{de7e3a2 V.ED..... ......I. 0,0-0,0 #7f07003e app:id/find_view_stub}

// System.out.println("shiming inflate--->"+inflate);

final View find_view_stub = findViewById(R.id.find_view_stub);

System.out.println("shiming ----"+find_view_stub);

View iamgeivew11 = find_view_stub.findViewById(R.id.imageview);

//himing ---- iamgeivew11null

// TODO: 2018/5/4 為啥為null 原因是布局文件中根布局只有View,没有ViewGroup

System.out.println("shiming ---- iamgeivew11"+iamgeivew11);

}else{

Toast.makeText(LayoutOptimizationActivity.this,"已经inflate了",Toast.LENGTH_LONG).show();

final View viewById = findViewById(R.id.find_view_stub);

View iamgeivew = findViewById(R.id.imageview);

//已经inflate了android.support.v7.widget.AppCompatImageView{4637833 V.ED..... ........ 348,294-732,678 #7f07003e app:id/find_view_stub}

System.out.println("shiming l----已经inflate了"+viewById);//

System.out.println("shiming l----已经inflate了iamgeivew"+iamgeivew);//已经inflate了iamgeivew==null

View iamgeivew11 = viewById.findViewById(R.id.imageview);

//已经inflate了 iamgeivew11null

System.out.println("shiming l----已经inflate了 iamgeivew11"+iamgeivew11);

}

}

尽量使用CompoundDrawable,如果存在相邻的ImageView和TextView 的话

<LinearLayout

android:layout_width="match_parent"

android:layout_height="150dp">

<TextView

android:text="我是文字"

android:drawableBottom="@mipmap/ic_launcher_round"

android:layout_width="wrap_content"

android:layout_height="wrap_content" />

<TextView

android:text="我是title2"

android:drawableEnd="@mipmap/ic_launcher_round"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:drawableRight="@mipmap/ic_launcher_round" />

<TextView

android:text="我是文字33"

android:drawableLeft="@mipmap/ic_launcher_round"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:drawableStart="@mipmap/ic_launcher_round" />

<TextView

android:drawableTop="@mipmap/ic_launcher_round"

android:text="我是文字3"

android:layout_width="wrap_content"

android:layout_height="wrap_content" />

</LinearLayout>

Android优化系列——代码、图片和布局优化

使用Lint 检查代码,和布局是否可以存在优化的地方,我会写个简单的经常遇见过的问题,同时完成一篇文档,加以说明,地址Lint的使用(安卓性能提升必备掌握的工具)

恭喜你阅读完了本文,相信你已经了解了Android优化系列——代码、图片和布局优化的方法,有兴趣的话赶紧去试试吧!如果你还有android相关的问题,欢迎你来达内android培训机构进行咨询。

免责声明:内容和图片源自网络,版权归原作者所有,如有侵犯您的原创版权请告知,我们将尽快删除相关内容。

免费预约企业总监级讲师试听课

怕钱不够?就业挣钱后再付学费!     怕学不会?0基础入学,达内定制课程!     担心就业?近12万家雇主企业,推荐名企就业!

上一篇:android新技术WorkManager,android开发者的福利
下一篇:优化android中的网络和电量,提高App性能
选择城市和中心
贵州省

广西省

海南省