应用层的使用:

Android提供了现成android.os.PowerManager类,该类用于控制设备的电源状态的切换.

Android JDK为我们提供了4种动画效果，分别是：
 AlphaAnimation,
RotateAnimation, 
ScaleAnimation, 
TranslateAnimation.今天我想讲解的是TranslateAnimation这个动画效果。
在本文中记录下来，以便以后忘记了可以查阅。

　　TranslateAnimation是移动的动画效果。它有三个构造函数，分别是：

　　1.public　　TranslateAnimation(Context context,AttributeSet attrs)   略过

　　
       2.public　　TranslateAnimation(float fromXDelta, float toXDelta, float fromYDelta, float toYDelta)

　　这个是我们最常用的一个构造方法，

　　float fromXDelta:这个参数表示动画开始的点离当前View X坐标上的差值；

　　float toXDelta, 这个参数表示动画结束的点离当前View X坐标上的差值；

　　float fromYDelta, 这个参数表示动画开始的点离当前View Y坐标上的差值；

　　float toYDelta)这个参数表示动画开始的点离当前View Y坐标上的差值；

　　如果view在A(x,y)点 那么动画就是从B点(x+fromXDelta, y+fromYDelta)点移动到C 点(x+toXDelta,y+toYDelta)点.

　　3.public　　TranslateAnimation (int fromXType, float fromXValue, int toXType, float toXValue, int fromYType, float fromYValue, int toYType, float toYValue)

　　fromXType:第一个参数是x轴方向的值的参照(Animation.ABSOLUTE, Animation.RELATIVE_TO_SELF,or Animation.RELATIVE_TO_PARENT);

　　fromXValue:第二个参数是第一个参数类型的起始值；

　　toXType,toXValue:第三个参数与第四个参数是x轴方向的终点参照与对应值；

　　后面四个参数就不用解释了。如果全部选择Animation.ABSOLUTE，其实就是第二个构造函数。

      以x轴为例介绍参照与对应值的关系:

      如果选择参照为Animation.ABSOLUTE，那么对应的值应该是具体的坐标值，比如100到300，指绝对的屏幕像素单位

      如果选择参照为Animation.RELATIVE_TO_SELF或者 Animation.RELATIVE_TO_PARENT指的是相对于自身或父控件，对应值应该理解为相对于自身或者父控件的几倍或百分之多少。多试参数就明白了

在创建新的控件或修改现有的控件时，我们都会涉及到重写控件或View的onDraw方法。

onDraw方法会传入一个Canvas对象，它是你用来绘制控件视觉界面的画布。

在onDraw方法里，我们经常会看到调用save和restore方法，它们到底是干什么用的呢？

❑ save：用来保存Canvas的状态。save之后，可以调用Canvas的平移、放缩、旋转、错切、裁剪等操作。

❑ restore：用来恢复Canvas之前保存的状态。防止save后对Canvas执行的操作对后续的绘制有影响。

save和restore要配对使用（restore可以比save少，但不能多），如果restore调用次数比save多，会引发Error。

正则表达式的分组和引用  

组和捕获

捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：

1	((A)(B(C)))
2	\A
3	(B(C))
4	(C)

组零始终代表整个表达式。
 之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。捕获的子序列稍后可以通过 Back 引用在表达式中使用，也可以在匹配操作完成后从匹配器获取。 

引用
。。。。。。。。

非捕获 组

以 (?) 开头的组是纯的非捕获 组，它不捕获文本，也不针对组合计进行计数。

String now = "25/10/2009";
        Matcher matcher = Pattern.compile("(\\d\\d)/(\\d\\d)/(\\d\\d\\d\\d)").matcher(now);
        if (matcher.find()) {
            System.out.println(matcher.group(3) + "-" + matcher.group(2) + "-" + matcher.group(1));
        } 

 

http://www.blogjava.net/ycyk168/archive/2009/10/25/299659.html

 

正则表达式三种数量词  

Greedy 数量词   (贪婪的)!【每次取最多，不成，往出吐个，再试】! 
X?    X，一次或一次也没有 
X*    X，零次或多次X+X，一次或多次 
X{n}    X，恰好 n 次 
X{n,}    X，至少 n 次 
X{n,m}    X，至少 n 次，但是不超过 m 次 
Reluctant 数量词   （不情愿的，勉强的）!【每次取最少，不成，吸入一个，再试】! 
X??    X，一次或一次也没有 
X*?    X，零次或多次 
X+?    X，一次或多次 
X{n}?    X，恰好 n 次X 
{n,}?    X，至少 n 次 
X{n,m}?    X，至少 n 次，但是不超过 m 次 
Possessive 数量词   （独占的）  !【每次取最多，不吐】! 
X?+    X，一次或一次也没有 
X*+    X，零次或多次 
X++    X，一次或多次 
X{n}+    X，恰好 n 次 
X{n,}+    X，至少 n 次 
X{n,m}+    X，至少 n 次，但是不超过 m 次

1 Matcher m=Pattern.compile("a.*b")
2               .matcher("a====b=========b=====");
3 while(m.find()){
4       System.out.println(m.group());
5         }
6 
7 
8 输出：
9 a====b=========b

因为总是从最大 匹配开始匹配，故称贪婪。

Reluctant正好和Greedy相反，它先从最小匹配开始，先从左端吞入一个字符，然后进行匹配，若不匹配就再吞入一个字符，直到找到匹配或将整个字符串吞入为止。

1 Matcher m=Pattern.compile("a.*?b")
2                   .matcher("a====b=========b=====");
3 while(m.find()){
4         System.out.println(m.group());
5         }
6 
7 输出：
8 a====b

Possessive和Greedy的匹配方式一样，先把整个字符串吞下，然后匹配整个字符串，如果匹配，就认为匹配，如果不匹配，就认为整个字符串不匹配，它不会从右端吐出一个字符串再进行匹配，只进行一次

1 Matcher m=Pattern.compile("a.*+b")
2                    .matcher("a====b=========b=====");
3 while(m.find()){
4     System.out.println(m.group());
5         }
6 
7 输出：
8 （无输出）

*******************
我的理解是

String text = "a====b=========b";

String reg = "a.*+b";

由于.代表任意字符，字母b和=都算匹配到了模式中（.*+），最后 "a.*+b"中的b没有找到匹配字符，所以不匹配。

如果这样：

String text = "a54564b";

String reg = "a\\d*+b";

"a54564b"中字母b不能吸收进“\\d*+”，最后匹配结果是true。