ArrayListをSharedPreferencesに保存


318

ArrayListカスタムオブジェクトを持っています。各カスタムオブジェクトには、さまざまな文字列と数値が含まれています。ユーザーがアクティビティを離れて後で戻ってきたい場合でも、配列を固定しておく必要がありますが、アプリケーションが完全に閉じた後で、配列を使用できるようにする必要はありません。この方法で他の多くのオブジェクトをこの方法でSharedPreferences保存しますが、この方法で配列全体を保存する方法がわかりません。これは可能ですか?たぶんSharedPreferencesこれを行う方法ではないですか?より簡単な方法はありますか?


あなたはここで答えを見つけることができます。stackoverflow.com/questions/14981233/...
Apurva Kolapkar

これは完全な例であり、URL stackoverflow.com/a/41137562/4344659
Sanjeev Sangral

誰かが解決策を探しているなら、これはあなたがkotlinでの完全な使用例で求めている答えかもしれません。stackoverflow.com/a/56873719/3710341
Sagar Chapagain

回答:


432

API 11の後、SharedPreferences Editor受け入れSetsます。あなたはあなたのリストをa HashSetまたは類似のものに変換して、そのようにそれを保存することができます。読み直したら、に変換し、ArrayList必要に応じて並べ替えれば問題ありません。

//Retrieve the values
Set<String> set = myScores.getStringSet("key", null);

//Set the values
Set<String> set = new HashSet<String>();
set.addAll(listOfExistingScores);
scoreEditor.putStringSet("key", set);
scoreEditor.commit();

をシリアル化してArrayListから、に保存/読み取りすることもできますSharedPreferences。以下は解決策です:

編集:
わかりました、以下は、ArrayListシリアル化されたオブジェクトとして保存しSharedPreferences、SharedPreferencesから読み取るソリューションです。

APIは、SharedPreferencesとの間の文字列の格納と取得(API 11以降)のみをサポートするため、タスクのリストを含むArrayListオブジェクトを文字列にシリアル化および逆シリアル化する必要があります。

addTask()TaskManagerApplicationクラスのメソッド、我々は共有好みのインスタンスを取得してから使用してシリアル化されたのArrayListを格納する必要がputString()方法を:

public void addTask(Task t) {
  if (null == currentTasks) {
    currentTasks = new ArrayList<task>();
  }
  currentTasks.add(t);

  // save the task list to preference
  SharedPreferences prefs = getSharedPreferences(SHARED_PREFS_FILE, Context.MODE_PRIVATE);
  Editor editor = prefs.edit();
  try {
    editor.putString(TASKS, ObjectSerializer.serialize(currentTasks));
  } catch (IOException e) {
    e.printStackTrace();
  }
  editor.commit();
}

同様に、onCreate()メソッドの設定からタスクのリストを取得する必要があります。

public void onCreate() {
  super.onCreate();
  if (null == currentTasks) {
    currentTasks = new ArrayList<task>();
  }

  // load tasks from preference
  SharedPreferences prefs = getSharedPreferences(SHARED_PREFS_FILE, Context.MODE_PRIVATE);

  try {
    currentTasks = (ArrayList<task>) ObjectSerializer.deserialize(prefs.getString(TASKS, ObjectSerializer.serialize(new ArrayList<task>())));
  } catch (IOException e) {
    e.printStackTrace();
  } catch (ClassNotFoundException e) {
    e.printStackTrace();
  }
}

ObjectSerializerApache PigプロジェクトObjectSerializer.javaからクラスを取得できます


21
putStringSetこれはAPI 11で追加されたことに注意してください。現在のほとんどのプログラマーは、リースAPI 8(Froyo)をターゲットにしています。
クリスティアン

2
この方法のアイデアは気に入っています。最もクリーンな方法のようですが、格納しようとしている配列は、文字列、double、およびブール値を含むカスタムクラスオブジェクトです。これらの3つのタイプすべてをセットに追加するにはどうすればよいですか?保存する前に、個々のオブジェクトをそれぞれ独自の配列に設定し、個別のセットに個別に追加する必要がありますか、それとももっと簡単な方法がありますか?
ryandlf 2011

5
なにscoreEditor
Ruchir Baronia

2
2016年10月以降の読者へ:このコメントはすでに多くの賛成票を獲得しており、私のように使用できますが、中止してこれを行わないでください。HashSetは重複する値を破棄するため、ArrayListは同じにはなりません。詳細はこちら:stackoverflow.com/questions/12940663/...
ソウル

2
この答えに遭遇した人への注意として:セットは順序付けされていないため、StringSetを保存すると、ArrayListでの順序が失われます。
David Liu

119

このオブジェクトの使用-> TinyDB--Android-Shared-Preferences-Turbo は非常にシンプルです。

TinyDB tinydb = new TinyDB(context);

置く

tinydb.putList("MyUsers", mUsersArray);

