大家都用过ViewPager吧😄，使用ViewPager时，需要给它配一个Adapter，通常我们要继承下面三个Adapter来，分别是：

———>最基本的PagerAdapter

——————>继承PagerAdapter的FragmentPagerAdapter

——————>继承PagerAdapter的FragmentStatePagerAdapter

那么这三个Adapter有什么区别，我们应该怎么选择呢？

1.关于PagerAdapter

首先，我们知道如果继承了PagerAdapter，需要我们实现下面两个方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/**
 * Return the number of views available.
 */
public abstract int getCount();


/**
 * Create the page for the given position.  The adapter is responsible
 * for adding the view to the container given here, although it only
 * must ensure this is done by the time it returns from
 * {@link #finishUpdate(ViewGroup)}.
 *
 * @param container The containing View in which the page will be shown.
 * @param position The page position to be instantiated.
 * @return Returns an Object representing the new page.  This does not
 * need to be a View, but can be some other container of the page.
 */
public Object instantiateItem(ViewGroup container, int position) {
    return instantiateItem((View) container, position);
}

第一个是要告诉ViewPager一共有几个页面，第二个则是ViewPager需要加载页面了，你需要根据position创建不同的页面对象，这里通常是View对象。

当然，如果你的ViewPager中内容比较复杂，需要用Fragment来自动管理其生命周期，那么可以使用FragmentPagerAdapter和FragmentStatePagerAdapter中的一种，那么他俩有什么区别呢？

首先我们看一下FragmentPagerAdapter的instantiateItem和destroyItem方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

 	@Override
   public Object instantiateItem(ViewGroup container, int position) {
       ...
       final long itemId = getItemId(position);

       // Do we already have this fragment?
       String name = makeFragmentName(container.getId(), itemId);
       Fragment fragment = mFragmentManager.findFragmentByTag(name);
       if (fragment != null) {
           if (DEBUG) Log.v(TAG, "Attaching item #" + itemId + ": f=" + fragment);
           mCurTransaction.attach(fragment);
       } else {
           fragment = getItem(position);
           if (DEBUG) Log.v(TAG, "Adding item #" + itemId + ": f=" + fragment);
           mCurTransaction.add(container.getId(), fragment,
                   makeFragmentName(container.getId(), itemId));
       }
      ...
       return fragment;
   }


   @Override
   public void destroyItem(ViewGroup container, int position, Object object) {
       if (mCurTransaction == null) {
           mCurTransaction = mFragmentManager.beginTransaction();
       }
       if (DEBUG) Log.v(TAG, "Detaching item #" + getItemId(position) + ": f=" + object
               + " v=" + ((Fragment)object).getView());
       mCurTransaction.detach((Fragment)object);
   }

public long getItemId(int position) {
       return position;
   }


   private static String makeFragmentName(int viewId, long id) {
       return "android:switcher:" + viewId + ":" + id;
   }

可以看出instantiateItem方法在添加Fragment时，会带一个Fragment的名字，其实就是Tag：

1

mCurTransaction.add(container.getId(), fragment, makeFragmentName(container.getId(), itemId));

这个Tag是根据一定规则从makeFragmentName中获得的，这里唯一变化的就是id，默认的id可从getItemId(position)中看到，就是当前的position，保证了每个fragment的tag是唯一的。

当ViewPager通过instantiateItem获取Fragment的时候，会先根据之前设置的Tag找一下这个Fragment存不存在：

1

mFragmentManager.findFragmentByTag(name)

根据获取到的Fragment有两种添加方式，如果根据Tag找到了之前存在的Fragment，就attach上去：

1

mCurTransaction.attach(fragment);

如果没找到，那就把新创建的Fragment add上去:

1

mCurTransaction.add(container.getId(), fragment, makeFragmentName(container.getId(), itemId));

当不用这个Fragment的时，会调用destroyItem方法，可以看到这里是detach掉了Fragment，并没有销毁。

综上，一个页面只会创建一次，创建时根据当前的position给Fragment设置一个Tag，当不需要时只是把Fragmetn detach掉，并不会销毁，下次需要时通过Tag复用Fragment。

所以，如果你有大量的Fragment要展示，FragmentPagerAdapter会持有每一个Fragment不释放，最终走向OOM。

所以，无论使用PagerAdapter还是FragmentPagerAdapter，有多少页面，就会创建多少页面对象，页面很多的情况下，会非常占用内存，虽然这样，但是它们也有各自的应用场景，例如，App的首次安装的启动引导页面个数是固定的，而且如果比较复杂，通常做成Fragment，这时使用FragmentPagerAdapter较为合适；而如果页面中有需要自动轮播卡片的地方，则可以使用PagerAdapter实现，因为其页面一般都是View，结构简单，数量也是固定的。

