Android琐碎知识点小记

1. 调用下面的方法,得到的返回值是什么？

public int getNum() {
        try {
            int a = 1 / 0;
            return 1;
        } catch (Exception e) {
            return 2;
        } finally {
            return 3;
        }
    }

代码在走到第 3 行的时候遇到了一个 MathException，这时第四行的代码就不会执行了，代码直接跳转到catch 语句中，走到第 6 行的时候，异常机制有这么一个原则“如果在 catch 中遇到了 return 或者异常等能使该函数终止的话，那么用 finally 就必须先执行完 finally 代码块里面的代码然后再返回值。”因此代码又跳到第 8行，可惜第 8 行是一个 return 语句，那么这个时候方法就结束了，因此第 6 行的返回结果就无法被真正返回。如果 finally 仅仅是处理了一个释放资源的操作，那么该道题最终返回的结果就是 2。因此上面返回值是 3。

2. Java 的基本数据类型都有哪些各占几个字节？
   Java 有 8 种基本数据类型
   byte 1
   char 2
   sort 2
   int 4
   float 4
   double 8
   long 8
   boolean 1（boolean 类型比较特别可能只占一个 bit，多个 boolean 可能共同占用一个字节）

3. String 是基本数据类型吗？可以被继承吗？
   String是引用类型，底层是用char数组实现的，String是final类，java 中被final修饰的类不能被继承，所以String不能被继承。

4. 在 java 中 wait 和 sleep 方法的不同？
   最大的不同是wait会释放锁，sleep会一直持有锁。wait通常用于线程间交互，sleep用于暂停执行。

5. 什么是线程池，如何使用？
   线程池就是事先将多个线程对象放到一个容器里，当使用的时候就不用new而是直接去线程池中拿线程即可，节省了开辟子线程的时间，提高了代码的执行效率。
   在 JDK 的 java.util.concurrent.Executors 中提供了生成多种线程池的静态方法。

ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(4);
ScheduledExecutorService newScheduledThreadPool =
Executors.newScheduledThreadPool(4);
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor(); 

然后调用他们的 execute 方法即可。

6. Java 中的反射
   说说你对 Java 中反射的理解?
   Java 中 的 反 射 首 先 是 能 够 获 取 到 Java 中 要 反 射 类 的 字 节 码 ， 获 取 字 节 码 有 三 种 方 法 :1.Class.forName(className) 2.类名.class 3.this.getClass()。然后将字节码中的方法，变量，构造函数等映射成相应的 Method、Filed、Constructor 等类，这些类提供了丰富的方法可以被我们所使用。
7. Java 中的动态代理
   写一个 ArrayList 的动态代理类

final List<String> list = new ArrayList<String>();
 List<String> proxyInstance = (List<String>)
Proxy.newProxyInstance(list.getClass().getClassLoader(),
list.getClass().getInterfaces(), new InvocationHandler() {
 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws
Throwable {
 return method.invoke(list, args);
 }
 });
 proxyInstance.add("你好");
 System.out.println(list); 

8. Java 中的设计模式
   Java 中一般认为有 23 种设计模式，我们不需要所有的都会，但是其中常用的几种设计模式应该去掌握。下面列
   出了所有的设计模式。需要掌握的设计模式我单独列出来了，当然能掌握的越多越好。
   总体来说设计模式分为三大类：
   创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
   结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
   行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录
   模式、状态模式、访问者模式、中介者模式、解释器模式。
9. 写 10 个简单的 linux 命令
   mkdir 创建文件夹
   rmdir 删除文件夹
   rm 删除文件
   mv 移动文件
   cp 拷贝文件
   cat 查看文件
   tail 查看文件尾部
   more 分页查看文件
   cd 切换当前目录
   ls 列出文件清单
   reboot 重启
   date 显示日期
   cal 显示日历
   ps 查看系统进程相当于 windows 的任务管理器
   ifconfig 配置网络
10. Service 是否在 main thread 中执行, service 里面是否能执行耗时的操作?
    默认情况,如果没有显示的指 service 所运行的进程, Service 和 activity 是运行在当前 app 所在进程的 main thread(UI 主线程)里面。service 里面不能执行耗时的操作(网络请求,拷贝数据库,大文件 )
    特殊情况 ,可以在清单文件配置 service 执行所在的进程 ,让 service 在另外的进程中执行。