取得するため

tinydb.getList("MyUsers");

更新

いくつかの役立つ例とトラブルシューティングがここにあります:Android Shared Preference TinyDB putListObject frunction


6
これが最善のアプローチです。私の側からの+1
Sritam Jagadev 2015

3
私も。非常に便利です!!
Juan Aguilar Guisado

1
リストの内容に応じて、tinydb.putList()リンクされたページの例を見て呼び出すときに、リストのオブジェクトタイプを指定する必要があります。
kc ochibili 2016年

良いlibですが、このライブラリにはオブジェクトを保存するときに問題が発生することがあります。具体的には、スタックオーバーフロー例外がスローされる場合があります。オブジェクトを格納する方法を理解するためにリフレクションを使用しているためだと思います。オブジェクトが複雑になりすぎると、その例外がスローされる可能性があります。
Mr.Q 2016年

1
あなたがすごく大好き!
mychemicalro 2017年

93

に保存ArrayしていSharedPreferencesます:

public static boolean saveArray()
{
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
    SharedPreferences.Editor mEdit1 = sp.edit();
    /* sKey is an array */
    mEdit1.putInt("Status_size", sKey.size());  

    for(int i=0;i<sKey.size();i++)  
    {
        mEdit1.remove("Status_" + i);
        mEdit1.putString("Status_" + i, sKey.get(i));  
    }

    return mEdit1.commit();     
}

ArrayからのデータのロードSharedPreferences

public static void loadArray(Context mContext)
{  
    SharedPreferences mSharedPreference1 =   PreferenceManager.getDefaultSharedPreferences(mContext);
    sKey.clear();
    int size = mSharedPreference1.getInt("Status_size", 0);  

    for(int i=0;i<size;i++) 
    {
     sKey.add(mSharedPreference1.getString("Status_" + i, null));
    }

}

14
これはとても素敵な「ハック」です。この方法では、SharedPreferencesが未使用の古い値で肥大化する可能性が常にあることに注意してください。たとえば、リストの実行時にサイズが100になり、次にサイズが50になる場合があります。50の古いエントリは設定に残ります。1つの方法は、MAX値を設定し、それまでのすべてをクリアすることです。
Iraklis 2013

3
@Iraklis確かに、しかし、あなたがこれだけ保存することを前提ArrayListSharedPrefeneces、あなたが使用することができmEdit1.clear()、これを避けるために。
AlexAndro 2013

1
私はこの「ハック」が好きです。しかし、mEdit1.clear()はこの目的に関係のない他の値を消去しますか?
Bagusflyer 2013年

1
ありがとう!よろしければ、.remove()に必要な目的はありますか?とにかく、設定は単に上書きされませんか?
スクリプトキティ

62

に変換してJSON String、文字列をに保存できSharedPreferencesます。


ArrayListをJSONArrayに変換するための大量のコードを見つけていますが、SharedPrefsに保存できるようにJSONStringに変換する方法について共有してもよいサンプルはありますか?
ryandlf 2011


3
しかし、それをSharedPrefsから戻し、ArrayListに戻すにはどうすればよいですか?
ryandlf 2011

申し訳ありませんが、現在テストするためのAndroid SDKがありませんが、こちらをご覧ください:benjii.me/2010/04/deserializing-json-in-android-using-gson。json配列を反復処理し、オブジェクトごとにそれらが行うことを実行する必要があります。うまくいけば、明日の完全な例を使用して私の回答の編集を投稿できます。
MByD 2011

53

@niravが言ったように、最善の解決策は、Gsonユーティリティクラスを使用して、jsonテキストとしてsharedPreferncesに保存することです。以下のサンプルコード:

//Retrieve the values
Gson gson = new Gson();
String jsonText = Prefs.getString("key", null);
String[] text = gson.fromJson(jsonText, String[].class);  //EDIT: gso to gson


//Set the values
Gson gson = new Gson();
List<String> textList = new ArrayList<String>();
textList.addAll(data);
String jsonText = gson.toJson(textList);
prefsEditor.putString("key", jsonText);
prefsEditor.apply();

2
神に感謝します、それは命の恩人でした。とてもシンプルです。
パルチバンM 2016

2
この答えは上向きである必要があります。見事!この方法でGsonを使用できるとは思いもしませんでした。配列表記がこのように使用されているのを初めて見る。ありがとうございました!
madu 2017年

3
リストに戻すには、List <String> textList = Arrays.asList(gson.fromJson(jsonText、String []。class));
Vamsi Challa

22

こんにちは私はGsonライブラリを使用せずに上記の問題の解決策を得ました。ここにソースコードを投稿します。

1.変数宣言ie

  SharedPreferences shared;
  ArrayList<String> arrPackage;

2.変数の初期化、すなわち

 shared = getSharedPreferences("App_settings", MODE_PRIVATE);
 // add values for your ArrayList any where...
 arrPackage = new ArrayList<>();