那如果我需要做一个可以无限滑动的卡片，就需要用到FragmentStatePagerAdapter了，我们看一下FragmentStatePagerAdapter的instantiateItem和destroyItem方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

/**
 * Return the Fragment associated with a specified position.
 */
public abstract Fragment getItem(int position);

@Override
public Object instantiateItem(ViewGroup container, int position) {
    ...
    
    if (mCurTransaction == null) {
        mCurTransaction = mFragmentManager.beginTransaction();
    }

    Fragment fragment = getItem(position);
    while (mFragments.size() <= position) {
        mFragments.add(null);
    }
    
 	...
    mCurTransaction.add(container.getId(), fragment);

    return fragment;
}

@Override
public void destroyItem(ViewGroup container, int position, Object object) {
    Fragment fragment = (Fragment) object;
    ...
    mCurTransaction.remove(fragment);
}

可以看到，FragmentStatePagerAdapter在初始化页面时，通过getItem这个抽象方法来获得Fragment，并将其add到容器里，而不用的时候直接remove掉，这样就不会一直占用Fragment，可以实现无限滑动，唯一关心的就是在getItem中创建一个Fragment就可以了。

以上就是我对三种PagerAdapter的简单理解。在使用ViewPager的过程中，除了adapter的选择，还需要到了下面的问题。

2.常见的两个问题小析

1.notifyDataSetChanged()后页面没有刷新的问题

这个问题主要是由于当数据更新时，ViewPager会调用dataSetChanged方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

void dataSetChanged() {
    // This method only gets called if our observer is attached, so mAdapter is non-null.

  	...
    for (int i = 0; i < mItems.size(); i++) {
        final ItemInfo ii = mItems.get(i);
        final int newPos = mAdapter.getItemPosition(ii.object);

        if (newPos == PagerAdapter.POSITION_UNCHANGED) {
            continue;
        }

        if (newPos == PagerAdapter.POSITION_NONE) {
            mItems.remove(i);
            i--;

            if (!isUpdating) {
                mAdapter.startUpdate(this);
                isUpdating = true;
            }

            mAdapter.destroyItem(this, ii.position, ii.object);
            needPopulate = true;

            if (mCurItem == ii.position) {
                // Keep the current item in the valid range
                newCurrItem = Math.max(0, Math.min(mCurItem, adapterCount - 1));
                needPopulate = true;
            }
            continue;
        }

     ...
    }

   ...
}

这个方法会调用adapter的getItemPosition()来获得object的位置情况是否发生变化，如果不发生变化就不更新了，如果而这个方法默认是返回的就是POSITION_UNCHANGED：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

 /**
 * Called when the host view is attempting to determine if an item's position
 * has changed. Returns {@link #POSITION_UNCHANGED} if the position of the given
 * item has not changed or {@link #POSITION_NONE} if the item is no longer present
 * in the adapter.
 *
 * <p>The default implementation assumes that items will never
 * change position and always returns {@link #POSITION_UNCHANGED}.
 *
 * @param object Object representing an item, previously returned by a call to
 *               {@link #instantiateItem(View, int)}.
 * @return object's new position index from [0, {@link #getCount()}),
 *         {@link #POSITION_UNCHANGED} if the object's position has not changed,
 *         or {@link #POSITION_NONE} if the item is no longer present.
 */
public int getItemPosition(Object object) {
    return POSITION_UNCHANGED;
}

所以要想每次刷新都让页面更新，需要在adapter中重写getItemPosition方法，并返回POSITION_NONE就可以了：

1
2
3
4
5

@Override
public int getItemPosition(Object object) {
    return POSITION_NONE;
}

2.初始化数据时不会调用OnPageChangeListener

相信大家都遇到过这种情况，就是ViewPager初始化时并不会调用OnPageChangeListener，所以很多时候我们都是手动调用第一页的onPageSelected方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

  private ViewPager.OnPageChangeListener onPageChangeListener = new ViewPager.OnPageChangeListener() {
      @Override
      public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {

      }

      @Override
      public void onPageSelected(int position) {

      }

      @Override
      public void onPageScrollStateChanged(int state) {

      }
  };

  public void OnCreate(){
      ...
      mViewPager.setOnPageChangeListener(onPageChangeListener);
onPageChangeListener.onPageSelected(0);  // 手动调用第一页
      ...
  }

但是如果如果你使用的是FragmentPagerAdapter时，会发现在onPageSelected(0)时，会发现Fragment还没有创建成功，这时候会出现NPE(NullPointerException)。所以这时候可以这样写：

1
2
3
4
5
6

mViewPager.post(new Runnable(){
@Override
    public void run() {
        onPageChangeListener.onPageSelected(0);  // 手动调用第一页
    }
});

