web-dev-qa-db-de.com

Ist es möglich, SharedPreferences unter Android ein Array oder ein Objekt hinzuzufügen

Ich habe eine ArrayList von Objekten, die einen Namen und einen Symbolzeiger haben und ich möchte sie in SharedPreferences speichern. Wie kann ich?

HINWEIS: Ich möchte keine Datenbank verwenden

72
zsniperx

Also von der Android-Entwicklerseite auf Data Storage :

Nutzerpreferenzen

Freigegebene Einstellungen sind nicht unbedingt für das Speichern von "Benutzereinstellungen" gedacht, z. B. für welchen Klingelton ein Benutzer gewählt hat. Wenn Sie daran interessiert sind, Benutzervoreinstellungen für Ihre Anwendung zu erstellen, finden Sie weitere Informationen unter PreferenceActivity. Hier finden Sie ein Aktivitäts-Framework, in dem Sie Benutzervorgaben erstellen können, das automatisch beibehalten wird (mit freigegebenen Einstellungen).

Ich denke, es ist in Ordnung, da es einfach nur Schlüssel-Wert-Paare sind, die bestehen bleiben.

Für das Originalposter ist das nicht so schwer. Sie durchlaufen einfach Ihre Array-Liste und fügen die Elemente hinzu. In diesem Beispiel verwende ich zur Vereinfachung eine Map. Sie können jedoch eine Array-Liste verwenden und diese entsprechend ändern:

// my list of names, icon locations
Map<String, String> nameIcons = new HashMap<String, String>();
nameIcons.put("Noel", "/location/to/noel/icon.png");
nameIcons.put("Bob", "another/location/to/bob/icon.png");
nameIcons.put("another name", "last/location/icon.png");

SharedPreferences keyValues = getContext().getSharedPreferences("name_icons_list", Context.MODE_PRIVATE);
SharedPreferences.Editor keyValuesEditor = keyValues.edit();

for (String s : nameIcons.keySet()) {
    // use the name as the key, and the icon as the value
    keyValuesEditor.putString(s, nameIcons.get(s));
}
keyValuesEditor.commit()

Sie würden etwas Ähnliches tun, um die Schlüssel-Wert-Paare erneut zu lesen. Sag mir, ob das funktioniert.

Update: Wenn Sie API Level 11 oder höher verwenden, gibt es eine Methode , um einen String-Satz auszugeben 

56
Noel

Unabhängig von der API-Ebene können Check String-Arrays und Object-Arrays in SharedPreferences


ARRAY SPEICHERN

public boolean saveArray(String[] array, String arrayName, Context mContext) {   
    SharedPreferences prefs = mContext.getSharedPreferences("preferencename", 0);  
    SharedPreferences.Editor editor = prefs.edit();  
    editor.putInt(arrayName +"_size", array.length);  
    for(int i=0;i<array.length;i++)  
        editor.putString(arrayName + "_" + i, array[i]);  
    return editor.commit();  
} 

LOAD ARRAY

public String[] loadArray(String arrayName, Context mContext) {  
    SharedPreferences prefs = mContext.getSharedPreferences("preferencename", 0);  
    int size = prefs.getInt(arrayName + "_size", 0);  
    String array[] = new String[size];  
    for(int i=0;i<size;i++)  
        array[i] = prefs.getString(arrayName + "_" + i, null);  
    return array;  
}  
69
Sherif elKhatib

Schreiben,

SharedPreferences prefs = PreferenceManager
        .getDefaultSharedPreferences(this);
JSONArray jsonArray = new JSONArray();
jsonArray.put(1);
jsonArray.put(2);
Editor editor = prefs.edit();
editor.putString("key", jsonArray.toString());
System.out.println(jsonArray.toString());
editor.commit();

Lesen,

try {
    JSONArray jsonArray2 = new JSONArray(prefs.getString("key", "[]"));
    for (int i = 0; i < jsonArray2.length(); i++) {
         Log.d("your JSON Array", jsonArray2.getInt(i)+"");
    }
} catch (Exception e) {
    e.printStackTrace();
}
55
Rohit

