Android中重要知识点

1.Handler机制

作用：

主要接受子线程发送的数据，并用此数据配合主线程更新UI。

怎么实现：

(1)UI主线程初始化第一个handler时会通过ThreadLocal创建一个Looper,(UI线程是否创建过Lppper,是，直接使用ThreadLoacal保存的UI线程对应的Looper，否，通过ThreadLoacal为UI线程创建唯一的一个Looper)。

(2) Looper初始化的时候会创建一个消息队列MessageQueue。

(3)子线程通过Handler创建一条消息，通过Handler将消息发送到UI线程的MessageQueue，UI线程对应的Looper查询消息队列是否有消息，没有，循环等待，有，UI线程调用Handler处理消息。

2.内存管理(内存泄漏，内存溢出OOM)

内存泄漏：对象在内存heap堆中中分配的空间，当不再使用或没有引用指向的情况下，仍不能被GC正常回收的情况。大量的内存泄漏会造成 OOM。

内存溢出OOM:内存溢出是指APP向系统申请超过最大阀值的内存请求，系统不会再分配多余的空间，就会造成OOM error。在我们Android平台下，多数情况是出现在图片不当处理加载的时候。

(1)static 声明变量的生命周期和app的生命周期一样的。如果大量使用，就会占据内存空间不释放。Static的合理使用一般用来修饰基本数据类型或者轻量级对象，尽量避免修饰集合或者打对象。

(2)无关引用：Context泄漏，Acticity结束掉后，由于仍被其他的对象指向，导致一直不能收回，这就导致了内存泄漏。

(3)使用softReference/weakReference:如果对内存开销比较关注的app.可以考虑使用weakReference,当GC回收扫过这块区域时，就会回收；如果不是那么关注的话，可以使用softReference,它会在内存申请不足的情况下自动释放，同样也能解决OOM。

(4)handler使用注意：如果handler还有消息需要处理但是activity页面已经结束的情况下，activity的引用其实并不会别回收，这就造成了内存泄漏。解决方案：在activity的ondestroy方法中调用handler.removeCallbacksAndMessages(null);取消所有消息的处理，包括待处理的消息。或者声明handler的内部类为static。

(5)bitmap处理：在bitmap不被使用的时候recycle掉，使用过程中，及时释放也是非常重要的。加载网络图片的时候，使用软引用或者弱引用并进行本地缓存。

(6)Cursor及时关闭：在查询SQLite数据库时，会返回一个Cursor，当查询完毕后，及时关闭。这样可以把查询的结果及时的回收掉。

(7)广播和服务:绑定广播和服务，一定要记得在不需要的时候给解绑。

(8)I/O流：读写结束，记得关闭。

(9)线程：线程不需要继续执行的时候要记得及时关闭。

3.SQLite数据库

创建表：

CREATE TABLE COMPANY(

ID INT PRIMARY KEY    NOT NULL,

NAME           TEXT    NOT NULL,

AGE            INT     NOT NULL,

ADDRESS        CHAR(50),

SALARY         REAL

);

删除表：

DROP TABLE COMPANY;

 

Insert(增):

为表中指定列添加值：

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)] 

VALUES (value1, value2, value3,...valueN);

为表中所有列添加值：

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

实例：(创建六个记录)

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)

VALUES (1, 'Paul', 32, 'California', 20000.00);

 

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)

VALUES (2, 'Allen', 25, 'Texas', 15000.00);

 

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)

VALUES (3, 'Teddy', 23, 'Norway', 20000.00);

 

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)

VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00);

 

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)

VALUES (5, 'David', 27, 'Texas', 85000.00);

 

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)

VALUES (6, 'Kim', 22, 'South-Hall', 45000.00);

 

表中现有记录如下：

ID          NAME        AGE         ADDRESS     SALARY

----------  ----------  ----------  ----------  ----------

1           Paul        32          California  20000.0

2           Allen       25          Texas       15000.0

3           Teddy       23          Norway      20000.0

4           Mark        25          Rich-Mond   65000.0

5           David       27          Texas       85000.0

6           Kim         22          South-Hall  45000.0

7           James       24          Houston     10000.0

 

Delete(删):

DELETE FROM COMPANY WHERE ID = 7;

DELETE FROM COMPANY;

 

Update(改)：

UPDATE COMPANY SET ADDRESS = ‘Texas’WHERE ID = 6;

如果您想修改 COMPANY表中ADDRESS和 SALARY列的所有值，则不需要使用 WHERE子句，UPDATE查询如下：

UPDATE COMPANY SET ADDRESS = 'Texas', SALARY = 20000.00;

 

Select(查)：

SELECT * FROM COMPANY;

SELECT ID, NAME, SALARY FROM COMPANY;

SELECT * FROM COMPANY LIMIT 6;

将产生以下结果：

ID          NAME        AGE         ADDRESS     SALARY

----------  ----------  ----------  ----------  ----------

1           Paul        32          California  20000.0

2           Allen       25          Texas       15000.0

3           Teddy       23          Norway      20000.0

4           Mark        25          Rich-Mond   65000.0

5           David       27          Texas       85000.0

6           Kim         22          South-Hall  45000.0

SELECT * FROM COMPANY LIMIT 3 OFFSET 2;

将产生以下结果：

ID          NAME        AGE         ADDRESS     SALARY

