Java RealmList.add方法代码示例

import io.realm.RealmList; //导入方法依赖的package包/类
@Override
public List<NYTimesMultimedium> deserialize(JsonParser parser, DeserializationContext context) throws IOException {
    RealmList<NYTimesMultimedium> list = new RealmList<>();

    TreeNode treeNode = parser.getCodec().readTree(parser);
    if (!(treeNode instanceof ArrayNode)) {
        return list;
    }

    ArrayNode arrayNode = (ArrayNode) treeNode;
    for (JsonNode node : arrayNode) {
        NYTimesMultimedium nyTimesMultimedium =
                objectMapper.treeToValue(node, NYTimesMultimedium.class);
        list.add(nyTimesMultimedium);
    }
    return list;
}
 

import io.realm.RealmList; //导入方法依赖的package包/类
public RealmList<RString> syncStringList(JSONArray jsonArray) {
    RealmList<RString> strings = new RealmList<>();
    for (int i = 0; i < jsonArray.length(); i++) {
        RString string = realm.createObject(RString.class);

        try {
            string.setValue(jsonArray.getString(i));
        } catch (JSONException e) {
            Log.e(TAG, "Error parsing string from JSON Array", e);
        }

        strings.add(string);
    }

    return strings;
}
 

import io.realm.RealmList; //导入方法依赖的package包/类
public RealmList<RQuizQuestion> syncQuizQuestions(JSONArray jsonArray) throws JSONException {

        RealmList<RQuizQuestion> questions = new RealmList<>();

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject questionJsonObject = jsonArray.getJSONObject(i);

            try {
                RQuizQuestion question = syncQuizQuestion(questionJsonObject);
                questions.add(question);

            } catch (JSONException e) {
                Log.e(TAG, "Error parsing quiz question", e);
            }
        }

        return questions;
    }
 

import io.realm.RealmList; //导入方法依赖的package包/类
public RealmList<RFilter> syncFilters(JSONArray jsonArray) throws JSONException {

        RealmList<RFilter> filters = new RealmList<>();

        realm.delete(RFilter.class);

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject filterJsonObject = jsonArray.getJSONObject(i);

            try {
                RFilter filter = syncFilter(filterJsonObject);
                filters.add(filter);

            } catch (JSONException e) {
                Log.e(TAG, "Error parsing filter", e);
            }
        }

        return filters;
    }
 

import io.realm.RealmList; //导入方法依赖的package包/类
/**
 * get saved contacts data from local storage
 * @return dictionary format
 */
public static RealmList<RealmContact> getContacts(Context context){
    Realm realm = Realm.getDefaultInstance();
    RealmResults<RealmContact> results = realm.where(RealmContact.class).findAll();
    RealmList<RealmContact> contacts = new RealmList<>();
    for (RealmContact contact: results) {
        contacts.add(contact);
    }
    return contacts;
}
 

import io.realm.RealmList; //导入方法依赖的package包/类
@Override
public RealmList<T> deserialize(JsonElement json, Type typeOfT,
                                        JsonDeserializationContext context) throws JsonParseException {
    RealmList<T> items = new RealmList<>();
    JsonArray ja = json.getAsJsonArray();
    for (JsonElement je : ja) {
        items.add((T) context.deserialize(je, getObjectType()));
    }
    return items;
}
 

import io.realm.RealmList; //导入方法依赖的package包/类
@Override
public RealmList<T> parse(JsonParser jsonParser) throws IOException {
    init();
    RealmList<T> list = new RealmList<>();
    if (jsonParser.getCurrentToken() == JsonToken.START_ARRAY) {
        while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
            T object = typeConverter != null ? typeConverter.parse(jsonParser) : mapper.parse(jsonParser);
            if (object != null) {
                list.add(object);
            }
        }
    }
    return list;
}
 

import io.realm.RealmList; //导入方法依赖的package包/类
@Override
public RealmList fromParcel(Parcel parcel) {
    int size = parcel.readInt();
    if (size != -1) {
        RealmList list = new RealmList();
        for (int i = 0; i < size; i++) {
            Parcelable parcelable = parcel.readParcelable(getClass().getClassLoader());
            list.add((RealmObject) Parcels.unwrap(parcelable));
        }
        return list;
    }
    return null;
}
 

import io.realm.RealmList; //导入方法依赖的package包/类
@Nullable
@Override
public RealmList<T> fromJson(@NonNull JsonReader reader) throws IOException {
    RealmList<T> result = new RealmList<>();
    reader.beginArray();
    while (reader.hasNext()) {
        result.add(elementAdapter.fromJson(reader));
    }
    reader.endArray();
    return result;
}
 

import io.realm.RealmList; //导入方法依赖的package包/类
@Override
public RealmList<RealmString> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
        throws JsonParseException {
    RealmList<RealmString> list = new RealmList<>();
    JsonArray ja = json.getAsJsonArray();
    for (JsonElement je : ja) {
        list.add(new RealmString(je.getAsString()));
    }
    return list;
}
 

import io.realm.RealmList; //导入方法依赖的package包/类
@Override
public RealmList<Tag> getTags() {
    RealmList<Tag> tags = new RealmList<>();
    List<String> tagStrs = mPostTagsEditText.getTokens();
    for (String tagStr : tagStrs) {
        tags.add(new Tag(tagStr));
    }
    return tags;
}
 