Durch gemeinsame Voreinstellungen wurden in API Level 11 eine getStringSet- und putStringSet-Methode eingeführt, die jedoch nicht mit älteren (noch populären) Android-Versionen kompatibel ist und auch auf Strings beschränkt ist.

Android bietet keine besseren Methoden, und das Speichern und Laden von Karten und Arrays zum Schleifen ist sehr unkompliziert und sauber, insbesondere für Arrays. Eine bessere Implementierung ist jedoch nicht so schwer:

package com.example.utils;

import org.json.JSONObject;
import org.json.JSONArray;
import org.json.JSONException;

import Android.content.Context;
import Android.content.SharedPreferences;

public class JSONSharedPreferences {
    private static final String PREFIX = "json";

    public static void saveJSONObject(Context c, String prefName, String key, JSONObject object) {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        SharedPreferences.Editor editor = settings.edit();
        editor.putString(JSONSharedPreferences.PREFIX+key, object.toString());
        editor.commit();
    }

    public static void saveJSONArray(Context c, String prefName, String key, JSONArray array) {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        SharedPreferences.Editor editor = settings.edit();
        editor.putString(JSONSharedPreferences.PREFIX+key, array.toString());
        editor.commit();
    }

    public static JSONObject loadJSONObject(Context c, String prefName, String key) throws JSONException {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        return new JSONObject(settings.getString(JSONSharedPreferences.PREFIX+key, "{}"));
    }

    public static JSONArray loadJSONArray(Context c, String prefName, String key) throws JSONException {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        return new JSONArray(settings.getString(JSONSharedPreferences.PREFIX+key, "[]"));
    }

    public static void remove(Context c, String prefName, String key) {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        if (settings.contains(JSONSharedPreferences.PREFIX+key)) {
            SharedPreferences.Editor editor = settings.edit();
            editor.remove(JSONSharedPreferences.PREFIX+key);
            editor.commit();
        }
    }
}

Jetzt können Sie mit diesen fünf Methoden beliebige Sammlungen in den gemeinsamen Einstellungen speichern. Das Arbeiten mit JSONObject und JSONArray ist sehr einfach. Sie können den JSONArray (Collection copyFrom) public-Konstruktor verwenden, um aus einer beliebigen Java-Sammlung eine JSONArray zu erstellen und die JSONArray-Methoden der get für den Zugriff auf die Elemente zu verwenden.

Es gibt keine Größenbeschränkung für gemeinsam genutzte Voreinstellungen (abgesehen von den Speicherbeschränkungen des Geräts). Daher können diese Methoden in den meisten Fällen verwendet werden, in denen Sie schnell und einfach einige Sammlungen in Ihrer App speichern möchten. JSON-Analyse findet hier statt, und Einstellungen in Android werden intern als XML-Dateien gespeichert. Daher empfehle ich die Verwendung anderer persistenter Datenspeichermechanismen, wenn Sie mit Megabytes an Daten arbeiten.

31
Mostafa

Einfacher Modus für die Speicherung komplexer Objekte mit der Google-Bibliothek von Gson [1]

public static void setComplexObject(Context ctx, ComplexObject obj){
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(ctx);
    SharedPreferences.Editor editor = preferences.edit();
    editor.putString("COMPLEX_OBJECT",new Gson().toJson(obj)); 
    editor.commit();
}

public static ComplexObject getComplexObject (Context ctx){
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(ctx);
    String sobj = preferences.getString("COMPLEX_OBJECT", "");
    if(sobj.equals(""))return null;
    else return new Gson().fromJson(sobj, ComplexObject.class);
}

[1] http://code.google.com/p/google-gson/

13
Hpsaturn

Ich habe ein Array von Taillengrößen (bereits in meiner array.xml erstellt) in meine Datei preferences.xml mit dem folgenden Code geladen. @ array/pant_inch_size ist die ID des gesamten Arrays. 

 <ListPreference 
 Android:title="choosepantsize"
 Android:summary="Choose Pant Size"
 Android:key="pantSizePref" 
 Android:defaultValue="34" 
 Android:entries="@array/pant_inch_size"
 Android:entryValues="@array/pant_inch_size" /> 