3.を使用して、値をsharedPreferenceに保存しpackagesharedPreferences()ます。

 private void packagesharedPreferences() {
   SharedPreferences.Editor editor = shared.edit();
   Set<String> set = new HashSet<String>();
   set.addAll(arrPackage);
   editor.putStringSet("DATE_LIST", set);
   editor.apply();
   Log.d("storesharedPreferences",""+set);
 }

4. sharedPreferenceの値を取得するretriveSharedValue()

 private void retriveSharedValue() {
   Set<String> set = shared.getStringSet("DATE_LIST", null);
   arrPackage.addAll(set);
   Log.d("retrivesharedPreferences",""+set);
 }

お役に立てれば幸いです...


素晴らしいソリューション!簡単で速い!
LoveAndroid 2016年

5
これにより、セットに追加するとすぐに、重複する文字列がすべてリストから削除されます。おそらく望まれていない機能
OneCricketeer

Stringsのリストのみですか?
CoolMind

この方法で注文が失われます
ブライアンラインホールド

16
/**
 *     Save and get ArrayList in SharedPreference
 */

JAVA:

public void saveArrayList(ArrayList<String> list, String key){
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);
    SharedPreferences.Editor editor = prefs.edit();
    Gson gson = new Gson();
    String json = gson.toJson(list);
    editor.putString(key, json);
    editor.apply();    

}

public ArrayList<String> getArrayList(String key){
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);
    Gson gson = new Gson();
    String json = prefs.getString(key, null);
    Type type = new TypeToken<ArrayList<String>>() {}.getType();
    return gson.fromJson(json, type);
}

コトリン

fun saveArrayList(list: java.util.ArrayList<String?>?, key: String?) {
    val prefs: SharedPreferences = PreferenceManager.getDefaultSharedPreferences(activity)
    val editor: Editor = prefs.edit()
    val gson = Gson()
    val json: String = gson.toJson(list)
    editor.putString(key, json)
    editor.apply()
}

fun getArrayList(key: String?): java.util.ArrayList<String?>? {
    val prefs: SharedPreferences = PreferenceManager.getDefaultSharedPreferences(activity)
    val gson = Gson()
    val json: String = prefs.getString(key, null)
    val type: Type = object : TypeToken<java.util.ArrayList<String?>?>() {}.getType()
    return gson.fromJson(json, type)
}

1
はい、ベストアンサー
AlexPad

これが最良の答え
です。

これを作成して、すべてのモデルクラスを保存することができますか?
BlackBlind

13

Android SharedPreferancesを使用すると、プリミティブ型(API11以降で使用可能なブール、フロート、整数、ロング、ストリング、およびストリングセット)をxmlファイルとしてメモリに保存できます。

ソリューションの重要なアイデアは、データをこれらのプリミティブ型の1つに変換することです。

個人的には、myリストをjson形式に変換し、それをSharedPreferences値の文字列として保存するのが大好きです。

私のソリューションを使用するには、Google Gson lib を追加する必要があります。

Gradleで次の依存関係を追加するだけです(Googleの最新バージョンを使用してください)。

compile 'com.google.code.gson:gson:2.6.2'

データを保存します(HttpParamはオブジェクトです):

List<HttpParam> httpParamList = "**get your list**"
String httpParamJSONList = new Gson().toJson(httpParamList);

SharedPreferences prefs = getSharedPreferences(**"your_prefes_key"**, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = prefs.edit();
editor.putString(**"your_prefes_key"**, httpParamJSONList);

editor.apply();

データを取得します(HttpParamはオブジェクトです):

SharedPreferences prefs = getSharedPreferences(**"your_prefes_key"**, Context.MODE_PRIVATE);
String httpParamJSONList = prefs.getString(**"your_prefes_key"**, ""); 

List<HttpParam> httpParamList =  
new Gson().fromJson(httpParamJSONList, new TypeToken<List<HttpParam>>() {
            }.getType());

ありがとう。この回答は、List <MyObject>を取得して保存するのに役立ちました。
visrahane

ありがとう。
正常に

11

これは完璧なソリューションです。

public void saveArrayList(ArrayList<String> list, String key){
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);
    SharedPreferences.Editor editor = prefs.edit();
    Gson gson = new Gson();
    String json = gson.toJson(list);
    editor.putString(key, json);
    editor.apply();     // This line is IMPORTANT !!!
}

public ArrayList<String> getArrayList(String key){
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);
    Gson gson = new Gson();
    String json = prefs.getString(key, null);
    Type type = new TypeToken<ArrayList<String>>() {}.getType();
    return gson.fromJson(json, type);
}

9

また、arraylistをStringに変換して、優先的に保存することもできます

private String convertToString(ArrayList<String> list) {

            StringBuilder sb = new StringBuilder();
            String delim = "";
            for (String s : list)
            {
                sb.append(delim);
                sb.append(s);;
                delim = ",";
            }
            return sb.toString();
        }