<service android:name="com.baidu.location.f"
 android:enabled="true"
 android:process=":remote" ></service> 

11. Serializable 和 Parcelable 的区别
    1.在使用内存的时候，Parcelable类会比Serializable性能高，所以推荐使用Parcelable。
    2.Serializable在进行序列化的时候会产生大量的临时变量，从而引起频繁的GC。
    3.Parcelable 不能使用在要将数据存储在磁盘上的情况。尽管 Serializable 效率低点，但在这种情况下，还是建议你用 Serializable 。
    实现：
    Serializable 的实现，只需要继承 Serializable 即可。这只是给对象打了一个标记，系统会自动将其序列化。
    Parcelabel 的实现，需要在类中添加一个静态成员变量 CREATOR，这个变量需要继承 Parcelable.Creator 接
    口。

public class MyParcelable implements Parcelable {
 private int mData;
 public int describeContents() {
 return 0;
 }
 public void writeToParcel(Parcel out, int flags) {
 out.writeInt(mData);
 }
 public static final Parcelable.Creator<MyParcelable> CREATOR= new Parcelable.Creator<MyParcelable>() {
 public MyParcelable createFromParcel(Parcel in) {
 return new MyParcelable(in);
 }
 public MyParcelable[] newArray(int size) {
 return new MyParcelable[size];
 }
 };
 private MyParcelable(Parcel in) {
 mData = in.readInt();
 }
}

12. 请描述一下 Intent 和 IntentFilter
    Android 中通过 Intent 对象来表示一条消息，一个 Intent 对象不仅包含有这个消息的目的地，还可以包含消息的内容，这好比一封 Email，其中不仅应该包含收件地址，还可以包含具体的内容。对于一个 Intent 对象，消息“目的地”是必须的，而内容则是可选项。
    通过 Intent 可以实现各种系统组件的调用与激活.
    IntentFilter: 可以理解为邮局或者是一个信笺的分拣系统.
    这个分拣系统通过 3 个参数来识别 :
    Action: 动作 view
    Data: 数据 uri uri
    Category : 而外的附加信息
13. Fragment 跟 Activity 之间是如何传值的
    当 Fragment 跟 Activity 绑定之后，在 Fragment 中可以直接通过 getActivity（）方法获取到其绑定的 Activity对象，这样就可以调用 Activity 的方法了。在 Activity 中可以通过如下方法获取Fragment 实例 。

FragmentManager fragmentManager = getFragmentManager();
 Fragment fragment = fragmentManager.findFragmentByTag(tag);
 Fragment fragment = fragmentManager.findFragmentById(id); 

获取到 Fragment 之后就可以调用 Fragment 的方法。也就实现了通信功能。

14. 如何避免 OOM 异常
    1、图片过大导致 OOM
    Android 中用 bitmap 时很容易内存溢出，比如报如下错误：Java.lang.OutOfMemoryError : bitmap size exceeds VM budget
    解决方法：
    方法 1： 等比例缩小图片

BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 2;
//Options 只保存图片尺寸大小，不保存图片到内存
 BitmapFactory.Options opts = new BitmapFactory.Options();
 opts.inSampleSize = 2;
 Bitmap bmp = null;
 bmp = BitmapFactory.decodeResource(getResources(),
mImageIds[position],opts);
 //回收
 bmp.recycle();

以上代码可以优化内存溢出，但它只是改变图片大小，并不能彻底解决内存溢出
方法 2：对图片采用软引用，及时地进行 recyle()操作

SoftReference<Bitmap> bitmap = new SoftReference<Bitmap>(pBitmap);
if(bitmap != null){
if(bitmap.get() != null && !bitmap.get().isRecycled()){
 bitmap.get().recycle();
 bitmap = null;
 }
}

2、界面切换导致 OOM
有时候我们会发现这样的问题，横竖屏切换 N 次后 OOM 了。
2.1、看看页面布局当中有没有大的图片，比如背景图之类的。
去除 xml 中相关设置，改在程序中设置背景图（放在 onCreate()方法中）：