----------  ----------  ----------  ----------  ----------

3           Teddy       23          Norway      20000.0

4           Mark        25          Rich-Mond   65000.0

5           David       27          Texas       85000.0

4.xml、json解析

Xml解析：

publicvoid click(View v){

    List<GirlFriend>gfs=null;

    GirlFriendgf=null;

   

    //获取解析器

    XmlPullParserparser = Xml.newPullParser();

    //设置要解析的xml

    try {

        FileInputStream fis =openFileInput("gfs.xml");

        parser.setInput(fis, "utf-8");

        

        //获取事件的类型

        int eventType = parser.getEventType();

        //循环 解析

        while(eventType!=XmlPullParser.END_DOCUMENT) {

            

            switch(eventType) {

            caseXmlPullParser.START_TAG:

                if(parser.getName().equals("GirlFriends")) {

                    //创建集合

                    gfs=newArrayList<GirlFriend>();

                }else if(parser.getName().equals("GirlFriend")) {

                    //创建对象

                    gf=newGirlFriend();

                }else if(parser.getName().equals("name")) {

                    //把name放到 对象中

                    Stringname = parser.nextText();

                    gf.setName(name);

                }else if(parser.getName().equals("age")) {

                    //把age放到 对象中

                    Stringage = parser.nextText();

                    gf.setAge(age);

                }else if(parser.getName().equals("size")) {

                    //把size放到 对象中

                    Stringsize = parser.nextText();

                    gf.setSize(size);

                }else if(parser.getName().equals("high")) {

                    //把high放到 对象中

                    Stringhigh = parser.nextText();

                    gf.setHigh(high);

                }else if(parser.getName().equals("weight")) {

                    //把weight放到 对象中

                    Stringweight = parser.nextText();

                    gf.setWeight(weight);

                }

                

                break;

            caseXmlPullParser.END_TAG:

                if(parser.getName().equals("GirlFriend")) {

                    //结束标签是GirlFriend 需要把对象添加到集合中

                    gfs.add(gf);

                    gf=null;

                }

                break;

 

            

            }

            

            //事件要继续往下推荐

            eventType=parser.next();

        }

        System.out.println(gfs.toString());

    }catch (Exception e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

    }

}

Json的Gson解析

publicclass GsonTest1 { 

 

    public static void main(String[] args){ 

        Gson gson = new Gson(); 

 

        Student student1 = new Student(); 

        student1.setId(1); 

        student1.setName("李坤"); 

        student1.setBirthDay(new Date()); 

 

        //////////////////////////////////////////////////////////// 

        System.out.println("----------简单对象之间的转化-------------"); 

        // 简单的bean转为json 

        String s1 = gson.toJson(student1); 

        System.out.println("简单Bean转化为Json===" + s1); 

 

        // json转为简单Bean 

        Student student = gson.fromJson(s1,Student.class); 

        System.out.println("Json转为简单Bean===" + student); 

        // 结果: 

        // 简单Bean转化为Json==={"id":1,"name":"李坤","birthDay":"Jun 22, 2012 8:27:52AM"} 

        // Json转为简单Bean===Student[birthDay=Fri Jun 22 08:27:52 CST 2012, id=1, 

        // name=李坤] 

        //////////////////////////////////////////////////////////// 

 

        Student student2 = new Student(); 

        student2.setId(2); 

        student2.setName("曹贵生"); 

        student2.setBirthDay(new Date()); 

 

        Student student3 = new Student(); 

        student3.setId(3); 

        student3.setName("柳波"); 

        student3.setBirthDay(new Date()); 

 

        List<Student> list = newArrayList<Student>(); 

        list.add(student1); 

        list.add(student2); 

        list.add(student3); 

 

        System.out.println("----------带泛型的List之间的转化-------------"); 

        // 带泛型的list转化为json 

        String s2 = gson.toJson(list); 

        System.out.println("带泛型的list转化为json==" + s2); 

 

        // json转为带泛型的list 

        List<Student> retList =gson.fromJson(s2, 

                newTypeToken<List<Student>>() { 

                }.getType()); 

        for (Student stu : retList) { 

            System.out.println(stu); 

        } 

 

        // 结果: 

        // 带泛型的list转化为json==[{"id":1,"name":"李坤","birthDay":"Jun 22, 2012 8:28:52AM"},{"id":2,"name":"曹贵生","birthDay":"Jun22, 2012 8:28:52 AM"},{"id":3,"name":"柳波","birthDay":"Jun 22, 2012 8:28:52AM"}] 

        // Student [birthDay=Fri Jun 2208:28:52 CST 2012, id=1, name=李坤] 

        // Student [birthDay=Fri Jun 2208:28:52 CST 2012, id=2, name=曹贵生] 

        // Student [birthDay=Fri Jun 2208:28:52 CST 2012, id=3, name=柳波] 

 

    } 

}

单例模式：

饿汉式：

public class Singleton{

        //直接创建对象

        public staticSingleton instance = new Singleton();

        //私有化构造

        privateSingleton(){}

        //提供外界访问的共有方法

        public staticSingleton getInstance(){

       returninstance;

}

}

 

懒汉式;

Public class Singleton { 

   Private static Singleton instance;

   Private Singleton (){}

   Public static synchronized Singleton getInstance() {

    If(instance == null) {

       Instance = new Singleton();

    }

   return instance; 

   } 

}