Dadurch wurde das Menü mit Auswahlmöglichkeiten aus dem Array gefüllt. Ich habe die Standardgröße auf 34 festgelegt. Wenn das Menü angezeigt wird, wird die Größe 34 vorgewählt. 

3
Keith

Der einfache Weg ist, es in das folgende Beispiel zu konvertieren:

Gson gson = new Gson();
String json = gson.toJson(myObj);

Speichern Sie den String dann in den gemeinsam genutzten Einstellungen. Wenn Sie ihn brauchen, holen Sie ihn einfach aus den freigegebenen Einstellungen und konvertieren Sie ihn zurück in JSONArray oder JSONObject (je nach Anforderung).

2
Gaurav Darji

Zum Schreiben:

 private <T> void storeData(String key, T data) {
    ByteArrayOutputStream serializedData = new ByteArrayOutputStream();

    try {
        ObjectOutputStream serializer = new ObjectOutputStream(serializedData);
        serializer.writeObject(data);
    } catch (IOException e) {
        e.printStackTrace();
    }

    SharedPreferences sharedPreferences = getSharedPreferences(TAG, 0);
    SharedPreferences.Editor edit = sharedPreferences.edit();

    edit.putString(key, Base64.encodeToString(serializedData.toByteArray(), Base64.DEFAULT));
    edit.commit();
}

Zum Lesen:

private <T> T getStoredData(String key) {
    SharedPreferences sharedPreferences = getSharedPreferences(TAG, 0);
    String serializedData = sharedPreferences.getString(key, null);
    T storedData = null;
    try {
        ByteArrayInputStream input = new ByteArrayInputStream(Base64.decode(serializedData, Base64.DEFAULT));
        ObjectInputStream inputStream = new ObjectInputStream(input);
        storedData = (T)inputStream.readObject();
    } catch (IOException|ClassNotFoundException|Java.lang.IllegalArgumentException e) {
        e.printStackTrace();
    }

    return storedData;
}
1
Benav

Dies ist der gemeinsam genutzte Code, den ich erfolgreich verwende. Siehe diesen link :

  public class MainActivity extends Activity {

private static final int RESULT_SETTINGS = 1;
Button button;
public String a="dd";

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

 button = (Button) findViewById(R.id.btnoptions);


setContentView(R.layout.activity_main);

  // showUserSettings();
  }

@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.settings, menu);
return true;
 }

@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {

case R.id.menu_settings:
 Intent i = new Intent(this, UserSettingActivity.class);
 startActivityForResult(i, RESULT_SETTINGS);
 break;

 }

return true;
}

@Override
 protected void onActivityResult(int requestCode, int resultCode, Intent data)     {
  super.onActivityResult(requestCode, resultCode, data);

 switch (requestCode) {
 case RESULT_SETTINGS:
 showUserSettings();
 break;

 } 

  }

  private void showUserSettings() {
 SharedPreferences sharedPrefs = PreferenceManager
.getDefaultSharedPreferences(this);

 StringBuilder builder = new StringBuilder();

 builder.append("\n Pet: "
  + sharedPrefs.getString("prefpetname", "NULL"));

 builder.append("\n Address:"
 + sharedPrefs.getString("prefaddress","NULL" ));

 builder.append("\n Your name: "
 + sharedPrefs.getString("prefname", "NULL"));

 TextView settingsTextView = (TextView) findViewById(R.id.textUserSettings);


  settingsTextView.setText(builder.toString());


    }

   }

GLÜCKLICHES KODIEREN!

1
dondondon

Sie können putStringSet verwenden.

So können Sie ein HashSet wie folgt in Ihren Einstellungen speichern:

Sparen

Set<String> values;

SharedPreferences sharedPref = 
    mContext.getSharedPreferences(PREF_KEY, Context.MODE_PRIVATE);

Editor editor = sharedPref.edit();

editor.putStringSet("YOUR_KEY", values);
editor.apply();

Retrive

SharedPreferences sharedPref = 
    mContext.getSharedPreferences(PREF_KEY, Context.MODE_PRIVATE);

Editor editor = sharedPref.edit();

Set<String> newList = editor.getStringSet("YOUR_KEY", null);

Das putStringSet erlaubt nur ein Set und dies ist eine ungeordnete Liste.

0
Daniel Beltrami