Android Realm 详解

介绍

Realm 是一个 MVCC （多版本并发控制）数据库，由Y Combinator公司在2014年7月发布一款支持运行在手机、平板和可穿戴设备上的嵌入式数据库，目标是取代SQLite。
Realm 本质上是一个嵌入式数据库，他并不是基于SQLite所构建的。它拥有自己的数据库存储引擎，可以高效且快速地完成数据库的构建操作。和SQLite不同，它允许你在持久层直接和数据对象工作。在它之上是一个函数式风格的查询api，众多的努力让它比传统的SQLite 操作更快 。
详细介绍（如果进不去，看这个也行）

优势

如果在在使用它时候，连它的优势在哪都不知道的话就有点说不过去了。

  • 易用
    Ream 不是在SQLite基础上的ORM，它有自己的数据查询引擎。并且十分容易使用。
  • 快速
    由于它是完全重新开始开发的数据库实现，所以它比任何的ORM速度都快很多，甚至比SLite速度都要快。
  • 跨平台
    Realm 支持 iOS & OS X (Objective?C & Swift) & Android。我们可以在这些平台上共享Realm数据库文件，并且上层逻辑可以不用任何改动的情况下实现移植。
  • 高级
    Ream支持加密，格式化查询，易于移植，支持JSON，流式api，数据变更通知等高级特性
  • 可视化
    Realm 还提供了一个轻量级的数据库查看工具，在Mac Appstore 可以下载“Realm Browser”这个工具，开发者可以查看数据库当中的内容，执行简单的插入和删除数据的操作。（windows上还不清楚）

条件

  • 目前不支持Android以外的Java
  • Android Studio >= 1.5.1
  • 较新的Android SDK版本
  • JDK version >=7.
  • 支持API 9(Android 2.3)以及之后的版本

使用

不介绍了，看代码了。

  • 加入依赖
    在project的build中加入依赖
buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath "io.realm:realm-gradle-plugin:2.2.1"
    }
}

project/build

在module中加入

apply plugin: ‘realm-android‘

module/build

Realm从v1.0.0后，不支持Ecilpse，我们推荐使用Android Studio

创建model

创建一个User类，需要继承RealmObject。支持public, protected和 private的类以及方法

public class User extends RealmObject {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

除了直接继承于RealmObject来声明 Realm 数据模型之外，还可以通过实现 RealmModel接口并添加 @RealmClass修饰符来声明。

@RealmClass
public class User implements RealmModel {
    ...
}
  • 支持的属性
    boolean, byte, short,int,long,float, double,String, Date 和，byte[], RealmObject, RealmList<? extends RealmObject>
    还支持Boolean, Byte, Short, Integer, Long, Float 和 Double
    Tip：整数类型 short、int 和 long 都被映射到 Realm 内的相同类型（实际上为 long ）
  • @PrimaryKey——表示该字段是主键
    使用过数据库的同学应该看出来了，PrimaryKey就是主键。使用@PrimaryKey来标注，字段类型必须是字符串（String）或整数（byte，short，int或long）以及它们的包装类型（Byte,Short, Integer, 或 Long）。不可以存在多个主键，使用字符串字段作为主键意味着字段被索引（注释@PrimaryKey隐式地设置注释@Index）。
@PrimaryKey
private String id;
  • @Required——表示该字段非空
    在某些情况下，有一些属性是不能为null的。使用@Required可用于用于强行要求其属性不能为空，只能用于Boolean, Byte, Short, Integer, Long, Float, Double, String, byte[] 和 Date。在其它类型属性上使用 @Required修饰会导致编译失败。
    Tip：基本数据类型不需要使用注解 @Required，因为他们本身就不可为空。
@Required
private String name;
  • @Ignore——表示忽略该字段
    被添加@Ignore标签后，存储数据时会忽略该字段。
@Ignore
private String name;
  • @Index——添加搜索索引
    为字段添加搜索索引，这样会使得插入的速度变慢，数据量也变得更大。不过在查询速度将变得更快，建议只在优化读取性能的特定情况时添加索引。支持索引：String，byte，short，int，long，boolean和Date字段。


