Ist es möglich, ein Array oder ein Objekt zu SharedPreferences auf Android hinzufügen

Question

Ich habe eine ArrayList von Objekten, die einen Namen und ein Symbol Zeiger haben und ich möchte es in SharedPreferences speichern. Wie kann ich tun?

Hinweis: Ich will nicht Datenbank verwenden

Answer 1

So aus der Android-Entwicklerwebsite auf Data Storage :

  

Benutzereinstellungen

     

Gemeinsame Einstellungen sind nicht streng für „Benutzereinstellungen“ Speichern wie, was ein Benutzer Klingelton hat sich dafür entschieden. Wenn Sie bei der Erstellung Benutzereinstellungen für Ihre Anwendung interessiert sind, sehen PreferenceActivity, die eine Aktivität Framework bietet Ihnen Benutzereinstellungen zu erstellen, die automatisch beibehalten werden (gemeinsam Präferenzen verwendet wird).

Also ich denke, es ist in Ordnung, da es einfach nur Schlüssel-Wert-Paare, die beibehalten werden.

Zum Originalplakat, das ist nicht so schwer. Sie einfach nur durch Ihre Array-Liste durchlaufen und die Elemente hinzuzufügen. In diesem Beispiel verwende ich eine Karte der Einfachheit halber aber Sie können eine Array-Liste verwenden und sie 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 wieder die Schlüssel-Wert-Paare zu lesen. Lassen Sie mich wissen, ob das funktioniert.

Update: Wenn Sie mit API-Level 11 oder höher, gibt es eine Methode einen String Set

Answer 2

Unabhängig von der API-Ebene, überprüfen String-Arrays und Object-Arrays in SharedPreferences

---

Speichern ARRAY

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;  
}  

Answer 3

zu 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();

zu 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();
}

Answer 4

Gemeinsame Präferenzen eingeführt, um eine getStringSet und putStringSet Methoden in API Ebene 11, aber das ist nicht kompatibel mit älteren Versionen von Android (die nach wie vor beliebt sind), und auch auf Sätze von Saiten beschränkt ist.

Android bietet keine besseren Methoden und Schleifen über Karten und Arrays zum Speichern und Laden sie nicht sehr einfach und sauber ist, speziell für Arrays. Aber eine bessere Umsetzung ist 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 jede Sammlung in gemeinsamen Präferenzen mit diesen fünf Methoden speichern. Arbeiten mit JSONObject und JSONArray ist sehr einfach. Sie können JSONArray (Collection copyFrom) öffentlichen Konstruktor, um eine JSONArray aus jeder Java-Sammlung und Verwendung JSONArray der get Methoden verwenden, um die Elemente zuzugreifen.

Es gibt keine Größenbeschränkung für die gemeinsame Präferenzen (außer Gerätespeichergrenzen), so dass diese Methoden für die meisten üblichen Fällen arbeiten können, wo Sie eine schnelle und einfache Lagerung für einige Sammlung in Ihrer App möchten. Aber JSON Parsen geschehen hier, und Vorlieben in Android als XMLs intern gespeichert, so dass ich mit anderen persistenten Datenspeichermechanismen empfehlen, wenn man es zu tun mit Megabyte an Daten.

Answer 5

Easy-Modus für komplexe Objektspeicher mit Gson Google-Bibliothek [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/

Answer 6

lud ich eine Reihe von Taillengrößen (bereits in meinem array.xml erstellt) in meine preferences.xml Datei mit dem folgenden Code. @ 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" /> 

Dieses Menü mit Auswahl aus dem Array gefüllt. Ich habe die Standardgröße als 34, so dass, wenn das Menü erscheint, sie sehen Größe 34 vorselektiert.

Answer 7

Der einfache Weg ist, zu wandeln es in JSON String wie unten Beispiel:

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

speichern Sie dann die Zeichenfolge in den gemeinsam genutzten Einstellungen. Sobald Sie es brauchen nur Zeichenfolge aus dem gemeinsamen Präferenzen erhalten und konvertieren zurück zu JSONArray oder JSONObject (wie pro Ihre Anforderung.)

Answer 8

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;
}

Answer 9

Dies ist der gemeinsame Präferenzen Code i erfolgreich zu verwenden, finden Sie 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());


    }

   }

HAPPY CODING!

Answer 10

Sie können verwenden putStringSet

Dies ermöglicht es Ihnen, eine HashSet in Ihre Einstellungen zu speichern, wie folgt aus:

Speichern

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);

Die putStringSet erlauben nur ein Set und das ist eine ungeordnete Liste.