Drawable drawable = getResources().getDrawable(R.drawable.id);
 ImageView imageView = new ImageView(this);
 imageView.setBackgroundDrawable(drawable); 

在 Activity destory 时注意，drawable.setCallback(null); 防止 Activity 得不到及时的释放.
2.2 、 跟 上 面 方 法 相 似 ， 直 接 把 xml 配 置 文 件 加 载 成 view 再 放 到 一 个 容 器 里 ， 然 后 直 接 调 用
this.setContentView(View view);方法，避免 xml 的重复加载。
2.3、 在页面切换时尽可能少地重复使用一些代码
比如：重复调用数据库，反复使用某些对象等等......
常见的内存使用不当的情况
3、查询数据库没有关闭游标 查询数据库没有关闭游标 查询数据库没有关闭游标
程序中经常会进行查询数据库的操作，但是经常会有使用完毕 Cursor 后没有关闭的情况。如果我们的查询结果集比较小，对内存的消耗不容易被发现，只有在常时间大量操作的情况下才会出现内存问题，这样就会给以后的测试和问题排查带来困难和风险。
4、构造 Adapter Adapter Adapter 时，没有使用缓存的 没有使用缓存的 没有使用缓存的convertView convertView convertView
在使用 ListView 的时候通常会使用 Adapter，那么我们应该尽可能的使用 ConvertView。
5、Bitmap 对象不再使用时调用 对象不再使用时调用 对象不再使用时调用 recycle() recycle() recycle()释放内存.
有时我们会手工的操作 Bitmap 对象，如果一个 Bitmap 对象比较占内存，当它不再被使用的时候，可以调用Bitmap.recycle()方法回收此对象的像素所占用的内存，但这不是必须的，视情况而定。
6、其他
Android 应用程序中最典型的需要注意释放资源的情况是在 Activity 的生命周期中，在 onPause()、onStop()、onDestroy()方法中需要适当的释放资源的情况。

15. Android 中如何捕获未捕获的异常
    1、自定义一个 Application，比如叫 MyApplication 继承 Application 实现 UncaughtExceptionHandler。
    2、覆写 UncaughtExceptionHandler 的 onCreate 和 uncaughtException 方法。

@Override
public void onCreate() {
 super.onCreate();
 Thread.setDefaultUncaughtExceptionHandler(this);
 }
@Override
public void uncaughtException(final Thread thread, final Throwable ex) {
 new Thread(new Runnable() {

 @Override
 public void run() {
 Looper.prepare();
 System.out.println(Thread.currentThread());
 Toast.makeText(getApplicationContext(), "thread="+thread.getId()+"
ex="+ex.toString(), 1).show();
 Looper.loop();
 }
 }).start();
 SystemClock.sleep(3000);
 android.os.Process.killProcess(android.os.Process.myPid());
 }
} 

注意：上面的代码只是简单的将异常打印出来。
在 onCreate 方法中我们给 Thread 类设置默认异常处理 handler，如果这句代码不执行则一切都是白搭。
在 uncaughtException 方法中我们必须新开辟个线程进行我们异常的收集工作，然后将系统给杀死.
3、在 AndroidManifest 中配置该 Application

<application
 android:name="com.example.uncatchexception.MyApplication"/>

16. 请描述一下 View 的绘制流程
    整个 View 树的绘图流程是在 ViewRoot.java 类(该类位于 Android 源码下面：
    D:\AndroidSource_GB\AndroidSource_GB\frameworks\base\core\java\android\view)的performTraversals()函数展开的,该函数做的执行过程可简单概况为根据之前设置的状态，判断是否需要重新计算视图大小(measure)、是否重新需要安置视图的位置(layout)、以及是否需要重绘 (draw)，其框架过程如下：

338650C6-00C1-4962-B083-400880D506F6.png

由 ViewRoot 对象的 performTraversals()方法调用 draw()方法发起绘制该 View 树，值得注意的是每次发起绘
图时，并不会重新绘制每个 View 树的视图，而只会重新绘制那些“需要重绘”的视图，View 类内部变量包含了一个
标志位 DRAWN，当该视图需要重绘时，就会为该 View 添加该标志位。