这样就会在viewpager的UI事件队列完成后处理onPageSelected方法的内容，这个时候Fragment已经好了。

但是，虽然这样，讲要进行的工作交给post会打乱同步时序，让要做的事充满了不确定性，我不知道它什么时候能调用onPageSelected方法。而且这样做也存在另外一个问题，当使用notifyDataSetChanged()刷新数据时，还是不会调用当前页的onPageSelected来更新当前页面，所以我更倾向于下面这种方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

public class MyPagerAdapter extends FragmentStatePagerAdapter {
    ...
        
    private Object lastPrimaryItem;
    
    private OnPageSwitchListener onPageSwitchListener;
    public MyPagerAdapter(FragmentManager fm, OnPageSwitchListener onPageSwitchListener) {
        super(fm);
        this.onPageSwitchListener = onPageSwitchListener;
    }
    
    @Override
    public void setPrimaryItem(ViewGroup container, int position, Object object) {
        super.finishUpdate(container);
        super.setPrimaryItem(container, position, object);
        if (object == lastPrimaryItem) {
            return;  // setPrimaryItem会多次调用，过滤掉多余的调用
        }
        lastPrimaryItem = object;
        MyFragment fragment = (MyFragment)object;
        if (onPageSwitchListener != null && fragment != null) {
            onPageSwitchListener.onPageSwitch(position, fragment);
        }
    }

    @Override
    public void finishUpdate(ViewGroup container) {
		// 这里将finishUpdate放到setPrimaryItem之前执行，见上面的方法👆
        // 原因是finishUpdate后的Fragment才算正式可以用了
    }
    
    public interface OnPageSwitchListener{
        void onPageSwitch(int position, MyFragment fragment);
    }
}

class MyActivity extends Activity implements MyPagerAdapter.OnPageSwitchListener{

    @Override
    public void onPageSwitch(int position, MyFragment fragment) {
    	// Do whatever you like here. :)
    }
}

简单说就是，PagerAdapter中有一个重要的方法叫setPrimaryItem，当一个页面显示的时候都会调用这个方法（多次），通过一些简单的处理，可以实现与mViewPager.setOnPageChangeListener()类似的功能，这样就不用每次调用onPageChangeListener.onPageSelected(0)或者使用Post操作了。

以上分析较为肤浅，有问题欢迎指正、补充，谢谢🙏

参考

[1] https://stackoverflow.com/questions/16074058/onpageselected-doesnt-work-for-first-page

[2] https://stackoverflow.com/questions/11794269/onpageselected-isnt-triggered-when-calling-setcurrentitem0

正则表达式是计算机世界里的基础技能，很多东西都是建立在正则表达式之上。学会使用正则表达式会帮助你理解更多，之前对正则表达式总是非常敬畏，感觉很难上手，直到看了老姚的《JavaScript 正则表达式迷你书》，才打开了新世界的大门，有时间的朋友可以去读一下，不要被书名中的JavaScript吓到，这本书其实跟某种语言关系不大。任意门

下面讲我认为书中较为重要的点记在下面：

首先，正则是什么？正则是匹配模式，要么匹配字符，要么匹配位置。（匹配可以理解为搜索的意思）

匹配字符：

一个正则匹配的字符串，具体到某一位字符时，它可以不是某个确定的字符，可以有多种可能。

其实现的方式是使用字符组。譬如[abc]，表示该字符是可以字符“a”、“b”、“c”中的任何一个，中括号里可以写任意字符，包括空格，问号等。

匹配位置：

一个正则可匹配的字符串的长度不是固定的，可以是多种情况的。

其实现的方式是使用量词。表示譬如{m,n}，表示连续出现最少m次，最多n次

其实只要明白了匹配位置的方法{m,n}和匹配字符的方法[这里可以写任意多的字符]，就可以实现99.999%的正则表达式问题。

至于其他的你看到关于正则表达式的知识都是建立在这两个基础能力之上的，要么是为了方便，创建了几个简单的写法，例如[0-5]=[012345]，又例如\d=[0-9]，这样就不用在方括号里写太多的字符，同时也增强了可读性。

下面就介绍一些为了方便实现上面两种匹配而产生的各种简写：

1.表示字符

如果字符组里的字符特别多的话，怎么办？假如我想匹配所有的字符，总不能把所有的字符都输入到中括号内吧？

所以，为了解决这个问题，正则表达式也可以写成这样的缩写：

• 比如[123456abcdefGHIJKLM]，可以写成**[1-6a-fG-M]*。用连字符”-“来省略和简写。（那么要匹配“a”、“-”、“z”这三者中任意一个字符，该怎么做呢？可以写成如下的方式：[-az]或[az-]或[a-z]。即要么放在开头，要么放在结尾，要么转义。）*

• **[^abc]**，表示是一个除”a”、”b”、”c”之外的任意一个字符。字符组的第一位放”^”（脱字符），表示求反的概念