 > **注意**：如果你创建Model并运行过，然后修改了Model。那么就需要升级数据库，否则会抛异常。升级方式后面会提到

### **初始化**
使用默认配置
```java
        Realm.init(this);
        Realm mRealm = Realm.getDefaultInstance();

这时候会创建一个叫做 default.realm的Realm文件，一般来说，这个文件位于/data/data/包名/files/。通过realm.getPath()来获得该Realm的绝对路径。

注意：模拟器上运行时，Realm.getDefaultInstance()抛出异常，真机上没问题（不止何故）

当然，我们还可以使用RealmConfiguration来配置Realm

RealmConfiguration config = new RealmConfiguration.Builder()
            .name("myrealm.realm") //文件名
            .schemaVersion(0) //版本号
            .build();
Realm realm = Realm.getInstance(config);

创建非持久化的Realm，也就是保持在内存中，应用关闭后就清除了。

RealmConfiguration myConfig = new RealmConfiguration.Builder(context)
            .name("myrealm.realm")//保存在内存中
            .inMemory() .build();

RealmConfiguration支持的方法：

  • Builder.name : 指定数据库的名称。如不指定默认名为default。
  • Builder.schemaVersion : 指定数据库的版本号。
  • Builder.encryptionKey : 指定数据库的密钥。
  • Builder.migration : 指定迁移操作的迁移类。
  • Builder.deleteRealmIfMigrationNeeded : 声明版本冲突时自动删除原数据库。
  • Builder.inMemory : 声明数据库只在内存中持久化。
  • build : 完成配置构建。

关闭Realm

记得使用完后，在onDestroy中关闭Realm

@Override
protected void onDestroy() {
    super.onDestroy();
    // Close the Realm instance.
    realm.close();
}

增

写入操作需要在事务中进行，可以使用executeTransaction方法来开启事务。

  • 使用executeTransaction方法插入数据
        mRealm.executeTransaction(new Realm.Transaction() {
            @Override
            public void execute(Realm realm) {
                User user = realm.createObject(User.class);
                user.setName("Gavin");
                user.setAge(23);
            }
        });

在execute方法中执行插入操作

注意：如果在UI线程中插入过多的数据，可能会导致主线程拥塞。

  • 使用copyToRealmOrUpdate或copyToRealm方法插入数据
    当Model中存在主键的时候，推荐使用copyToRealmOrUpdate方法插入数据。如果对象存在，就更新该对象；反之，它会创建一个新的对象。若该Model没有主键，使用copyToRealm方法，否则将抛出异常。
        final User user = new User();
        user.setName("Jack");
        user.setId("2");
        mRealm.executeTransaction(new Realm.Transaction() {
            @Override
            public void execute(Realm realm) {
                realm.copyToRealmOrUpdate(user);
            }
        });
  • 如果你用的是这样的modle
public class User2 extends RealmObject {
      public String name;
      public int age;
}

就这样写

        mRealm.executeTransaction(new Realm.Transaction() {
            @Override
            public void execute(Realm realm) {
                User2 user = realm.createObject(User2.class);
                user.name = "Micheal";
                user.age = 30;
            }
        });
  • 如果User还有其他属性是，比如养了只Dog：
public class Dog extends RealmObject {
      private String name;
      private int age;
      //getters and setters
}

对应的User属性中加入Dog类

public class User extends RealmObject {
      private String name;
      private int age;
      private Dog dog;
      //getters and setters
}

如果你养了不止一只，你养了二哈、阿拉撕家…那你就要用到RealmList了。在User中加入该属性

private RealmList<Dog> dogs;
  • 1
  • 1

插入数据

    @Override
    public void execute(Realm realm) {
        User user = realm.createObject(User.class);
        user.setName("Gain");
        user.setAge(23);

        Dog dog1 = realm.createObject(Dog.class);
        dog1.setAge(1);
        dog1.setName("二哈");
        user.getDogs().add(dog1);

        Dog dog2 = realm.createObject(Dog.class);
        dog2.setAge(2);
        dog2.setName("阿拉撕家");
        user.getDogs().add(dog2);
      }
});
  • 上面都是用可executeTransaction方法插入数据，还有另一种方法可以用于插入数据——beginTransaction和commitTransaction
mRealm.beginTransaction();//开启事务
User user = mRealm.createObject(User.class);
user.setName("Gavin");
user.setId("3");
mRealm.commitTransaction();//提交事务

在插入前，先调用beginTransaction()，完成后调用commitTransaction()即可。

注意：在UI和后台线程同时开启创建write的事务，可能会导致ANR错误。为了避免该问题，可以使用executeTransactionAsync来实现。

  • 使用executeTransactionAsync
    该方法会开启一个子线程来执行事务，并且在执行完成后进行结果通知。
RealmAsyncTask transaction = mRealm.executeTransactionAsync(new Realm.Transaction() {
    @Override
    public void execute(Realm realm) {
        User user = realm.createObject(User.class);
        user.setName("Eric");
        user.setId("4");
      }
});

还可以加入监听

RealmAsyncTask transaction =  mRealm.executeTransactionAsync(new Realm.Transaction() {
    @Override
    public void execute(Realm realm) {
        User user = realm.createObject(User.class);
        user.setName("Eric");
        user.setId("4");
      }
}, new Realm.Transaction.OnSuccess() {
    @Override
    public void onSuccess() {
        //成功回调
      }
}, new Realm.Transaction.OnError() {
    @Override
    public void onError(Throwable error) {
        //失败回调
      }
});

注意：如果当Acitivity或Fragment被销毁时，在OnSuccess或OnError中执行UI操作，将导致程序奔溃 。用RealmAsyncTask .cancel();可以取消事务
在onStop中调用，避免crash

public void onStop () {
    if (transaction != null && !transaction.isCancelled()) {
        transaction.cancel();
      }
}
  • JSON
    Realm还是个很nice的功能就是将Json字符串转化为对象，厉害了我的Realm
    （直接借用官方的例子）
// 一个city model
public class City extends RealmObject {
    private String city;
    private int id;
    // getters and setters left out ...
}
// 使用Json字符串插入数据
realm.executeTransaction(new Realm.Transaction() {
    @Override
    public void execute(Realm realm) {
        realm.createObjectFromJson(City.class, "{ city: \"Copenhagen\", id: 1 }");
    }
});
// 使用InputStream插入数据
realm.executeTransaction(new Realm.Transaction() {
    @Override
    public void execute(Realm realm) {
        try {
            InputStream is = new FileInputStream(new File("path_to_file"));
            realm.createAllFromJson(City.class, is);
        } catch (IOException e) {
            throw new RuntimeException();
        }
    }
});

Realm 解析 JSON 时遵循如下规则：

  • 使用包含空值（null）的 JSON 创建对象：
  • 对于非必须（可为空值的属性），设置其值为 null；
  • 对于必须（不可为空值的属性），抛出异常；
  • 使用包含空值（null）的 JSON 更新对象：
  • 对于非必须（可为空值的属性），设置其值为 null；
  • 对于必须（不可为空值的属性），抛出异常；
  • 使用不包含对应属性的 JSON： * 该属性保持不变

查

查找操作就比插入方便多了，并不需在事务中操作，直接查询即可。

  • findAll ——查询
    例：查询所有的User
RealmResults<User> userList = mRealm.where(User.class).findAll();
  • 1
  • 1

这里使用RealmResults来接受查询到的结果，突然出现的RealmResults可能会让人懵逼。看看他的源码，发现RealmResults继承了AbstractList，而AbstractList又实现了List接口。好吧，原来实现了我们熟悉的List接口。

public final class RealmResults<E extends RealmModel> extends AbstractList<E>

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>
  • 1
  • 1

RealmResults源码

注意：RealmResults虽然实现了List接口，不过有很多方法是不能用的。比如add、addAll、remove、clear等，调用后会直接抛异常。不过也不用当心误用这些方法，因为它们都被标记为@Deprecated了。

  • findAllAsync——异步查询
    当数据量较大，可能会引起ANR的时候，就可以使用findAllAsync
        RealmResults<User> userList = mRealm.where(User.class)
                .equalTo("name", "Gavin")
                .findAllAsync();

值得注意的是，这里并不会马上查到数据，是有一定延时的。也就是说，你马上使用userList的时候，里面是没有数据的。可以注册RealmChangeListener监听器，或者使用isLoaded()方法，判断是否查询完成

if (result.isLoaded()) {
     // 完成查询
}
  • findFirst ——查询第一条数据
    例：查询User表中的第一条数据
User user2 = mRealm.where(User.class).findFirst();
  • equalTo ——根据条件查询
    例：得到name为Gavin的用户列表。
RealmResults<User> userList = mRealm.where(User.class)
            .equalTo("name", "Gavin").findAll();

如果User中还有Dog属性，希望根据Dog的条件来获取用户：
例：查询dogs.name为二哈的User

RealmResults<User> userList = mRealm.where(User.class)
             .equalTo("dogs.name", "二哈").findAll();

得到有养有dogs.name为”二哈”的用户列表（这里的dogs是User表中的属性名）

  • equalTo ——多条件查询
    当然，我们还经常要用到多条件的查询的功能。
    例：找到用户名为“Gavin”，且dogs.name为“二哈”的User
RealmResults<User> userList = mRealm.where(User.class)
            .equalTo("name", "Gavin").findAll();
RealmResults<User> userList = user5.where()
            .equalTo("dogs.name", "二哈").findAll();

上面先找到name为“Gavin”的User列表，然后再得到的结果中查询dogs.name为“二哈”
觉得这样写太麻烦？我也是这样想的，所以还可以这样写

RealmResults<User> userList = mRealm.where(User.class)
            .equalTo("name", "Gavin")
            .equalTo("dogs.name", "二哈")
            .findAll();

是不是很清爽~~~

  • 更多查询条件
    上面就展示了equalTo的用法。当然，查询还有更多的用法，我就不一一示例了。已知的方法如下：
    sum()：对指定字段求和。
    average()：对指定字段求平均值。
    min(): 对指定字段求最小值。
    max() : 对指定字段求最大值。count : 求结果集的记录数量。
    findAll(): 返回结果集所有字段，返回值为RealmResults队列
    findAllSorted() : 排序返回结果集所有字段，返回值为RealmResults队列
    between(), greaterThan(),lessThan(), greaterThanOrEqualTo() & lessThanOrEqualTo()
    equalTo() & notEqualTo()
    contains(), beginsWith() & endsWith()
    isNull() & isNotNull()
    isEmpty()& isNotEmpty()
  • RealmQuery以及or的使用
    在使用where()方法时，能得到一个RealmQuery对象，使用方法如下：
    例：查询name为“Gavin”和“Eric”的用户
RealmQuery<User> query = mRealm.where(User.class);
query.equalTo("name", "Gavin");
query.or().equalTo("name", "Eric");
RealmResults<User> userList = query.findAll();

这种情况下就要用到or()方法
这么一大串，你又觉得麻烦了？没事，继续简化。

RealmResults<User> userList = mRealm.where(User.class)
            .equalTo("name", "Gavin")
            .or().equalTo("name", "Eric")
            .findAll();

Tip：查询的时候你不用当心得到的RealmResults为null。如果查询的结果为空，那么RealmResults的size为0

  • 排序
    查询结束后，还可以进行排序，就像这样：
RealmResults<User> userList = mRealm.where(User.class) .findAll();
userList = result.sort("age"); //根据age，正序排列
userList = result.sort("age", Sort.DESCENDING);//逆序排列
  • 聚合
    RealmResult自带一些聚合方法：
RealmResults<User> results = realm.where(User.class).findAll();
long   sum     = results.sum("age").longValue();
long   min     = results.min("age").longValue();
long   max     = results.max("age").longValue();
double average = results.average("age");
long   matches = results.size();

改

mRealm.executeTransaction(new Realm.Transaction() {
    @Override
    public void execute(Realm realm) {
        //先查找后得到User对象
        User user = mRealm.where(User.class).findFirst();
        user.setAge(26);
    }
});

修改也是需要在事务中操作。
使用查询语句得到数据，然后将内容改了即可。

删

  • 使用deleteFromRealm()
//先查找到数据
final RealmResults<User> userList = mRealm.where(User.class).findAll();
mRealm.executeTransaction(new Realm.Transaction() {
    @Override
    public void execute(Realm realm) {
        userList.get(0).deleteFromRealm();
    }
});
  • 使用deleteFromRealm(int index)
mRealm.executeTransaction(new Realm.Transaction() {
    @Override
    public void execute(Realm realm) {
        userList.deleteFromRealm(0);
    }
});
  • 更多方法：
userList.deleteFirstFromRealm(); //删除user表的第一条数据
userList.deleteLastFromRealm();//删除user表的最后一条数据
results.deleteAllFromRealm();//删除user表的全部数据

版本升级

当数据结构发生变化是，需要升级数据库。对于Realm来说，数据库升级就是迁移操作，把原来的数据库迁移到新结构的数据库。（体验：略麻烦）

  • 例1：User类发生变化，移除age，新增个@Required的id字段。
    User版本：version 0
String name;
int    age;

User版本：version 1

@Required
String    id;
String name;

创建迁移类CustomMigration，需要实现RealmMigration接口。执行版本升级时的处理：

    /**
     * 升级数据库
     */
    class CustomMigration implements RealmMigration {
        @Override
        public void migrate(DynamicRealm realm, long oldVersion, long newVersion) {
            RealmSchema schema = realm.getSchema();
            if (oldVersion == 0 && newVersion == 1) {
                RealmObjectSchema personSchema = schema.get("User");
                //新增@Required的id
                personSchema
                        .addField("id", String.class, FieldAttribute.REQUIRED)
                        .transform(new RealmObjectSchema.Function() {
                            @Override
                            public void apply(DynamicReal
mObject obj) {
                                obj.set("id", "1");//为id设置值
                            }
                        })
                        .removeField("age");//移除age属性
                oldVersion++;
            }
        }
    }

使用Builder.migration升级数据库，将版本号改为1（原版本号：0）。当Realm发现新旧版本号不一致时，会自动使用该迁移类完成迁移操作。

RealmConfiguration config = new RealmConfiguration.Builder()
            .name("myrealm.realm") //文件名
            .schemaVersion(1)
            .migration(new CustomMigration())//升级数据库
            .build();
  • 例2：加入Dog类，User中加入Dog集合。
    User版本：version 1
@Required
String    id;
String name;

User版本：version 2

@Required
private String id;
private String name;
private RealmList<Dog> dogs;

Dog类

public class Dog extends RealmObject {
        private String name;
        private int age;
}

在迁移类CustomMigration中，继续添加处理方法。

            if (oldVersion == 1 && newVersion == 2) {
                //创建Dog表
                RealmObjectSchema dogSchema = schema.create("Dog");
                dogSchema.addField("name", String.class);
                dogSchema.addField("age", int.class);

                //User中添加dogs属性
                schema.get("User")
                        .addRealmListField("dogs", dogSchema)
                        .transform(new RealmObjectSchema.Function() {
                            @Override
                            public void apply(DynamicRealmObject obj) {
                                //为已存在的数据设置dogs数据
                                DynamicRealmObject dog = realm.createObject("Dog");
                                dog.set("name", "二哈");
                                dog.set("age", 2);
                                obj.getList("dogs").add(dog);
                            }
                        });
                oldVersion++;
            }
  • 更多用法——RealmObjectSchema
    例：取消id必填：
personSchema.setNullable("id", true):
  • 1
  • 1

例：移除id字段

personSchema.removeField("id");
  • 1
  • 1

例：重命名

personSchema..renameField("id", "userId");
  • 1
  • 1
  • 更多用法——DynamicRealmObject
    例：获取id
String id = obj.getString("id");
  • 1
  • 1

例：为字段设置值

obj.setString("name", "Gavin");
obj.setInt("id", 1);
obj.setLong("id", 1);

疑问：我在debug时发现这样的数据，如图：

userList

什么，dogs、id、name的值怎么都是null？这~~
开始我还以为升级时数据丢失，不过在图中userList第0条数据的右边看到了我的数据，于是我展开了里面的内容，如图：

展开后的userListg

好吧，他并不是我想象中的那种存法，我已经不知道他内部是怎么实现的了。（还望大神赐教）

加密

（官方原文）
Realm 文件可以通过传递一个512位（64字节）的密钥参数给 Realm.getInstance().encryptionKey() 来加密存储在磁盘上。

byte[] key = new byte[64];
new SecureRandom().nextBytes(key);
RealmConfiguration config = new RealmConfiguration.Builder()
  .encryptionKey(key)
  .build();
Realm realm = Realm.getInstance(config);

保证了所有永久性存储在磁盘上的数据都是通过标准 AES-256 加密的。每次创建新的 Realm 实例的时候，都需要提供相同的密钥。
参考 examples/encryptionExample。这个例子演示了如何通过 Android KeyStore 来安全地存储密钥。

适配器（Adapter）

（官方原文）
Realm提供了一些抽象的工具类来方便地将 OrderedRealmCollection
（RealmResults和 RealmList 都实现了这个借口）展示到UI控件上。

  • RealmBaseAdapter 可以与ListView配合使用。参见示例.
  • RealmRecyclerViewAdapter可以与 RecyclerView配合使用。参见示例.

你需要在 app 的 build.gradle中添加额外的依赖以使用这些适配器。

dependencies {
    compile ‘io.realm:android-adapters:1.4.0‘
}

Intents

（官方原文）
你不可以直接通过 intent传递 RealmObject，建议你只传递RealmObject的标识符。举个常用例子，假如你的对象拥有一个主键，请通过intent 的 bundle 来传递这个主键的值。

// Assuming we had a person class with a @PrimaryKey on the ‘id‘ field ...
Intent intent = new Intent(getActivity(), ReceivingService.class);
intent.putExtra("person_id", person.getId());
getActivity().startService(intent);

在接受方（Activity、Service、IntentService、BroadcastReceiver及其它）从 bundle中解析出这个主键然后打开Realm 查询得到这个 RealmObject。

// in onCreate(), onHandleIntent(), etc.
String personId = intent.getStringExtra("person_id");
Realm realm = Realm.getDefaultInstance();
Person person = realm.where(Person.class).equalTo("id", personId).findFirst();// do something with the person ...
realm.close();

可以参考 threading example 中的 Object Passing部分。该示例展示了在安卓开发中常用的如何传递 id 并且得到对应的 RealmObject。

RxJava

对于这么火的RxJava，Realm又怎么会放过他。
Realm 包含了对 RxJava 的原生支持。如下类可以被暴露为一个 Observable：Realm, RealmResults, RealmObject, DynamicRealm 和 DynamicRealmObject。
（直接用一个官方的例子）

Realm realm = Realm.getDefaultInstance();
GitHubService api = retrofit.create(GitHubService.class);
realm.where(Person.class).isNotNull("username").findAllAsync().asObservable()
    .filter(persons.isLoaded)
    .flatMap(persons -> Observable.from(persons))
    .flatMap(person -> api.user(person.getGithubUserName())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(user -> showUser(user));

这里使用asObservable轻松转换成RxJava中的Observable，使用.filter(persons.isLoaded)来判断是否已查询完成。到这里，熟悉RxJava的同学应该已经看明白了~~。可能还有人会一脸懵逼，->? 这是什么鬼？哈哈，这叫Lambda，有时间可以去看看。

也许还有很多同学不了解RxJava，这里极力推荐给 Android 开发者的 RxJava 详解。

终于写完了~~~说好易用的，没想到内容居然这么多。

源码地址

GitHub

参考资料

官方文档
GitHub
Realm for Android快速入门教程
Android开发笔记（八十五）手机数据库Realm
在Android加入和使用Realm
Android 进阶之第三方库的介绍 Realm [一] 基础用法

原文地址：https://www.cnblogs.com/endv/p/12229594.html

时间： 2024-11-09 00:54:18

Android Realm 详解的相关文章

[gitbook] Android框架分析系列之Android Binder详解

请支持作者原创: https://mr-cao.gitbooks.io/android/content/android-binder.html Android Binder详解 Table of Contents 1. binder简介 2. binder的实现 2.1. IBinder类简介 2.2. IInterface类简介 2.3. BpBinder和BBinder简介 2.4. ProcessState和IPCThreadState简介 2.5. ServiceManager简介 2.

android动画详解三 动画API概述

· 属性动画与view动画的不同之处 view动画系统提供了仅动画View 对象的能力,所以如果你想动画非View 对象,你就要自己实现代码. view动画系统实际上还被强制仅能对 View 的少数属性进行动画,比如缩放和旋转,而不能对背景色进行. view动画的另一个坏处是它仅修改View的绘制位置,而不是View的实际位置.例如,如果你动画一个移动穿越屏幕,button的绘制位置是正确的,但实际你可以点击它的位置却没有变,所以你必须去实现你自己的逻辑来处理它. 使用属性动画系统时,这个限制被

android矩阵详解

Matrix,中文里叫矩阵,高等数学里有介绍,在图像处理方面,主要是用于平面的缩放.平移.旋转等操作. 在Android里面,Matrix由9个float值构成,是一个3*3的矩阵.最好记住.如下图: 解释一下,上面的sinX和cosX,表示旋转角度的cos值和sin值,注意,旋转角度是按顺时针方向计算的. translateX和translateY表示x和y的平移量.scale是缩放的比例,1是不变,2是表示缩放1/2,这样子. 在android.graphics.Matrix中有对应旋转的函

Android ProgressBar详解以及自定义

版本:1.0 日期:2014.5.16 版权:© 2014 kince 转载注明出处 这一次主要说一下Android下的进度条,为什么是它呢,因为近期被其各种美轮美奂的设计所倾倒,计划逐渐去实现.另外一个因素也是它也是为数不多的直接继承于View类的控件,从中可以学习到一些自定义控件的知识.下面列举了一些个人觉得还算漂亮的进度条,仅供参考. 是不是很漂亮,其实就像上面图形展示的那样,进度条大体上无非就是这几种形式.这样一来肯定是需要自定义了,所以方向有两个:要么继承于系统的ProgressBar

Android 菜单详解

Android中菜单分为三种,选项菜单(OptionMenu),上下文菜单(ContextMenu),子菜单(SubMenu) 选项菜单 可以通过两种办法增加选项菜单,一是在menu.xml中添加,该种方式参见Android 资源详解(二) 菜单资源,二是在.java中添加 1.覆盖Activity 的 onCreateOptionsMenu(Menu  menu)方法,当我们第一次打开菜单 时该方法被自动调用. 2.调用Menu的 add()方法添加菜单项(Menultem) ,可以调用Men

Android菜单详解（一）——理解android中的Menu

前言 今天看了pro android 3中menu这一章,对Android的整个menu体系有了进一步的了解,故整理下笔记与大家分享. PS:强烈推荐<Pro Android 3>,是我至今为止看到的最好的一本android书,中文版出到<精通Android 2>. 理解Android的菜单 菜单是许多应用程序不可或缺的一部分,Android中更是如此,所有搭载Android系统的手机甚至都要有一个"Menu"键,由此可见菜单在Android程序中的特殊性.An

Android surfaceview详解

周末看<精通Android游戏开发>(Pro Android Games),里面讲到游戏的框架,其中一个重要的概念surfaceview,觉得不是很理解,于是花了一点时间研究了下,写下自己的心得. surface,这个单词的意思是浮在表面的,那么surfaceview就是浮在表面的view了.如果真的这样解释,估计有人要拍砖了.然而,话虽不能这么说,取这个名儿,多少还是有点关系的.surface是一个可见区域. 我们在屏幕上看到的这些view,在屏幕上看到的就是画面,在内存中就是一块内存区.绘

android ViewPager详解

Viewpager 在android界面布局中属于常用类型 ,它可以做导航,页面菜单,进入软件是的欢迎界面 等等.比现在最流行的几款手机软件  ,QQ,微信,微博 等 ,其主界面 都用到了ViewPager,所以学好它,势在必得 ,在这里总结了下, 先用图解 : 这是一个仿微博界面的xml布局 ,他们之间的关系经常搞混淆,怕记不住 ,总结了几句话:ViewPager里面含界面,它的改变控制(title)Imageview的变化,Textview控制页面,并间接控制Title(imageview)

Android LayoutInflater 详解

Android LayoutInflater 详解 简介: 在实际开发中LayoutInflater这个类还是非常有用的,它的作用类似于findViewById(). 不同点是LayoutInflater是用来找res/layout/下的xml布局文件,并且实例化:而findViewById()是找xml布局文件下的具体widget控件(如Button,TextView等等). 使用场景: ①对于一个没有被载入或者想要动态载入的界面,都需要使用LayoutInflater.inflater()来