17. Handler 机制
    Android 中主线程也叫 UI 线程，那么从名字上我们也知道主线程主要是用来创建、更新 UI 的，而其他耗时操作，比如网络访问，或者文件处理，多媒体处理等都需要在子线程中操作，之所以在子线程中操作是为了保证 UI 的流畅程度，手机显示的刷新频率是 60Hz，也就是一秒钟刷新 60 次，每 16.67 毫秒刷新一次，为了不丢帧，那么主线程处理代码最好不要超过 16 毫秒。当子线程处理完数据后，为了防止 UI 处理逻辑的混乱，Android 只允许主线程修改 UI，那么这时候就需要 Handler 来充当子线程和主线程之间的桥梁了。我们通常将 Handler 声明在 Activity 中，然后覆写 Handler 中的 handleMessage 方法,当子线程调用handler.sendMessage()方法后 handleMessage 方法就会在主线程中执行。这里面除了 Handler、Message 外还有隐藏的 Looper 和 MessageQueue 对象。
    在主线程中 Android 默认已经调用了 Looper.preper()方法，调用该方法的目的是在 Looper 中创建MessageQueue 成员变量并把 Looper 对象绑定到当前线程中。当调用 Handler sendMessage（对象）方法的时候就将 Message 对象添加到了 Looper 创建的 MessageQueue 队列中，同时给 Message 指定了 target 对象，其实这个 target 对象就是 Handler 对象。主线程默认执行了Looper.looper（）方法，该方法从 Looper 的成员变量MessageQueue 中取出 Message，然后调用 Message 的 target 对象的 handleMessage()方法。这样就完成了整个消息机制。

18. 事件分发中的 2.1 事件分发中的 onTouch onTouch onTouch 和 onTouchEvent onTouchEvent onTouchEvent 有什么区别，又该如何使用？
    这两个方法都是在 View 的 dispatchTouchEvent 中调用的onTouch 优先于 onTouchEvent 执行。如果在onTouch 方法中通过返回 true 将事件消费掉，onTouchEvent 将不会再执行。
    另外需要注意的是，onTouch 能够得到执行需要两个前提条件，第一 mOnTouchListener 的值不能为空，第二当前点击的控件必须是 enable 的。因此如果你有一个控件是非 enable 的，那么给它注册 onTouch 事件将永远得不到执行。对于这一类控件，如果我们想要监听它的 touch 事件，就必须通过在该控件中重写 onTouchEvent 方法来实现。

19. 讲一下android中进程的优先级？
    前台进程
    可见进程
    服务进程
    后台进程
    空进程

20. Map、Set、List、Queue、Stack的特点与用法。
    Collection 是对象集合， Collection 有两个子接口 List 和 Set
    List 可以通过下标 (1,2..) 来取得值，值可以重复。
    而 Set 只能通过游标来取值，并且值是不能重复的。
    ArrayList ， Vector ， LinkedList 是 List 的实现类。
    ArrayList 是线程不安全的， Vector 是线程安全的，这两个类底层都是由数组实现的。
    LinkedList 是线程不安全的，底层是由链表实现的。
    Map 是键值对集合：
    HashTable 和 HashMap 是 Map 的实现类。
    HashTable 是线程安全的，不能存储 null 值。
    HashMap 不是线程安全的，可以存储 null 值。
    Stack类：继承自Vector，实现一个后进先出的栈。提供了几个基本方法，push、pop、peak、empty、search等。
    Queue接口：提供了几个基本方法，offer、poll、peek等。已知实现类有LinkedList、PriorityQueue等。
    21.Java中==和equals的区别，equals和hashCode的区别
    java中的数据类型，可分为两类：
    a. 基本数据类型：byte short long int char double boolean float .它们之间的比较应当用（＝＝），比较的是他们的值。
    b. 复合数据类型(类) :当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。
    equals方法：
    JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
    hashCode 方法：
    如果两个对象根据equals()方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。
    如果两个对象根据equals()方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生相同的整数结果。
    从而在集合操作的时候有如下规则：
    将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。

Android性能优化

1. 节制的使用Service,当启动一个Service时，系统会倾向于将这个Service所依赖的进程进行保留，系统可以在LRUcache当中缓存的进程数量也会减少，导致切换程序的时候耗费更多性能。我们可以使用IntentService，当后台任务执行结束后会自动停止，避免了Service的内存泄漏。
   知晓内存的开支情况