• \d 就是[0-9]。表示是一位数字。记忆方式：其英文是digit（数字）。

• \D 就是[^0-9]。表示除数字外的任意字符。

• \w 就是[0-9a-zA-Z_]。表示数字、大小写字母和下划线。记忆方式：w是word的简写，也称单词字符。

• \W 就是[^0-9a-zA-Z_]。非单词字符。

• \s 就是[ \t\v\n\r\f]。表示空白符，包括空格、水平制表符、垂直制表符、换行符、回车符、换页符。记忆方式：s是space character的首字母。

• \S 就是[^ \t\v\n\r\f]。 非空白符。

• . 就是[^\n\r\u2028\u2029]。通配符，表示几乎任意字符。换行符、回车符、行分隔符和段分隔符除外。记忆方式：想想省略号…中的每个点，都可以理解成占位符，表示任何类似的东西。

  如果要匹配任意字符怎么办？可以使用[\d\D]、[\w\W]、[\s\S]和[^]中任何的一个。

2.表示位置（数量）

• {m,} 表示至少出现m次。

• {m} 等价于{m,m}，表示出现m次。

• ? 等价于{0,1}，表示出现或者不出现。记忆方式：问号的意思表示，有吗？

• + 等价于{1,}，表示出现至少一次。记忆方式：加号是追加的意思，得先有一个，然后才考虑追加。

• *** ** 等价于{0,}，表示出现任意次，有可能不出现。记忆方式：看看天上的星星，可能一颗没有，可能零散有几颗，可能数也数不过来。

举例说明🌰

明白了基本用法，就需要几个例子来实验一下了。如果要在目录中搜索文件夹名字中有Util的文件，而且只显示DreamReader文件夹中的结果，那我可以这样搜:

1