private ArrayList<String> convertToArray(String string) {

            ArrayList<String> list = new ArrayList<String>(Arrays.asList(string.split(",")));
            return list;
        }

convertToStringメソッドを使用して文字列に変換した後、Arraylistを保存し、文字列を取得して配列に変換できます。convertToArray

API 11以降は、SharedPreferencesに直接セットを保存できます!!! :)


6

String、int、booleanの場合、最良の選択はsharedPreferencesです。

ArrayListまたは複雑なデータを格納する場合。最良の選択は紙のライブラリです。

依存関係を追加

implementation 'io.paperdb:paperdb:2.6'

紙を初期化

Application.onCreate()で一度初期化する必要があります。

Paper.init(context);

保存する

List<Person> contacts = ...
Paper.book().write("contacts", contacts);

データのロード

オブジェクトがストレージに存在しない場合は、デフォルト値を使用します。

List<Person> contacts = Paper.book().read("contacts", new ArrayList<>());

どうぞ。

https://github.com/pilgr/Paper


5

上記のすべての回答を読みました。それはすべて正しいですが、私は以下のようなより簡単な解決策を見つけました:

  1. 文字列リストを共有設定に保存する>>

    public static void setSharedPreferenceStringList(Context pContext, String pKey, List<String> pData) {
    SharedPreferences.Editor editor = pContext.getSharedPreferences(Constants.APP_PREFS, Activity.MODE_PRIVATE).edit();
    editor.putInt(pKey + "size", pData.size());
    editor.commit();
    
    for (int i = 0; i < pData.size(); i++) {
        SharedPreferences.Editor editor1 = pContext.getSharedPreferences(Constants.APP_PREFS, Activity.MODE_PRIVATE).edit();
        editor1.putString(pKey + i, (pData.get(i)));
        editor1.commit();
    }

    }

  2. そしてShared-preferenceから文字列リストを取得するために>>

    public static List<String> getSharedPreferenceStringList(Context pContext, String pKey) {
    int size = pContext.getSharedPreferences(Constants.APP_PREFS, Activity.MODE_PRIVATE).getInt(pKey + "size", 0);
    List<String> list = new ArrayList<>();
    for (int i = 0; i < size; i++) {
        list.add(pContext.getSharedPreferences(Constants.APP_PREFS, Activity.MODE_PRIVATE).getString(pKey + i, ""));
    }
    return list;
    }

これConstants.APP_PREFSが開くファイルの名前です。パス区切り文字を含めることはできません。


5

Kotlinの場合:

fun SharedPreferences.Editor.putIntegerArrayList(key: String, list: ArrayList<Int>?): SharedPreferences.Editor {
    putString(key, list?.joinToString(",") ?: "")
    return this
}

fun SharedPreferences.getIntegerArrayList(key: String, defValue: ArrayList<Int>?): ArrayList<Int>? {
    val value = getString(key, null)
    if (value.isNullOrBlank())
        return defValue
    return ArrayList (value.split(",").map { it.toInt() }) 
}

4

最良の方法は、GSONを使用してJSOn文字列に変換し、この文字列をSharedPreferenceに保存することです。また、この方法を使用して応答をキャッシュします。


4

Gsonライブラリを使用して、文字列とカスタム配列リストを保存できます。

=>まず、配列リストをSharedPreferencesに保存する関数を作成する必要があります。

public void saveListInLocal(ArrayList<String> list, String key) {

        SharedPreferences prefs = getSharedPreferences("AppName", Context.MODE_PRIVATE);
        SharedPreferences.Editor editor = prefs.edit();
        Gson gson = new Gson();
        String json = gson.toJson(list);
        editor.putString(key, json);
        editor.apply();     // This line is IMPORTANT !!!

    }

=> SharedPreferencesから配列リストを取得する関数を作成する必要があります。

public ArrayList<String> getListFromLocal(String key)
{
    SharedPreferences prefs = getSharedPreferences("AppName", Context.MODE_PRIVATE);
    Gson gson = new Gson();
    String json = prefs.getString(key, null);
    Type type = new TypeToken<ArrayList<String>>() {}.getType();
    return gson.fromJson(json, type);

}

=> saveを呼び出して配列リスト関数を取得する方法。

ArrayList<String> listSave=new ArrayList<>();
listSave.add("test1"));
listSave.add("test2"));
saveListInLocal(listSave,"key");
Log.e("saveArrayList:","Save ArrayList success");
ArrayList<String> listGet=new ArrayList<>();
listGet=getListFromLocal("key");
Log.e("getArrayList:","Get ArrayList size"+listGet.size());

=>アプリレベルのbuild.gradleにgsonライブラリを追加することを忘れないでください。

実装 'com.google.code.gson:gson:2.8.2'


3