• 使用枚举通常会比使用静态常量消耗两倍以上的内存，尽可能不使用枚举
• 任何一个Java类，包括匿名类、内部类，都要占用大概500字节的内存空间
• 任何一个类的实例要消耗12-16字节的内存开支，因此频繁创建实例也是会在一定程序上影响内存的
• 使用HashMap时，即使你只设置了一个基本数据类型的键，比如说int，但是也会按照对象的大小来分配内存，大概是32字节，而不是4字节，因此最好使用优化后的数据集合
  避免创建不必要的对象
• 如果有需要拼接的字符串，那么可以优先考虑使用StringBuffer或者StringBuilder来进行拼接，而不是加号连接符，因为使用加号连接符会创建多余的对象，拼接的字符串越长，加号连接符的性能越低。
• 当一个方法的返回值是String的时候，通常需要去判断一下这个String的作用是什么，如果明确知道调用方会将返回的String再进行拼接操作的话，可以考虑返回一个StringBuffer对象来代替，因为这样可以将一个对象的引用进行返回，而返回String的话就是创建了一个短生命周期的临时对象。
• 在没有特殊原因的情况下，尽量使用基本数据类型来代替封装数据类型，int比Integer要更加有效，其它数据类型也是一样。
  仅在需要时才加载布局
  举例：填信息时不是需要全部填的，有一个添加更多字段的选项，当用户需要添加其他信息的时候，才将另外的元素显示到界面上。用VISIBLE性能表现一般，可以用ViewStub。ViewStub也是View的一种，但是没有大小，没有绘制功能，也不参与布局，资源消耗非常低，可以认为完全不影响性能。

<ViewStub   
        android:id="@+id/view_stub"  
        android:layout="@layout/profile_extra"  
        android:layout_width="match_parent"  
        android:layout_height="wrap_content"  
        />  

public void onMoreClick() {  
    ViewStub viewStub = (ViewStub) findViewById(R.id.view_stub);  
    if (viewStub != null) {  
        View inflatedView = viewStub.inflate();  
        editExtra1 = (EditText) inflatedView.findViewById(R.id.edit_extra1);  
        editExtra2 = (EditText) inflatedView.findViewById(R.id.edit_extra2);  
        editExtra3 = (EditText) inflatedView.findViewById(R.id.edit_extra3);  
    }  
}  

为什么在Service中创建子线程而不是Activity中?

这是因为Activity很难对Thread进行控制，当Activity被销毁之后，就没有任何其它的办法可以再重新获取到之前创建的子线程的实例。而且在一个Activity中创建的子线程，另一个Activity无法对其进行操作。但是Service就不同了，所有的Activity都可以与Service进行关联，然后可以很方便地操作其中的方法，即使Activity被销毁了，之后只要重新与Service建立关联，就又能够获取到原有的Service中Binder的实例。因此，使用Service来处理后台任务，Activity就可以放心地finish，完全不需要担心无法对后台任务进行控制的情况。

哪些操作会导致ANR 在主线程执行以下操作：

1. 高耗时的操作，如图像变换 2. 磁盘读写，数据库读写操作 3. 大量的创建新对象
   String、StringBuilder、StringBuffer、CharSequence区别
   1)CharSequence接口:是一个字符序列.String StringBuilder 和 StringBuffer都实现了它.

2. String类:是常量,不可变.
3. StringBuilder类;只可以在单线程的情况下进行修改(线程不安全).
4. StringBuffer类:可以在多线程的情况下进行改变(线程安全). 5)Stringbuilder比StringBuffer效率高,应该尽量使用StringBuilder.