find ./* | grep -e ".*Dream.*StringUtil"

今天发现项目的报错记录中排名第一的是ArrayIndexOutOfBoundsException错误，影响用户84，发生次数129。

报错堆栈如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1 android.text.StaticLayout.getLineTop(StaticLayout.java:878)
2 android.widget.TextView.getExtendedPaddingTop(TextView.java:1966)
3 android.widget.TextView.bringTextIntoView(TextView.java:7291)
4 android.widget.TextView.onPreDraw(TextView.java:5107)
5 android.view.ViewTreeObserver.dispatchOnPreDraw(ViewTreeObserver.java:944)
6 android.view.ViewRootImpl.performTraversals(ViewRootImpl.java:2348)
7 android.view.ViewRootImpl.doTraversal(ViewRootImpl.java:1292)
8 android.view.ViewRootImpl$TraversalRunnable.run(ViewRootImpl.java:6598)
9 android.view.Choreographer$CallbackRecord.run(Choreographer.java:800)
10 android.view.Choreographer.doCallbacks(Choreographer.java:603)
11 android.view.Choreographer.doFrame(Choreographer.java:572)
12 android.view.Choreographer$FrameDisplayEventReceiver.run(Choreographer.java:786)
13 android.os.Handler.handleCallback(Handler.java:815)
14 android.os.Handler.dispatchMessage(Handler.java:104)
15 android.os.Looper.loop(Looper.java:194)
16 android.app.ActivityThread.main(ActivityThread.java:5682)
17 java.lang.reflect.Method.invoke(Native Method)
18 java.lang.reflect.Method.invoke(Method.java:372)

从错误堆栈里并没有找到特别有用的信息。

于是去看了下报错的设备信息：

可谓是五花八门，看来也不是特定机型或者特定系统的问题。

从日志和设备信息都分析不出问题，只能靠google了，通过不断的搜索，渐渐发现类似的崩溃跟TextView的两个属性有关系，分别是:

• Android:maxLines
• Android:ellipsize

根据查询的信息，得出了下面的结论：

如果同时设置了ellipsize和maxLine=1,就会在某些机型上产生崩溃（不是必先），报ArrayIndexOutOfBoundsException的异常。解决办法就是将maxLine=1换成已经废弃的singleLine=true。这是Android系统的一个bug，目前还没有解决。

下面查询到的相关记录：

If you try to use maxLines=1 with ellipsize, you shall get the following lint error (refer to this discussion)

Combining ellipsize and maxLines=1 can lead to crashes on some devices. Earlier versions of lint recommended replacing singleLine=true with maxLines=1 but that should not be done when using ellipsize

来源：https://code.luasoftware.com/tutorials/android/android-textview-singleline-with-ellipsis/

问题 Crash when using ellipsize=”start” (Jelly Bean) 的回复

ri...@gmail.com ri...@gmail.com #3Jul 12, 2012 08:17AM

I do notice that changing android:lines=”1” to android:singleLine=”true” causes the crash not to happen.

来源:https://issuetracker.google.com/issues/36950033

I faced what I suspect is the same problem in my own app. For me, it was happening because I was using android:ellipsize="start" without also using android:singleLine="true".

We had switched all of our android:singleLine="true" attributes to the recommended android:maxLines="1", but it turns out that there’s a bug in how the system calculates the ellipsis that is triggered if singleLine isn’t present.

So I believe you can solve this issue by simply adding android:singleLine="true" to your TextViews that are using ellipsize attrs.

来源：https://stackoverflow.com/questions/45487427/crashlytics-reporting-multiples-issues-for-textview-makesinglelayout

第一次见Lamda表达式

第一次看到这行代码的时候，我是百思不得姐：

1

Toolkit.let(mUserTabFragment, f -> f.setUserVisibleHint(true));

点击进入let函数看到其定义如下：

1
2
3
4
5
6

public static <T> void let(@Nullable T input, Consumer<T> consumer) {
    if (input == null || consumer == null) {
        return;
    }
    consumer.accept(input);
}

可以看出let的第二个参数是一个Consumer，但是上面的f->f.setUserVisibleHint(isVisibleToUser));是什么鬼，是Consumer吗？答案是 是的，这样看就明白了，首先，我们创建一个Consumer对象：

1
2
3
4
5
6

Consumer<Fragment> consumer = new Consumer<Fragment>() {
    @Override
    public void accept(Fragment f) {
		f.setUserVisibleHint(true));
    }
};

上面代码的Lamda形式为：

1

Consumer<Fragment> consumer = (f)-> f.setUserVisibleHint(true));

所以 可以直接将等号右边带入let函数的第二个参数，就变成了那个样子：

1

Toolkit.let(mUserTabFragment, f -> f.setUserVisibleHint(true));

现在应该就明白了第二个参数到底是啥了，其实就是一种Lamda表达式。

Android中动画的使用

前言：

在Android中，如果想让一个View的消失，如果没有做任何处理，直接setVisibility(View.GONE)，你会发现整个View是瞬间消失的，没有任何过度。为了让用户感知到View的消失，就要让这个View消失的时候带一个动画效果，这样可以减轻用户的焦虑感。

Android中动画的种类

Android中共有三种动画系统，分别是：

• View Animations - 最原始的Android动画，性能差而且不够灵活.Property Animations动画出现后就被废弃了。
• Property Animations - 自Android 3.0后引入的强大灵活的动画系统
• Transition Animations - 上面两种动画只是对某个View进行改变，而不会影响其所在的容器及周边的Views，而Transition动画可以适应layout的变化。默认的Transition框架支持Andorid 4.4以上的系统，使用com.android.support:transition支持库可以使Transition框架兼容到Android 4.0及以上。

Property Animation 属性动画

其中我们最常用的是Property animation，称之为，属性动画。顾名思义，属性动画可以对任意对象的任意属性在一段时长内进行渐变：

Property animations allow us to animate any property of any object from one value to another over a specified duration.

所以，属性动画除了可以对View的位置、角度做变换外，还可以对字体的大小、View的颜色等属性进行变换。

Android中常用的动画叫Property Animation（属性动画），它是出现在View Animation(视图动画) （包括 Tween Animation（补间动画）和 Frame Animation(逐帧动画)） 之后的，相比老的视图动画，Property Animation的主要优势是：

老的View Animation只是对View对象的外观进行动画操作，但是并没有真正的改变对象本身的属性。例如对某个View平移以后，只是视觉特效，并没有真正改变这个View的位置，也就是说你点击平移后的View是不能触发onClick的，因为其属性中的位置还在原来的位置(the previous animations changed the visual appearance of the target objects… but they didn’t actually change the objects themselves.)。而Property Animation除了视觉效果，还能真正的改变View的属性。而使用Property Animation不仅可以对View进行透明度渐变、缩放、平移操作，还可以对其他的一些属性进行动画操作，例如字体大小，颜色，背景等，实现炫酷的字体颜色变化，或者背景颜色变化等等。

Property Animation（属性动画）的主要实现类是：ObjectAnimation。这个类是我们实现动画最常用的类。

ObjectAnimator 动画

用法示例

ObjectAnimator的主要用法如下，假设要让一个View进行透明度从透明到不透明：

1

ObjectAnimator alphaAnim = ObjectAnimator.ofFloat(view,"Alpha", 0f, 1f) .setDuration(getResources().getInteger(R.integer.china_date_switch_btn_gone_duration));

上面代码中ofFloat就是指让这个动画按照float类型的精度去变化。ofFloat函数源码中的常用构造函数如下：

1

ofFloat(Object target, String propertyName, float... values)

第一个target是要赋予动画的对象，第二个propertyName是赋予什么动画或者对这个对象的什么属性进行变化，第三个是一个可变长度的参数，那三个点表示这个参数可以有多个，例如上面示例代码中有两个，分别是0f和1f，表示从透明变到不透明。也可以添加任何多个，例如0f, 1f, 0.5f，指的就是从透明到不透明又到半透明。

上面简单的例子就实现了透明度动画。除了透明度属性，常用的属性还有：

常用的propertyName有以下：

除了上面的属性，ObjectAnimator可以对一个对象的任意属性进行动画渐变，例如：

1
2
3

ObjectAnimator.ofFloat(mTextView,"textSize",  0, 100, 50)
                .setDuration(5000)
                .start();

这样就相当于不断调用TextView的setTextSize()方法对文字大小进行设置，就实现字体变大，再变小的动画。

但是需要注意的是，如果要对一个对象的属性进行变化，这个对象必须有公开的set的方法例如TextView有setTextSize这个方法，那么就可以用“textSize”这个属性。

这时你可能会疑惑了🤔，如果想控制的对象方法名字不是set开头，而是叫changeTextSize或者moveXPosition等，或者一个对象有set方法，但是没有public暴露给大家使用怎么办呢？

这时可以提出两种抛砖引玉的方法：

• 在对象外层包装一个类，自己写一个public的set方法控制对象的属性。
• 使用ValueAnimator。至于什么是ValueAnimator，下面就马上会讲到。

ValueAnimator

明白了怎么用，我们再简单了解一下它实现的原理，想一想怎样实现对象的属性动画呢？如果我们想实现一个1秒钟内将透明度从0变到1的动画，其实是把整个工作分成了两部分：

• 计算属性（透明度）的值。也就是这一秒内，每个时间点的属性值应该是多少，这部分工作由ValueAnimator完成。

• 设置属性（透明度）的值。将每个时间点的值设置到对象上。这部分由ObjectAnimator完成。

其实ValueAnimator就是一个时间机制，你甚至可以单纯的利用它的时间机制实现除了动画以外的其他逻辑：

1
2
3
4
5
6
7
8
9

ValueAnimator anim = ValueAnimator.ofFloat(0f, 1f);
anim.setDuration(500);
anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        public void onAnimationUpdate(ValueAnimator animation) {
            Float value = (Float) animation.getAnimatedValue();
            // do something with value...
        }
    });
anim.start();

AnimatorSet

如果需要组合多个动画，可以借助AnimatorSet进行统一管理。AnimatorSet类可以将单个的ObjectAnimator组合起来形成动画集，可以同时创建多个特效，例如，一边放大一边变透明化或者按照顺序先放大再透明化等等。通过组合不同的动画属性，可以满足生活中大部分常用的场景。其用法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

ObjectAnimator alphaAnim = ObjectAnimator.ofFloat(view,"Alpha", 0f, 1f)
        .setDuration(getResources().getInteger(R.integer.china_date_switch_btn_gone_duration));
ObjectAnimator scaleAnim = ObjectAnimator.ofFloat(view,"scaleY",  0, 1)
        .setDuration(getResources().getInteger(R.integer.china_date_switch_btn_gone_duration));
AnimatorSet fadeInAnim = new AnimatorSet();
fadeInAnim.play(alphaAnim).with(scaleAnim);
fadeInAnim.addListener(new AnimatorListenerAdapter() {
    @Override
    public void onAnimationStart(Animator animation) {
        super.onAnimationStart(animation);
        view.setVisibility(View.VISIBLE);
    }
});
fadeInAnim.start();

两大神器TypeEvaluator和Interpolation

TypeEvaluator

恐怕不少刚接触ObjectAnimator的人都会想为啥ObjectAnimator后面要跟ofFloat, ofInt和ofObject，ofObject又是个什么东西呢？

如果一个动画变化的属性是数字，例如透明度就是从0到1的，ofFloat会在要求的时间范围内把每个时间点的值计算成一个个的float值，相应的，ofInt就会把属性值计算成Int值，这些都是动画系统实现的方法。那如果现在属性的变化不是时间而是Point类，那动画系统怎么知道如何计算每个时间点的Point值呢，答案是你来告诉动画系统如何计算。只要继承TypeEvaluator类，实现其中的evaluate方法即可：

1
2
3
4
5
6
7
8

public class PointEvaluator implements TypeEvaluator {
    public Object evaluate(float fraction, Object startValue, Object endValue) {
        Point startPoint = (Point) startValue;
        Point endPoint = (Point) endValue;
        return new Point(startPoint.x + fraction * (endPoint.x - startPoint.x),
                         startPoint.y + fraction * (endPoint.y - startPoint.y));
    }
}

这样就可以计算两个点之间的值了：

1
2
3

Point p0 = new Point(0, 0);
Point p1 = new Point(100, 200);
ValueAnimator anim = ValueAnimator.ofObject(new PointEvaluator(), p0, p1);

Interpolation

放大，缩小，平移等这样的动画方式非常普通，因为这些动画是线性的，也就是说在动画时间内，属性值的变化是线性变化的。大家有时会看到一些非常炫酷的动画例如，回弹，果冻效果等等，这些效果多是非线性变化的结果，如果想实现这样的效果，就用到了Interpolation（插值器）。

Android已经实现了常用的Interpolation，如：

还有AccelerateDecelerateInterpolator、AnticipateInterpolator、PathInterpolator、OvershootInterpolator、AnticipateOvershootInterpolator 、DecelerateInterpolator 、CycleInterpolator等，这些基本上涵盖了我们使用的范围。

当然，如果上面插值器不满足需求，也可以定制插值器，只需要继承BaseInterpolator并实现TimeInterpolator接口就可以了，例如OvershootInterpolator的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class OvershootInterpolator extends BaseInterpolator {
    private final float mTension;

    public OvershootInterpolator() {
        mTension = 2.0f;
    }

    public OvershootInterpolator(float tension) {
        mTension = tension;
    }

    public float getInterpolation(float t) {
        // _o(t) = t * t * ((tension + 1) * t + tension)
        // o(t) = _o(t - 1) + 1
        t -= 1.0f;
        return t * t * ((mTension + 1) * t + mTension) + 1.0f;
    }
}

这里的getInterpolation方法里是一个插值器函数，如果输入的t直接返回，那这就是一个线性插值器。这个网站看一查看插值器函数生成的曲线，安利给大家。

Android Transition Framework

上面介绍的动画针对的是某一个对象进行动画操作，但是实际应用中，我更多的使用Android的Transition动画来移动某个View。Transition动画与Property动画最大的区别就是：View动的过程中会对其周边的View产生影响。也就是说，如果我想让一个View逐渐变大，那它在变大的过程中不会覆盖在其周边的View上面，而是挤推着周围的View移动，也就是整个Layout都在变化，而这一切都是Transition框架自动实现的，开发者不需要关心实现细节。

后续补充：

https://developer.android.com/training/transitions/

https://developer.android.com/training/transitions/start-activity

https://cloud.tencent.com/info/8fb508a6e6115e59e4f151fbaadd432e.html

参考：

ObjectAnimator 基本使用 http://wiki.jikexueyuan.com/project/android-animation/7.html

Android 属性动画：这是一篇很详细的 属性动画 总结&攻略 https://blog.csdn.net/carson_ho/article/details/72909894

为什么要废弃掉Android之前的动画？https://android-developers.googleblog.com/2011/02/animation-in-honeycomb.html

查看Interpolation曲线：http://inloop.github.io/interpolator/

背景

最近在工作中解锁了一些使用Android Studio的技巧，在这里记录一下。

1. 为什么明明我的电脑剩余那么多内存，用Android Studio打开多个工程后就开始卡顿了呢？

有一次在使用Android stuido的时候发现会卡顿无比，滚动鼠标都卡，但我的机器明明配置很高，系统剩余的内存也很多啊。

于是，打开内存指示器，查看Android Studio的内存使用情况：

打开设置 -> Appearance -> Window Options -> Show memory indicator

勾选了Show memory indicator 之后，就可以在Android Studio的右下角看到内存指示器了：

双击指示器可以手动进行GC操作。这里显示的就是Android Studio占用的内存大小（左）和分配给Android Studio使用的最大内存（右）。如果发现占用内存基本上快要等于分配的最大内存的时候，说明需要分配更多的内存给Android Studio了。当时我的机器显示的是1020/1024M，这应该就是其默认分配的内存大小，基本上分配的内存已经快要用完了，这也就是为啥明明电脑内存剩余很多，但是Android Studio却很卡顿的原因。

于是，通过下面步骤来提高分配给Android的内存：

打开菜单Help->Edit Custom VM Options，这时，会在新窗口打开一个studo.vmoptions文件（如果之前没有，会新创建一个），在打开的文件中输入下面代码配置虚拟机堆栈的最大分配内存：

1

-Xmx4096m

这里可以根据自己机器的内存大小，对Android Studio进行配置，配置完成后，重启Android Studio，看到右下角的内存指示器显示的最大分配内存已经发生了变化，就说明生效了。

一、故事背景（可略过）

以前，世界上只有两种电脑：笔记本和台式机。

上帝说，要有高性能的笔记本。于是，就有了MainFramer。

我就遇到了这种情况，上班后公司配的是MacBookPro的笔记本和一个Windows的台式机（PC），我曾尝试过使用MacBook作为主力机工作，MacOS的体验非常优秀，但是唯一的不足就是其在处理大型复杂任务时的速度远不如我那台高配的台式机，编译一次工程的时间差在3分钟左右，而我每天编译上20次就能差出一个小时，有这个时间提前让我下班多好。最重要的是，我只要一点击Build，整个机器就开始满负荷运行，除了温度飙升外，CPU也被占满，这时候开个网页都卡成了幻灯片。

为了提高工作效率，我尝试一直用台式机工作，于是我的MBP吃灰了很久，这么优秀的笔记本放在那里吃灰实在是心疼。最关键的是，台式机让我完全没有工作流的感觉，当我周末无聊想充电的时候，我发现我所有想看的东西都在公司，当我一个个软件打开，一个个网页从历史记录中找到后，我发现我已经没有了学习的欲望。这时候我非常想念用笔记本时那种“合盖走人”后，回家打开盖子发现我所有的思路都还在的感觉。

于是我急切的找一种方法，让简单的任务在笔记本上来做，复杂的任务能够利用台式机完成，并且在体验上做到“无差别”。终于，我在浏览全球最大的同性社交网站时惊喜的发现了mainframer，这是一个工具，可以将编译这件占内存和CPU的事从本地电脑放到远程电脑上来做。

简单的说，你只需要一台本地机器（Local Machine：例如我的性能不咋地的MacBook）和一台远程机器（Remote Machine：性能强悍的台式机或者云主机），通过mainframer，就可以实现在本地机器上写代码，在远程机器上编译代码。你可以在笔记本上写代码，到了需要调试的时候，mainframer会快速同步代码到远程机器并进行编译，并将编译的结果返回到你的笔记本，这一切仿佛都是在你的笔记本上进行的，你可以正常的build和调试程序。这样一来，就可以享受笔记本的便捷，又能享受台式机的高性能了，美滋滋。

下面就是我配置成功后，录制的在MacBookPro上写代码，在Linux发行版Manjaro上进行Build的视频：

传送门

VIM在命令行环境中（比如操作VPS）非常实用，习惯之后对工作效率的提高大有裨益。但是剑一天不用，锈的也是很快的。前几天在终端中偶然发现了命令vimtutor，该教程非常巧妙简洁，整个教程操作一遍只需要半个小时左右，基本的操作就很熟悉了。现在将其小节汇总于下，方便记忆。

浏览命令

1. 光标在屏幕文本中的移动既可以用箭头键，也可以使用 hjkl 字母键。
   h (左移) j (下行) k (上行) l (右移)

2. 欲进入 Vim 编辑器(从命令行提示符)，请输入：vim 文件名 <回车>

3. 欲退出 Vim 编辑器，请输入 <ESC> :q! <回车> 放弃所有改动。
   或者输入 <ESC> :wq <回车> 保存改动。

4. 在正常模式下删除光标所在位置的字符，请按： x

5. 欲插入或添加文本，请输入：
   i 输入欲插入文本 <ESC> 在光标前插入文本
A 输入欲添加文本 <ESC> 在一行后添加文本

特别提示：按下 键会带您回到正常模式或者撤消一个不想输入或部分完整
的命令。

最近在小米笔记本上安装了黑苹果，从Arch Linux上转到了MacOS High Sierra。说实话，虽然在操作上很多东西还不是很习惯，但是MacOS丰富的软件和漂亮的界面以及合理的逻辑非常讨人喜欢。

很快，我也遇到了一些问题，首先是经常用到的VirtualBox虚拟机启动物理硬盘上的Windows时遇到的问题：

• 安装了双硬盘的笔记本在启动时设备符号是变化的，有时候是/dev/disk0，有时候则是/dev/disk1，导致保存的镜像文件（vmdk文件）需要重新生成。

• Mac下只要重新挂载Windows分区所在的硬盘，权限也要重新授权。否则报错：

  1 2 3 4

  VBoxManage: error: VMDK: could not open raw disk file '/dev/disk2' VBoxManage: error: Error code VERR_RESOURCE_BUSY at /Users/vbox/tinderbox/4.3-mac-rel/src/VBox/Storage/VMDK.cpp(3390) in function int vmdkCreateRawImage(VMDKIMAGE*, VBOXHDDRAW*, uint64_t) VBoxManage: error: Cannot create the raw disk VMDK: VERR_RESOURCE_BUSY VBoxManage: error: The raw disk vmdk file was not created

Android相关

Activity和Fragment的生命周期

加速Activity启动

• 精简onCreate中的代码
• 将耗时操作放到后台线程
• 优化布局文件（ Hierarchy Viewer， Layoutopt）
• 缓存ListView

Android多线程的几种方式

• Handler.sendXXXMessage()
• Handler.post(Runnable)
• Activity.runOnUIThread(Runnable)
• View.post(Runnable)
• AsyncTask