Realm Android memorizzazione int [] e String []

Question

C'è un modo per memorizzare un int [] e una stringa [], altro che creare un nuovo oggetto che contiene quelli, e poi riporlo in un realmlist

Ho un oggetto che accetta i parametri di String, int [] e String []. Non puoi negozio int [], e String [] nel regno così ho fatto un oggetto

public class Workouts extends RealmObject { 

    private String workout; 

    public Workouts() { 

    } 

    public Workouts(String workout) { 
     this.workout = workout; 
    } 

    public String getWorkout() { 
     return workout; 
    } 

    public void setWorkout(String workout) { 
     this.workout = workout; 
    } 
} 

e

public class Multiplier extends RealmObject { 

    private int multiplier; 

    public Multiplier() { 

    } 

    public Multiplier(int multiplier) { 
     this.multiplier = multiplier; 
    } 

    public int getMultiplier() { 
     return multiplier; 
    } 

    public void setMultiplier(int multiplier) { 
     this.multiplier = multiplier; 
    } 
} 

e poi li ho negozio come moltiplicatori realmlist; allenamenti RealmList;

Mi chiedo se c'è un modo per conservare questi da solo utilizzando una matrice invece di un realmlist

Answer 1

Emanuele da Realm qui. Al momento non c'è altro modo oltre al wrapping di String o int e usare RealmList su quelli. Ciò è dovuto a diversi motivi, tra cui la possibilità di utilizzare il file Realm su piattaforme diverse. È una soluzione accettabile nel tuo caso d'uso o è un dolore?

Se si desidera, questo elenco mostra come si utilizza una RealmList per memorizzare un gruppo di valori primitivi all'interno di RealmObject. https://gist.github.com/cmelchior/1a97377df0c49cd4fca9

Answer 2

Creare classe RealmString come di seguito

public class RealmString extends RealmObject { 
    private String val; 
    public RealmString(){ 
    } 

    public RealmString(String value) { 
     this.val = value; 
    } 

    public String getValue() { 
     return val; 
    } 

    public void setValue(String value) { 
     this.val = value; 
    } 


    @Override 
    public String toString() { 
     return val; 
    } 
} 

Crea nuova classe

public class RealmStringDeserializer implements JsonDeserializer<RealmList<RealmString>> { 

    @Override 
    public RealmList<RealmString> deserialize(JsonElement json, Type typeOfT, 
               JsonDeserializationContext context) throws JsonParseException { 

     RealmList<RealmString> realmStrings = new RealmList<>(); 
     JsonArray stringList = json.getAsJsonArray(); 

     for (JsonElement stringElement : stringList) { 
      realmStrings.add(new RealmString(stringElement.getAsString())); 
     } 

     return realmStrings; 
    } 
} 

Se si utilizza regno con retrofit quindi aggiungere seguenti righe al retrofit classe costruttore

Gson gson = new GsonBuilder() 
       .setLenient() 
       .setExclusionStrategies(new ExclusionStrategy() { 
        @Override 
        public boolean shouldSkipField(FieldAttributes f) { 
         return f.getDeclaringClass().equals(RealmObject.class); 
        } 

        @Override 
        public boolean shouldSkipClass(Class<?> clazz) { 
         return false; 
        } 
       }) 
       .registerTypeAdapter(new TypeToken<RealmList<RealmString>>() { 
       }.getType(), new RealmStringDeserializer()) 
       .create(); 

     if (retrofit == null) { 
      retrofit = new Retrofit.Builder() 
        .baseUrl(NetworkConstants.BASE_URL) 
        .addConverterFactory(GsonConverterFactory.create(gson)) 
        .build(); 
     } 

Answer 3

Non mi piace usare RealmString e RealmInt. Come per esempio ti ricorderai di eliminarli di nuovo quando la lista cambia?

Ho creato una soluzione personalizzata per il combo Realm - GSON (Retrofit), in cui condividono lo stesso oggetto modello. Ho provato solo 10 file json. Fammi sapere se trovi qualche problema e ti perfezionerò.

In primo luogo, creare una stringa invece di un int [] o String [] nel vostro RealmObject:

/* 
* Languages this user selected. Comma separated String. 
*/ 
@SerializedName("languages") 
private String languages; 

Quindi creare getter e setter per esso. Notare che StringUtils.join() è il mio metodo, se nessuna delle librerie in uso lo utilizza, puoi trovarlo ovunque sulla rete.

/** 
* All user languages. 
*/ 
public void setLanguagesFromList(List<String> languages) { 

    String languagesStr = languages == null ? "" : StringUtils.join(languages, ","); 
    if (!TextUtils.equals(this.languages, languagesStr)) { 
     setDirty(true); 
    } 
    this.languages = languagesStr; 
} 

/** 
* Returns an unmodifiableList with all user languages. 
* <p> 
* Use setLanguagesFromList with a new list to make changes. 
* 
* @return 
*/ 
public List<String> getLanguagesList() { 

    return Collections.unmodifiableList(
      languages == null ? new ArrayList<>() : 
        Arrays.asList(languages.split(","))); 
} 

Se si utilizza questo getter molto, si potrebbe desiderare di creare un List<String> che non viene salvato nel database (@Ignore), ma viene utilizzata per accelerare questo metodo (in modo che l'analisi viene eseguita solo su modifiche/primo accesso).

quindi creare un Deserializer per GSON/Retrofit:

/** 
* Used so that string (or any other primitive) arrays are parsed int one String. Realm cannot handle String arrays. 
*/ 
public class RealmPrimitiveArrayDeserializer implements 
    JsonDeserializer<String> { 

private final static String KOMMA = ","; 

    @Override 
    public String deserialize(JsonElement json, Type typeOfT, 
          JsonDeserializationContext context) throws JsonParseException { 

    if (json.isJsonNull()) { 
     return null; 
    } 

    if (json.isJsonArray()) { 

     StringBuilder targetStringBuilder = null; 
     JsonArray stringList = json.getAsJsonArray(); 

     for (JsonElement element : stringList) { 

      if (element.isJsonPrimitive()) { 

       if (targetStringBuilder == null) { 
        targetStringBuilder = new StringBuilder(); 
       } 

       targetStringBuilder.append(element.getAsString()); 
       targetStringBuilder.append(KOMMA); 
      } 
     } 

     if (targetStringBuilder != null && targetStringBuilder.length() > 0) { 

      // remove the last komma: 
      targetStringBuilder.deleteCharAt(targetStringBuilder.length() - 1); 

      return targetStringBuilder.toString(); 
     } 
    } 

    return json.getAsString(); 
    } 
} 

Aggiungi questo per la configurazione GSON usata da Retrofit:

GsonBuilder gsonBuilder = new GsonBuilder() 
       .registerTypeAdapter(new TypeToken<String>() { 
       }.getType(), new RealmPrimitiveArrayDeserializer()); 

Questo è tutto. In bocca al lupo.