FacebookSDKのSharedPreferencesTokenCacheクラスからserializeKey()およびdeserializeKey()関数を参照できます。supportedTypeをJSONオブジェクトに変換し、JSON文字列をSharedPreferencesに格納しますここからSDKをダウンロードできます

private void serializeKey(String key, Bundle bundle, SharedPreferences.Editor editor)
    throws JSONException {
    Object value = bundle.get(key);
    if (value == null) {
        // Cannot serialize null values.
        return;
    }

    String supportedType = null;
    JSONArray jsonArray = null;
    JSONObject json = new JSONObject();

    if (value instanceof Byte) {
        supportedType = TYPE_BYTE;
        json.put(JSON_VALUE, ((Byte)value).intValue());
    } else if (value instanceof Short) {
        supportedType = TYPE_SHORT;
        json.put(JSON_VALUE, ((Short)value).intValue());
    } else if (value instanceof Integer) {
        supportedType = TYPE_INTEGER;
        json.put(JSON_VALUE, ((Integer)value).intValue());
    } else if (value instanceof Long) {
        supportedType = TYPE_LONG;
        json.put(JSON_VALUE, ((Long)value).longValue());
    } else if (value instanceof Float) {
        supportedType = TYPE_FLOAT;
        json.put(JSON_VALUE, ((Float)value).doubleValue());
    } else if (value instanceof Double) {
        supportedType = TYPE_DOUBLE;
        json.put(JSON_VALUE, ((Double)value).doubleValue());
    } else if (value instanceof Boolean) {
        supportedType = TYPE_BOOLEAN;
        json.put(JSON_VALUE, ((Boolean)value).booleanValue());
    } else if (value instanceof Character) {
        supportedType = TYPE_CHAR;
        json.put(JSON_VALUE, value.toString());
    } else if (value instanceof String) {
        supportedType = TYPE_STRING;
        json.put(JSON_VALUE, (String)value);
    } else {
        // Optimistically create a JSONArray. If not an array type, we can null
        // it out later
        jsonArray = new JSONArray();
        if (value instanceof byte[]) {
            supportedType = TYPE_BYTE_ARRAY;
            for (byte v : (byte[])value) {
                jsonArray.put((int)v);
            }
        } else if (value instanceof short[]) {
            supportedType = TYPE_SHORT_ARRAY;
            for (short v : (short[])value) {
                jsonArray.put((int)v);
            }
        } else if (value instanceof int[]) {
            supportedType = TYPE_INTEGER_ARRAY;
            for (int v : (int[])value) {
                jsonArray.put(v);
            }
        } else if (value instanceof long[]) {
            supportedType = TYPE_LONG_ARRAY;
            for (long v : (long[])value) {
                jsonArray.put(v);
            }
        } else if (value instanceof float[]) {
            supportedType = TYPE_FLOAT_ARRAY;
            for (float v : (float[])value) {
                jsonArray.put((double)v);
            }
        } else if (value instanceof double[]) {
            supportedType = TYPE_DOUBLE_ARRAY;
            for (double v : (double[])value) {
                jsonArray.put(v);
            }
        } else if (value instanceof boolean[]) {
            supportedType = TYPE_BOOLEAN_ARRAY;
            for (boolean v : (boolean[])value) {
                jsonArray.put(v);
            }
        } else if (value instanceof char[]) {
            supportedType = TYPE_CHAR_ARRAY;
            for (char v : (char[])value) {
                jsonArray.put(String.valueOf(v));
            }
        } else if (value instanceof List<?>) {
            supportedType = TYPE_STRING_LIST;
            @SuppressWarnings("unchecked")
            List<String> stringList = (List<String>)value;
            for (String v : stringList) {
                jsonArray.put((v == null) ? JSONObject.NULL : v);
            }
        } else {
            // Unsupported type. Clear out the array as a precaution even though
            // it is redundant with the null supportedType.
            jsonArray = null;
        }
    }

    if (supportedType != null) {
        json.put(JSON_VALUE_TYPE, supportedType);
        if (jsonArray != null) {
            // If we have an array, it has already been converted to JSON. So use
            // that instead.
            json.putOpt(JSON_VALUE, jsonArray);
        }

        String jsonString = json.toString();
        editor.putString(key, jsonString);
    }
}