import io.realm.RealmList; //导入方法依赖的package包/类
@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
    if (data != null) {
        if (data.getCount() > 0) {
            RealmList<ImageBean> realmList = new RealmList<>();
            data.moveToFirst();
            do {
                String path = data.getString(data.getColumnIndexOrThrow(IMAGE_PROJECTION[0]));
                String name = data.getString(data.getColumnIndexOrThrow(IMAGE_PROJECTION[1]));
                long dateTime = data.getLong(data.getColumnIndexOrThrow(IMAGE_PROJECTION[2]));
                long id = data.getLong(data.getColumnIndexOrThrow(IMAGE_PROJECTION[5]));
                if (fileExist(path)) {
                    ImageBean bean = new ImageBean();
                    bean.setId(id);
                    bean.setPath(path);
                    bean.setName(name);
                    bean.setDate(dateTime);
                    realmList.add(bean);
                }

            } while (data.moveToNext());

            if (onLoadFinishedListener != null) {
                onLoadFinishedListener.onLoadFinished(realmList);
            }
        }
    }
}
 

import io.realm.RealmList; //导入方法依赖的package包/类
public RQuizQuestion syncQuizQuestion(JSONObject jsonObject) throws JSONException {

        String questionId = jsonObject.getString("id");
        RQuizQuestion question = RealmWrites.withRealm(realm).findOrCreate(RQuizQuestion.class, questionId);

        question.setQuestion(jsonObject.getString("question"));

        JSONArray answersJsonArray = jsonObject.getJSONArray("answers");
        RealmList<RQuizAnswer> answers = new RealmList<>();

        for (int i = 0; i < answersJsonArray.length(); i++) {
            JSONObject answerJsonObject = answersJsonArray.getJSONObject(i);

            String answerId = answerJsonObject.getString("id");
            RQuizAnswer answer = RealmWrites.withRealm(realm).findOrCreate(RQuizAnswer.class, answerId);

            answer.setAnswer(answerJsonObject.getString("answer"));

            answers.add(answer);
        }

        question.setAnswers(answers);

        return question;
    }
 

import io.realm.RealmList; //导入方法依赖的package包/类
/**
 * load all contacts from Phone Contact
 * this method needs async task because it may take too longer to load
 * @param listener : success result handler
 */
public void loadPhoneContacts(ResultListener listener){
    long startnow = android.os.SystemClock.uptimeMillis();
    Uri uri = ContactsContract.CommonDataKinds.Phone.CONTENT_URI;
    String[] projection = new String[] {
            Phone._ID,
            Phone.DISPLAY_NAME,
            Phone.NUMBER
    };

    Cursor people = context.getContentResolver().query(uri, projection, null, null, null);
    int indexId = people.getColumnIndex(Phone._ID);
    int indexName = people.getColumnIndex(Phone.DISPLAY_NAME);
    int indexNumber = people.getColumnIndex(Phone.NUMBER);

    RealmList<RealmContact> realmContacts = new RealmList<>();

    if(people.moveToFirst()) {
        do {
            String idx = people.getString(indexId);
            String name   = people.getString(indexName);
            String number = people.getString(indexNumber);
            // Do work...
            String phone = number.replace(" ", "").replace("-", "");

            RealmContact contact = new RealmContact();
            contact.setIdx(idx);
            contact.setName(name);
            contact.setPhone(phone);

            /*boolean isExist = false;

            for (int i = 0; i < phoneContacts.size(); i++){
                RealmContact existContact = phoneContacts.get(i);
                if (existContact.getIdx().equals(contact.getIdx())){
                    isExist = true;
                    break;
                }
            }
            if (!isExist){
                phoneContacts.add(contact);
            }*/

            realmContacts.add(contact);

        } while (people.moveToNext());

        saveContacts(realmContacts);
    }

    if (phoneContacts.isEmpty())
        phoneContacts = getContacts(context);

    long endnow = android.os.SystemClock.uptimeMillis();
    long processingDuration = endnow - startnow;
    Log.d("AppManager", "TimeForContacts " + (endnow - startnow) + " ms");

    // analysis
    Bundle params = new Bundle();
    params.putLong("duration", processingDuration);
    References.getInstance().analytics.logEvent("load_contacts", params);

    if (listener != null) {
        listener.onResult(true);
    }
}
 

import io.realm.RealmList; //导入方法依赖的package包/类
public Post(@NonNull Post post) {
    this.setId(post.getId());
    this.setUuid(post.getUuid());
    this.setTitle(post.getTitle());
    this.setSlug(post.getSlug());
    this.setStatus(post.getStatus());
    this.setMarkdown(post.getMarkdown());
    this.setMobiledoc(post.getMobiledoc());
    this.setHtml(post.getHtml());

    List<Tag> realmTags = post.getTags();
    RealmList<Tag> unmanagedTags = new RealmList<>();
    for (Tag realmTag : realmTags) {
        unmanagedTags.add(new Tag(realmTag));
    }
    this.setTags(unmanagedTags);

    this.setFeatureImage(post.getFeatureImage());
    this.setFeatured(post.isFeatured());
    this.setPage(post.isPage());
    this.setLanguage(post.getLanguage());

    this.setAuthor(post.getAuthor());
    this.setCreatedBy(post.getCreatedBy());
    this.setUpdatedBy(post.getUpdatedBy());
    this.setPublishedBy(post.getPublishedBy());

    this.setCreatedAt(post.getCreatedAt());
    this.setUpdatedAt(post.getUpdatedAt());
    this.setPublishedAt(post.getPublishedAt());

    this.setMetaTitle(post.getMetaTitle());
    this.setMetaDescription(post.getMetaDescription());

    this.setCustomExcerpt(post.getCustomExcerpt());

    for (PendingAction action : post.getPendingActions()) {
        this.addPendingAction(action.getType());
    }
    this.setConflictState(post.getConflictState());
}