1.CharSequence是一个java接口，代表一个char序列，String、StringBuilder、StringBuffer都实现了该接口，CharSequence实例通过调用toString方法可转化为String对象。
2.String类是final的，不可派生子类，其内部封装的是char[]，另外，android下的String类和jdk中的String类是有区别的，android下的String类中部分API通过native方法实现，效率相对高一些。
3.String使用'+'进行字符串拼接时，在编译期会转化为StringBuilder#append方式
4.String在内存中有一个常量池，两个相同的串在池中只有一份实例(String s = "abc"方式或者String#intern方式会在池中分配)，使用new String方式会在heap中分配，每次创建都是一个全新的实例。
5.StrigBuilder & StringBuffer都是可扩展的串，提供了一系列apped方法用于拼接不同类型对象
6.StringBuffer于jdk1.0引入，线程安全（多线程场景下使用），StringBuilder于jdk1.5引入，线程不安全，因而效率更高。
7.StringBuilder & StringBuffer初始容量都为16，开发者应该指定其容量，以避免多次扩容所带来的性能问题。

要做一个尽可量流畅的ListView，你可以做到的优化手段是什么？越详细越多手段越好

复用convertView
使用ViewHolder
滑动时不加载图片
Item中有图片时 异步加载 并且对图片进行适当压缩
分批，分页加载

Java中反射的作用是什么?什么时候会用到

对于任意一个类，都能够知道这个类的所有属性和方法；
对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能：
a)在运行时判断任意一个对象所属的类；
b)在运行时构造任意一个类的对象；
c)在运行时判断任意一个类所具有的成员变量和方法；
d)在运行时调用任意一个对象的方法；生成动态代理。

Java中有内存泄露吗？举一些例子？

1.查询数据库没有关闭游标

2. 构造Adapter时，没有使用缓存的 convertView
3. Bitmap对象不再使用时调用recycle()释放内存
4. 无用时没有释放对象的引用
5. 在Activity中使用非静态的内部类，并开启一个长时间运行的线程，因为内部类持有Activity的引用，会导致Activity本来可以被gc时却长期得不到回收
   6.使用Handler处理消息前，Activity通过例如finish()退出，导致内存泄漏
   7.动态注册广播在Activity销毁前没有unregisterReceiver
   如何缩减APK包大小
   代码
   保持良好的编程习惯，不要重复或者不用的代码，谨慎添加libs，移除使用不到的libs。
   使用proguard混淆代码，它会对不用的代码做优化，并且混淆后也能够减少安装包的大小。
   native code的部分，大多数情况下只需要支持armabi与x86的架构即可。如果非必须，可以考虑拿掉x86的部分。
   资源
   使用Lint工具查找没有使用到的资源。去除不使用的图片，String，XML等等。
   assets目录下的资源请确保没有用不上的文件。
   生成APK的时候，aapt工具本身会对png做优化，但是在此之前还可以使用其他工具如tinypng对图片进行进一步的压缩预处理。
   jpeg还是png，根据需要做选择，在某些时候jpeg可以减少图片的体积。
   对于9.png的图片，可拉伸区域尽量切小，另外可以通过使用9.png拉伸达到大图效果的时候尽量不要使用整张大图。
   策略
   有选择性的提供hdpi，xhdpi，xxhdpi的图片资源。建议优先提供xhdpi的图片，对于mdpi，ldpi与xxxhdpi根据需要提供有差异的部分即可。
   尽可能的重用已有的图片资源。例如对称的图片，只需要提供一张，另外一张图片可以通过代码旋转的方式实现。
   能用代码绘制实现的功能，尽量不要使用大量的图片。例如减少使用多张图片组成animate-list的AnimationDrawable，这种方式提供了多张图片很占空间。

声明ViewHolder内部类时，为什么建议使用static关键字

这个是考静态内部类和非静态内部类的主要区别之一。非静态内部类会隐式持有外部类的引用，就像大家经常将自定义的adapter在Activity类里，然后在adapter类里面是可以随意调用外部activity的方法的。当你将内部类定义为static时，你就调用不了外部类的实例方法了，因为这时候静态内部类是不持有外部类的引用的。声明ViewHolder静态内部类，可以将ViewHolder和外部类解引用。大家会说一般ViewHolder都很简单，不定义为static也没事吧。确实如此，但是如果你将它定义为static的，说明你懂这些含义。万一有一天你在这个ViewHolder加入一些复杂逻辑，做了一些耗时工作，那么如果ViewHolder是非静态内部类的话，就很容易出现内存泄露。如果是静态的话，你就不能直接引用外部类，迫使你关注如何避免相互引用。 所以将 ViewHolder内部类 定义为静态的，是一种好习惯.

java是如何管理内存的

Java的内存管理就是对象的分配和释放问题。（两部分）