private void deserializeKey(String key, Bundle bundle)
        throws JSONException {
    String jsonString = cache.getString(key, "{}");
    JSONObject json = new JSONObject(jsonString);

    String valueType = json.getString(JSON_VALUE_TYPE);

    if (valueType.equals(TYPE_BOOLEAN)) {
        bundle.putBoolean(key, json.getBoolean(JSON_VALUE));
    } else if (valueType.equals(TYPE_BOOLEAN_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        boolean[] array = new boolean[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = jsonArray.getBoolean(i);
        }
        bundle.putBooleanArray(key, array);
    } else if (valueType.equals(TYPE_BYTE)) {
        bundle.putByte(key, (byte)json.getInt(JSON_VALUE));
    } else if (valueType.equals(TYPE_BYTE_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        byte[] array = new byte[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = (byte)jsonArray.getInt(i);
        }
        bundle.putByteArray(key, array);
    } else if (valueType.equals(TYPE_SHORT)) {
        bundle.putShort(key, (short)json.getInt(JSON_VALUE));
    } else if (valueType.equals(TYPE_SHORT_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        short[] array = new short[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = (short)jsonArray.getInt(i);
        }
        bundle.putShortArray(key, array);
    } else if (valueType.equals(TYPE_INTEGER)) {
        bundle.putInt(key, json.getInt(JSON_VALUE));
    } else if (valueType.equals(TYPE_INTEGER_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        int[] array = new int[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = jsonArray.getInt(i);
        }
        bundle.putIntArray(key, array);
    } else if (valueType.equals(TYPE_LONG)) {
        bundle.putLong(key, json.getLong(JSON_VALUE));
    } else if (valueType.equals(TYPE_LONG_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        long[] array = new long[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = jsonArray.getLong(i);
        }
        bundle.putLongArray(key, array);
    } else if (valueType.equals(TYPE_FLOAT)) {
        bundle.putFloat(key, (float)json.getDouble(JSON_VALUE));
    } else if (valueType.equals(TYPE_FLOAT_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        float[] array = new float[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = (float)jsonArray.getDouble(i);
        }
        bundle.putFloatArray(key, array);
    } else if (valueType.equals(TYPE_DOUBLE)) {
        bundle.putDouble(key, json.getDouble(JSON_VALUE));
    } else if (valueType.equals(TYPE_DOUBLE_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        double[] array = new double[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = jsonArray.getDouble(i);
        }
        bundle.putDoubleArray(key, array);
    } else if (valueType.equals(TYPE_CHAR)) {
        String charString = json.getString(JSON_VALUE);
        if (charString != null && charString.length() == 1) {
            bundle.putChar(key, charString.charAt(0));
        }
    } else if (valueType.equals(TYPE_CHAR_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        char[] array = new char[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            String charString = jsonArray.getString(i);
            if (charString != null && charString.length() == 1) {
                array[i] = charString.charAt(0);
            }
        }
        bundle.putCharArray(key, array);
    } else if (valueType.equals(TYPE_STRING)) {
        bundle.putString(key, json.getString(JSON_VALUE));
    } else if (valueType.equals(TYPE_STRING_LIST)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        int numStrings = jsonArray.length();
        ArrayList<String> stringList = new ArrayList<String>(numStrings);
        for (int i = 0; i < numStrings; i++) {
            Object jsonStringValue = jsonArray.get(i);
            stringList.add(i, jsonStringValue == JSONObject.NULL ? null : (String)jsonStringValue);
        }
        bundle.putStringArrayList(key, stringList);
    }
}

2

配列リストをアプリケーションクラスに貼り付けてみませんか?アプリが実際に強制終了された場合にのみ破棄されるため、アプリが利用可能である限り保持されます。


5
アプリケーションが再起動された場合はどうなるでしょうか。
Manohar Perepa、2015年

2

私が見つけた最良の方法は、キーの2D配列を作成し、配列のカスタム項目をキーの2D配列に入れて、起動時に2D Arraを介して取得することです。ほとんどのAndroidユーザーはまだジンジャーブレッドを使用しており、文字列セットを使用するにはハニカムが必要なため、文字列セットを使用するという考えは気に入りませんでした。

サンプルコード:ここでditorは共有設定エディターで、rowitemは私のカスタムオブジェクトです。

editor.putString(genrealfeedkey[j][1], Rowitemslist.get(j).getname());
        editor.putString(genrealfeedkey[j][2], Rowitemslist.get(j).getdescription());
        editor.putString(genrealfeedkey[j][3], Rowitemslist.get(j).getlink());
        editor.putString(genrealfeedkey[j][4], Rowitemslist.get(j).getid());
        editor.putString(genrealfeedkey[j][5], Rowitemslist.get(j).getmessage());

2

次のコードは受け入れられた回答であり、新しい人々(私)のためにさらに数行あります。は、セットタイプオブジェクトをarrayListに変換する方法と、「。putStringSet」および「.getStringSet」の前にあるものに関する追加のガイダンスを示しています。(エビロンありがとう)

// shared preferences
   private SharedPreferences preferences;
   private SharedPreferences.Editor nsuserdefaults;

// setup persistent data
        preferences = this.getSharedPreferences("MyPreferences", MainActivity.MODE_PRIVATE);
        nsuserdefaults = preferences.edit();

        arrayOfMemberUrlsUserIsFollowing = new ArrayList<String>();
        //Retrieve followers from sharedPreferences
        Set<String> set = preferences.getStringSet("following", null);

        if (set == null) {
            // lazy instantiate array
            arrayOfMemberUrlsUserIsFollowing = new ArrayList<String>();
        } else {
            // there is data from previous run
            arrayOfMemberUrlsUserIsFollowing = new ArrayList<>(set);
        }

// convert arraylist to set, and save arrayOfMemberUrlsUserIsFollowing to nsuserdefaults
                Set<String> set = new HashSet<String>();
                set.addAll(arrayOfMemberUrlsUserIsFollowing);
                nsuserdefaults.putStringSet("following", set);
                nsuserdefaults.commit();

2
//Set the values
intent.putParcelableArrayListExtra("key",collection);

//Retrieve the values
ArrayList<OnlineMember> onlineMembers = data.getParcelableArrayListExtra("key");


2

シリアライゼーションまたはGsonライブラリを使用して、リストを文字列に、またはその逆に変換し、文字列を設定に保存できます。

GoogleのGsonライブラリを使用する:

//Converting list to string
new Gson().toJson(list);

//Converting string to list
new Gson().fromJson(listString, CustomObjectsList.class);

Javaシリアル化の使用:

//Converting list to string
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(list);
oos.flush();
String string = Base64.encodeToString(bos.toByteArray(), Base64.DEFAULT);
oos.close();
bos.close();
return string;

//Converting string to list
byte[] bytesArray = Base64.decode(familiarVisitsString, Base64.DEFAULT);
ByteArrayInputStream bis = new ByteArrayInputStream(bytesArray);
ObjectInputStream ois = new ObjectInputStream(bis);
Object clone = ois.readObject();
ois.close();
bis.close();
return (CustomObjectsList) clone;

2

このメソッドは、配列リストを保存/保存するために使用されます:-

 public static void saveSharedPreferencesLogList(Context context, List<String> collageList) {
            SharedPreferences mPrefs = context.getSharedPreferences("PhotoCollage", context.MODE_PRIVATE);
            SharedPreferences.Editor prefsEditor = mPrefs.edit();
            Gson gson = new Gson();
            String json = gson.toJson(collageList);
            prefsEditor.putString("myJson", json);
            prefsEditor.commit();
        }

このメソッドは、配列リストを取得するために使用されます:-

public static List<String> loadSharedPreferencesLogList(Context context) {
        List<String> savedCollage = new ArrayList<String>();
        SharedPreferences mPrefs = context.getSharedPreferences("PhotoCollage", context.MODE_PRIVATE);
        Gson gson = new Gson();
        String json = mPrefs.getString("myJson", "");
        if (json.isEmpty()) {
            savedCollage = new ArrayList<String>();
        } else {
            Type type = new TypeToken<List<String>>() {
            }.getType();
            savedCollage = gson.fromJson(json, type);
        }

        return savedCollage;
    }

1

これをMapオブジェクトに変換して保存し、を取得するときに値をArrayListに戻すことができますSharedPreferences


1

このカスタムクラスを使用します。

public class SharedPreferencesUtil {

    public static void pushStringList(SharedPreferences sharedPref, 
                                      List<String> list, String uniqueListName) {

        SharedPreferences.Editor editor = sharedPref.edit();
        editor.putInt(uniqueListName + "_size", list.size());

        for (int i = 0; i < list.size(); i++) {
            editor.remove(uniqueListName + i);
            editor.putString(uniqueListName + i, list.get(i));
        }
        editor.apply();
    }

    public static List<String> pullStringList(SharedPreferences sharedPref, 
                                              String uniqueListName) {

        List<String> result = new ArrayList<>();
        int size = sharedPref.getInt(uniqueListName + "_size", 0);

        for (int i = 0; i < size; i++) {
            result.add(sharedPref.getString(uniqueListName + i, null));
        }
        return result;
    }
}

使い方:

SharedPreferences sharedPref = getPreferences(Context.MODE_PRIVATE);
SharedPreferencesUtil.pushStringList(sharedPref, list, getString(R.string.list_name));
List<String> list = SharedPreferencesUtil.pullStringList(sharedPref, getString(R.string.list_name));

1

これはうまくいくはずです:

public void setSections (Context c,  List<Section> sectionList){
    this.sectionList = sectionList;

    Type sectionListType = new TypeToken<ArrayList<Section>>(){}.getType();
    String sectionListString = new Gson().toJson(sectionList,sectionListType);

    SharedPreferences.Editor editor = getSharedPreferences(c).edit().putString(PREFS_KEY_SECTIONS, sectionListString);
    editor.apply();
}

それら、それを捕まえるために:

public List<Section> getSections(Context c){

    if(this.sectionList == null){
        String sSections = getSharedPreferences(c).getString(PREFS_KEY_SECTIONS, null);

        if(sSections == null){
            return new ArrayList<>();
        }

        Type sectionListType = new TypeToken<ArrayList<Section>>(){}.getType();
        try {

            this.sectionList = new Gson().fromJson(sSections, sectionListType);

            if(this.sectionList == null){
                return new ArrayList<>();
            }
        }catch (JsonSyntaxException ex){

            return new ArrayList<>();

        }catch (JsonParseException exc){

            return new ArrayList<>();
        }
    }
    return this.sectionList;
}

わたしにはできる。


1

リストを保存するための私のutilsクラス SharedPreferences

public class SharedPrefApi {
    private SharedPreferences sharedPreferences;
    private Gson gson;

    public SharedPrefApi(Context context, Gson gson) {
        this.sharedPreferences = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
        this.gson = gson;
    } 

    ...

    public <T> void putList(String key, List<T> list) {
        SharedPreferences.Editor editor = sharedPreferences.edit();
        editor.putString(key, gson.toJson(list));
        editor.apply();
    }

    public <T> List<T> getList(String key, Class<T> clazz) {
        Type typeOfT = TypeToken.getParameterized(List.class, clazz).getType();
        return gson.fromJson(getString(key, null), typeOfT);
    }
}

使用する

// for save
sharedPrefApi.putList(SharedPrefApi.Key.USER_LIST, userList);

// for retrieve
List<User> userList = sharedPrefApi.getList(SharedPrefApi.Key.USER_LIST, User.class);


私のユーティリティの完全なコード //アクティビティコードの例を使用してチェック


1

Stringの保存と取得と同じ方法を使用しましたが、ここではarrayListでHashSetをメディエーターとして使用しました

arrayListをSharedPreferencesに保存するには、HashSetを使用します。

1-SharedPreferences変数を作成します(配列に変更が発生する場所に)

2-arrayListをHashSetに変換します

3-次に、stringSetを配置して適用します

4-HashSet内でgetStringSetを作成し、ArrayListを再作成してHashSetを設定します。

public class MainActivity extends AppCompatActivity {
    ArrayList<String> arrayList = new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        SharedPreferences prefs = this.getSharedPreferences("com.example.nec.myapplication", Context.MODE_PRIVATE);

        HashSet<String> set = new HashSet(arrayList);
        prefs.edit().putStringSet("names", set).apply();


        set = (HashSet<String>) prefs.getStringSet("names", null);
        arrayList = new ArrayList(set);

        Log.i("array list", arrayList.toString());
    }
}

0
    public  void saveUserName(Context con,String username)
    {
        try
        {
            usernameSharedPreferences= PreferenceManager.getDefaultSharedPreferences(con);
            usernameEditor = usernameSharedPreferences.edit();
            usernameEditor.putInt(PREFS_KEY_SIZE,(USERNAME.size()+1)); 
            int size=USERNAME.size();//USERNAME is arrayList
            usernameEditor.putString(PREFS_KEY_USERNAME+size,username);
            usernameEditor.commit();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }

    }
    public void loadUserName(Context con)
    {  
        try
        {
            usernameSharedPreferences= PreferenceManager.getDefaultSharedPreferences(con);
            size=usernameSharedPreferences.getInt(PREFS_KEY_SIZE,size);
            USERNAME.clear();
            for(int i=0;i<size;i++)
            { 
                String username1="";
                username1=usernameSharedPreferences.getString(PREFS_KEY_USERNAME+i,username1);
                USERNAME.add(username1);
            }
            usernameArrayAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_dropdown_item_1line, USERNAME);
            username.setAdapter(usernameArrayAdapter);
            username.setThreshold(0);

        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }

0

上記の答えはすべて正しいです。:)私は自分の状況にこれらの1つを使用しました。しかし、質問を読んだとき、私が間違っていなければ、OPが実際にはこの投稿のタイトルとは異なるシナリオについて話していることがわかりました。

「ユーザーがアクティビティを離れて、後で戻ってきたい場合でも、配列を固定しておく必要があります。」

彼は実際、ユーザーがアプリケーション内で画面を変更するかどうかに関係なく、アプリが開くまでデータが保存されることを望んでいます。

「しかし、アプリケーションが完全に閉じられた後は、配列を使用可能にする必要はありません。」

しかし、いったんアプリケーションが閉じられると、データは保持されるべきでSharedPreferencesはないので、これを使用するのは最適な方法ではないと思います。

この要件に対してできることは、クラスを拡張するクラスを作成することですApplication

public class MyApp extends Application {

    //Pardon me for using global ;)

    private ArrayList<CustomObject> globalArray;

    public void setGlobalArrayOfCustomObjects(ArrayList<CustomObject> newArray){
        globalArray = newArray; 
    }

    public ArrayList<CustomObject> getGlobalArrayOfCustomObjects(){
        return globalArray;
    }

}

setterとgetterを使用して、ArrayListにアプリケーション内のどこからでもアクセスできます。そして、最良の部分は、アプリが閉じられると、保存されているデータについて心配する必要がなくなります。:)

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.