分配 ：内存的分配是由程序完成的，程序员需要通过关键字new 为每个对象申请内存空间 (基本类型除外)，所有的对象都在堆 (Heap)中分配空间。

释放 ：对象的释放是由垃圾回收机制决定和执行的，这样做确实简化了程序员的工作。但同时，它也加重了JVM的工作。因为，GC为了能够正确释放对象，GC必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都需要进行监控。

JVM的内存区域组成

java把内存分两种：一种是栈内存，另一种是堆内存
1。在函数中定义的基本类型变量和对象的引用变量都在函数的栈内存中分配；
2。堆内存用来存放由new创建的对象和数组以及对象的实例变量 在函数（代码块）中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量所分配的内存空间；在堆中分配的内存由java虚拟机的自动垃圾回收器来管理.

堆和栈的优缺点
堆的优势是可以动态分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的。
缺点就是要在运行时动态分配内存，存取速度较慢； 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。
另外，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。

垃圾回收机制：

（问题一：什么叫垃圾回收机制？）
垃圾回收是一种动态存储管理技术，它自动地释放不再被程序引用的对象，按照特定的垃圾收集算法来实现资源自动回收的功能。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用，以免造成内存泄露。
（问题二：java的垃圾回收有什么特点？）
JAVA语言不允许程序员直接控制内存空间的使用。内存空间的分配和回收都是由JRE负责在后台自动进行的，尤其是无用内存空间的回收操作(garbagecollection,也称垃圾回收)，只能由运行环境提供的一个超级线程进行监测和控制。
（问题四：什么样的对象符合垃圾回收条件？） 当没有任何获得线程能访问一个对象时，该对象就符合垃圾回收条件。
（问题五：垃圾回收器是怎样工作的？）
垃圾回收器如发现一个对象不能被任何活线程访问时，他将认为该对象符合删除条件，就将其加入回收队列，但不是立即销毁对象，何时销毁并释放内存是无法预知的。垃圾回收不能强制执行，然而Java提供了一些方法（如：System.gc()方法），允许你请求JVM执行垃圾回收，而不是要求，虚拟机会尽其所能满足请求，但是不能保证JVM从内存中删除所有不用的对象。
（问题六：一个java程序能够耗尽内存吗？） 可以。垃圾收集系统尝试在对象不被使用时把他们从内存中删除。然而，如果保持太多活的对象，系统则可能会耗尽内存。垃圾回收器不能保证有足够的内存，只能保证可用内存尽可能的得到高效的管理。
（问题七：如何显示的使对象符合垃圾回收条件？） （1） 空引用 ：当对象没有对他可到达引用时，他就符合垃圾回收的条件。也就是说如果没有对他的引用，删除对象的引用就可以达到目的，因此我们可以把引用变量设置为null，来符合垃圾回收的条件。
StringBuffer sb = new StringBuffer("hello");
System.out.println(sb);
sb=null;
（2） 重新为引用变量赋值：可以通过设置引用变量引用另一个对象来解除该引用变量与一个对象间的引用关系。
StringBuffer sb1 = new StringBuffer("hello");
StringBuffer sb2 = new StringBuffer("goodbye");
System.out.println(sb1);
sb1=sb2;//此时"hello"符合回收条件
（3） 方法内创建的对象：所创建的局部变量仅在该方法的作用期间内存在。一旦该方法返回，在这个方法内创建的对象就符合垃圾收集条件。有一种明显的例外情况，就是方法的返回对象。
public static void main(String[] args) {
Date d = getDate();
System.out.println("d = " + d);
}
private static Date getDate() {
Date d2 = new Date();
StringBuffer now = new StringBuffer(d2.toString());
System.out.println(now);
return d2;
}
（4） 隔离引用：这种情况中，被回收的对象仍具有引用，这种情况称作隔离岛。若存在这两个实例，他们互相引用，并且这两个对象的所有其他引用都删除，其他任何线程无法访问这两个对象中的任意一个。也可以符合垃圾回收条件。
public class Island {
Island i;
public static void main(String[] args) {
Island i2 = new Island();
Island i3 = new Island();
Island i4 = new Island();
i2.i=i3;
i3.i=i4;
i4.i=i2;
i2=null;
i3=null;
i4=null;
}
}