मेरे पास ArrayListकस्टम ऑब्जेक्ट्स हैं। प्रत्येक कस्टम ऑब्जेक्ट में कई प्रकार के तार और संख्याएँ होती हैं। उपयोगकर्ता को गतिविधि छोड़ देने पर भी मुझे ऐरे के चारों ओर चिपके रहने की आवश्यकता होती है और फिर बाद में वापस आना चाहता है, हालाँकि मुझे एप्लिकेशन पूरी तरह से बंद होने के बाद उपलब्ध सरणी की आवश्यकता नहीं है। मैं इस तरह से कई अन्य वस्तुओं SharedPreferencesको सहेजता हूं , लेकिन मैं यह नहीं पता लगा सकता हूं कि इस तरह से मेरे पूरे सरणी को कैसे बचाया जाए। क्या यह संभव है? शायद SharedPreferencesइस बारे में जाने का रास्ता नहीं है? क्या कोई सरल विधि है?

android arraylist sharedpreferences

— ryandlf
स्रोत

आप यहाँ उत्तर पा सकते हैं: stackoverflow.com/questions/14981233/…

— अपूर्वा कोलापकर

यह पूरा उदाहरण url stackoverflow.com/a/41137562/4344659 के

— संजीव संगराल

अगर किसी को समाधान की तलाश है, तो यह वह जवाब हो सकता है जिसे आप कोटलिन में पूर्ण उपयोग उदाहरण के साथ मांग रहे हैं। stackoverflow.com/a/56873719/3710341

— सागर चापागैन

431

एपीआई 11 के बाद SharedPreferences Editorस्वीकार करते हैं Sets। आप अपनी सूची को एक 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 वर्ग की विधि में, हमें साझा प्राथमिकता का उदाहरण प्राप्त करना होगा और फिर putString()विधि का उपयोग करके क्रमबद्ध ArrayList को संग्रहीत करना होगा :

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एपीआई 11 में जोड़ा गया था। अधिकांश वर्तमान प्रोग्रामर पट्टे एपीआई 8 (फ्रायो) पर लक्षित करते हैं।

— क्रिश्चियन

2

मुझे इस पद्धति का विचार पसंद है क्योंकि यह सबसे साफ लगता है, लेकिन जिस सरणी को मैं स्टोर करना चाहता हूं वह एक कस्टम क्लास ऑब्जेक्ट है जिसमें स्ट्रिंग्स, डबल्स और बूलियन शामिल हैं। मैं इन तीनों प्रकारों को एक सेट में कैसे जोड़ूं? क्या मुझे हर व्यक्तिगत वस्तु को अपने स्वयं के सरणी में सेट करना है और फिर व्यक्तिगत रूप से अलग-अलग सेटों में मुझे स्टोर करने से पहले जोड़ना है, या एक सरल तरीका है?

— रयानडेल

5

क्या है scoreEditor?

— रुचिर बरोनिया

2

अक्टूबर 2016 के बाद के पाठकों के लिए: इस टिप्पणी से पहले ही बहुत कुछ हो जाता है और आप इसे मेरी तरह उपयोग कर सकते हैं, लेकिन कृपया इसे रोकें और ऐसा न करें। HashSet डुप्लिकेट मान को छोड़ देगा, इस प्रकार आपका ArrayList समान नहीं होगा। यहाँ विवरण: stackoverflow.com/questions/12940663/…

— seoul

2

इस उत्तर पर आने वालों के लिए एक चेतावनी के रूप में: एक सेट अनियंत्रित है, इसलिए एक स्ट्रिंगसेट को सहेजना उस आदेश को खो देगा जो आपने अपने एरियर के साथ किया था।

— डेविड लियू

119

इस ऑब्जेक्ट का उपयोग करना -> टिनीबीडी - एंड्रॉइड-साझा-प्राथमिकताएं-टर्बो इसकी बहुत सरल है।

TinyDB tinydb = new TinyDB(context);

रखना

tinydb.putList("MyUsers", mUsersArray);

लेना

tinydb.getList("MyUsers");

अपडेट करें

कुछ उपयोगी उदाहरण और समस्या निवारण यहां मिल सकते हैं: Android साझा वरीयताएँ TinyDB putListObject फ्रिक्शन

— kc ochibili
स्रोत

6

यह सबसे अच्छा दृष्टिकोण है। मेरी तरफ से +1

— श्रीतम जगदेव

3

मैं भी। अत्यंत उपयोगी !!

— जुआन एगुइलर गुइसाडो

1

आपकी सूची की सामग्री के आधार पर, tinydb.putList()लिंक किए गए पृष्ठ पर दिए गए उदाहरणों को देखते समय आपको अपनी सूची का ऑब्जेक्ट प्रकार निर्दिष्ट करना होगा ।

— kc ochibili

अच्छी बात है, लेकिन मुझे यह उल्लेख करना चाहिए कि कभी-कभी वस्तुओं के भंडारण के समय इस पुस्तकालय में समस्याएँ होती हैं। अधिक विशिष्ट होने के लिए, यह स्टैक ओवरफ्लो अपवाद को फेंक सकता है। और मुझे लगता है कि यह इसलिए है क्योंकि यह प्रतिबिंब का उपयोग करता है कि वस्तु को कैसे संग्रहीत किया जाए, और यदि वस्तु बहुत जटिल हो जाती है तो वह उस अपवाद को फेंक सकती है।

— मि।

1

मुझ तुमसे बहुत प्यार है!

— माइकेमिक्रो

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

यह एक बहुत अच्छा "हैक" है। विदित हो कि इस पद्धति के साथ, अप्रयुक्त पुराने मूल्यों के साथ शेयर्डप्रिफरेंस को खिलाने की हमेशा सकारात्मकता होती है। उदाहरण के लिए एक सूची में एक रन पर 100 का आकार, और फिर 50 का आकार हो सकता है। 50 पुरानी प्रविष्टियां वरीयताओं पर बनी रहेंगी। एक तरह से एक MAX मान सेट कर रहा है और उस तक कुछ भी साफ़ कर रहा है।

— इराकलीस

3

@Iraklis वास्तव में, लेकिन यह मानते हुए कि आप इसे केवल इस ArrayListमें संग्रहीत करते हैं कि SharedPrefenecesआप इससे mEdit1.clear()बचने के लिए उपयोग कर सकें।

— अलेक्सांद्रो

1

मुझे यह "हैक" पसंद है। लेकिन mEdit1.clear () इस उद्देश्य के लिए प्रासंगिक अन्य मूल्यों को मिटा देगा?

— Bagusflyer

1

धन्यवाद! यदि आप मुझसे पूछते हैं कि क्या, .remove () के लिए एक आवश्यक उद्देश्य है? वैसे भी वरीयता अधिलेखित नहीं होगी?

— स्क्रिप्ट किटी

62

आप इसे में बदल सकते हैं JSON Stringऔर स्ट्रिंग को स्टोर कर सकते हैं SharedPreferences।

— MByD
स्रोत

मुझे ArrayLists को JSONArrays में परिवर्तित करने पर एक टन कोड मिल रहा है, लेकिन क्या आपके पास एक नमूना है जिसे आप JSONString में परिवर्तित करने के लिए तैयार हो सकते हैं ताकि मैं इसे SharedPrefs में संग्रहीत कर सकूं?

— रयानडॉल्फ

5

toString ()

— MByD

3

लेकिन फिर मैं इसे SharedPrefs से कैसे निकालूं और इसे वापस ArrayList में बदल दूं?

— रयानडेल

मुझे क्षमा करें, मेरे पास अभी इसका परीक्षण करने के लिए Android SDK नहीं है, लेकिन यहाँ एक नज़र डालें: benjii.me/2010/04/deserializing-json-in-android-use-gson । आपको जसन सरणी पर पुनरावृति करनी चाहिए और प्रत्येक वस्तु के लिए वहां क्या करना चाहिए, उम्मीद है कि मैं कल एक पूर्ण उदाहरण के साथ अपने उत्तर पर एक संपादन पोस्ट कर सकूंगा।

— एमबी 12

53

जैसा कि @nirav ने कहा, बेस्ट सॉल्यूशन इसे साझा कर रहा है। इसे साझा किया गया है। नीचे नमूना कोड:

//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

भगवान का शुक्र है, कि एक जीवन रक्षक था। वास्तव में बहुत सरल है।

— पार्थिबन एम

2

इस उत्तर को जोर से देखा जाए। उत्तम! नहीं पता था कि मैं इस तरह से Gson का उपयोग कर सकता हूं। पहली बार सरणी संकेतन को देखने के लिए इस तरह से भी इस्तेमाल किया। धन्यवाद!

— मदु

3

इसे वापस सूची में बदलने के लिए, सूची <string> textList = Arrays.asList (gson.fromJson (jsonText, String []। Class));

— वामसी चल्ला

22

अरे दोस्तों मुझे उपर्युक्त समस्या का समाधान बिना उपयोग के मिल गया Gson पुस्तकालय । यहां मैं स्रोत कोड पोस्ट करता हूं।

1.Variable घोषणा यानी

  SharedPreferences shared;
  ArrayList<String> arrPackage;

2.Variable आरंभीकरण यानी

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

3. साझा मूल्य का उपयोग करने के लिए अतिरिक्त मूल्य 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.Retrive मूल्य retriveSharedValue():

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

मुझे उम्मीद है कि यह आपके लिए उपयोगी होगा ...

— साचिन पंगारे
स्रोत

महान समाधान! आसान और तेज़!

— लवएंड्रॉइड

5

जैसे ही आप किसी सेट में शामिल होते हैं, सूची से सभी डुप्लिकेट स्ट्रिंग्स हटा देगा। संभवतः एक वांछित विशेषता नहीं है

— OneCricketeer

क्या यह केवल Stringएस की सूची के लिए है ?

— कूलमैन्ड

आप इस तरह से ऑर्डर खो देंगे

— ब्रायन रेनहोल्ड

16

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

जावा:

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

Kotlin

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

— Raviraj
स्रोत

1

हां, सबसे अच्छा जवाब

— एलेक्सपैड

यह सबसे अच्छा जवाब है, मैं इसे अन्य वस्तुओं को भी संग्रहीत करने के लिए उपयोग कर रहा हूं

— इरफंडी डी। वेंडी

क्या आप इसका मतलब यह कर सकते हैं कि यह सभी मॉडल वर्ग को संग्रहीत करेगा?

— ब्लैकबाइंड

13

Android SharedPreferances आपको xml फ़ाइल के रूप में मेमोरी में आदिम प्रकार (बूलियन, फ्लोट, इंट, लॉन्ग, स्ट्रिंग और स्ट्रिंगसेट जो एपीआई 11 से उपलब्ध है) को सहेजने की अनुमति देता है।

किसी भी समाधान का मुख्य विचार डेटा को उन आदिम प्रकारों में से एक में बदलना होगा।

मैं व्यक्तिगत रूप से अपनी सूची को जोंस प्रारूप में बदलना पसंद करता हूं और फिर इसे एक साझाकरण मूल्य में स्ट्रिंग के रूप में सहेजता हूं।

मेरे समाधान का उपयोग करने के लिए आपको Google Gson lib जोड़ना होगा ।

धीरे-धीरे केवल निम्न निर्भरता जोड़ें (कृपया 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());

— एवी लेविन
स्रोत

धन्यवाद। इस उत्तर ने मुझे मेरी सूची <MyObject> को पुनः प्राप्त करने और सहेजने में मदद की।

— विराघन

धन्यवाद। ठीक काम

— वेलयुतम एम।

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

आप सरणीसूची को स्ट्रिंग में भी बदल सकते हैं और वरीयता में सहेज सकते हैं

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

आप Arraylist को convertToStringविधि का उपयोग करके स्ट्रिंग में परिवर्तित करने के बाद सहेज सकते हैं और स्ट्रिंग को पुनः प्राप्त कर सकते हैं और इसे सरणी उपयोग में परिवर्तित कर सकते हैंconvertToArray

एपीआई 11 के बाद आप सीधे साझा करने के लिए साझा कर सकते हैं, हालांकि !!! :)

— SKT
स्रोत

6

स्ट्रिंग, इंट, बूलियन के लिए, सबसे अच्छा विकल्प साझाकरण होगा।

यदि आप 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

मैंने ऊपर सभी उत्तर पढ़े हैं। यह सब सही है लेकिन मुझे नीचे के रूप में एक अधिक आसान समाधान मिला है:

साझा प्राथमिकता में बचत स्ट्रिंग सूची >>

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

}

और साझा-वरीयता से स्ट्रिंग सूची प्राप्त करने के लिए >>

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

कोटलिन के साथ भी:

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 लाइब्रेरी का उपयोग करके सहेज सकते हैं।

=> सबसे पहले आपको साझा सूची को साझा सूची को सहेजने के लिए फ़ंक्शन बनाने की आवश्यकता है।

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

}

=> कैसे सहेजें कॉल करने के लिए और सरणी सूची समारोह को पुनः प्राप्त करने के लिए।

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

=> आप app स्तर build.gradle में gson लाइब्रेरी को जोड़ना न भूलें।

कार्यान्वयन 'com.google.code.gson: gson: 2.8.2'

— पारस संतोकी
स्रोत

3

आप FacebookSDK के SharedPreferencesTokenCache वर्ग से serializeKey () और deserializeKey () फ़ंक्शन का उल्लेख कर सकते हैं। यह समर्थित टाइप को JSON ऑब्जेक्ट में कनवर्ट करता है और JSON स्ट्रिंग को SharedPreferences में संग्रहीत करता है । आप यहां से एसडीके डाउनलोड कर सकते हैं

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

— emeraldhieu
स्रोत

2

आप किसी एप्लिकेशन वर्ग पर अपनी सरणी सूची क्यों नहीं चिपकाते? यह केवल तब नष्ट हो जाता है जब ऐप वास्तव में मारा जाता है, इसलिए, जब तक ऐप उपलब्ध होगा, तब तक यह चारों ओर चिपका रहेगा।

— कार्लोस सिल्वा
स्रोत

5

क्या होगा अगर आवेदन फिर से relaunched है।

— मनोहर परेरा

2

सबसे अच्छा तरीका है कि मैं खोजने के लिए सक्षम किया गया है एक कुंजी का 2 डी सरणी बनाने और सरणी के कस्टम आइटम 2-डी सरणी में डाल दिया और फिर इसे स्टार्टअप पर 2 डी arra के माध्यम से पुनः प्राप्त। मुझे स्ट्रिंग सेट का उपयोग करने का विचार पसंद नहीं आया क्योंकि अधिकांश Android उपयोगकर्ता अभी भी जिंजरब्रेड पर हैं और स्ट्रिंग सेट का उपयोग करने के लिए मधुकोश की आवश्यकता होती है।

सैंपल कोड: यहां डिटर साझा प्रीफ़ एडिटर है और रोएटीम मेरी कस्टम ऑब्जेक्ट है।

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

निम्नलिखित कोड नए लोगों (मुझे) के लिए कुछ और पंक्तियों के साथ स्वीकृत उत्तर है, जैसे। दिखाता है कि सेट प्रकार की वस्तु को वापस सरणी में कैसे परिवर्तित किया जाए, और ring .putStringSS ’और S .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();

— tmr
स्रोत

2

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

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

— मौलिक गोहेल
स्रोत

2

सीरियल को लागू करने के लिए मत भूलना:

Class dataBean implements Serializable{
 public String name;
}
ArrayList<dataBean> dataBeanArrayList = new ArrayList();

https://stackoverflow.com/a/7635154/4639974

— मैनुअल श्मेट्ज़बर्गर
स्रोत

2

सूची को स्ट्रिंग और इसके विपरीत में परिवर्तित करने के लिए आप क्रमांकन या Gson लाइब्रेरी का उपयोग कर सकते हैं और फिर वरीयताओं में स्ट्रिंग को बचा सकते हैं।

Google की Gson लाइब्रेरी का उपयोग करना:

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

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

जावा क्रमांकन का उपयोग करना:

//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

मेरी सूची को बचाने के लिए बर्तन कक्षा 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

मैंने एक स्ट्रिंग को बचाने और पुनः प्राप्त करने का एक ही तरीका इस्तेमाल किया है, लेकिन यहाँ सरणी के साथ मैंने एक मध्यस्थ के रूप में हैशसेट का उपयोग किया है

शेयर्सप्रफरेन्स के लिए एंसीलिस्ट को बचाने के लिए हम हैशेट का उपयोग करते हैं:

1- हम शेयर्डप्रिफरेंस वैरिएबल बनाते हैं (स्थान में जहां परिवर्तन सरणी के लिए होता है)

2 - हम arrayList को HashSet में बदलते हैं

3 - फिर हम स्ट्रिंग लगाते हैं और आवेदन करते हैं

4 - आप HashSet के भीतर GetStringSet और HashSet को सेट करने के लिए ArrayList को फिर से बनाएँ।

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

— user4680583
स्रोत

0

उपरोक्त सभी उत्तर सही हैं। :) मैंने खुद अपनी स्थिति के लिए इनमें से एक का इस्तेमाल किया। हालाँकि जब मैंने प्रश्न पढ़ा तो मैंने पाया कि ओपी वास्तव में इस पोस्ट के शीर्षक से अलग परिदृश्य के बारे में बात कर रहा है, अगर मुझे यह गलत नहीं लगा।

"अगर उपयोगकर्ता ने गतिविधि छोड़ दी और फिर बाद में वापस आना चाहता है, तो मुझे सरणी को चारों ओर से चिपकाने की आवश्यकता है"

वह वास्तव में चाहता है कि एप्लिकेशन के खुलने तक डेटा को स्टोर किया जाए, भले ही एप्लिकेशन के भीतर उपयोगकर्ता स्क्रीन बदल रहा हो।

"हालांकि मुझे आवेदन के पूरी तरह से बंद होने के बाद उपलब्ध सरणी की आवश्यकता नहीं है"

लेकिन एक बार आवेदन बंद होने के बाद डेटा को संरक्षित नहीं किया जाना चाहिए 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;
    }

}

सेटर और गेटर का उपयोग करके ArrayList को एप्लिकेशन के साथ कहीं से भी एक्सेस किया जा सकता है। और सबसे अच्छी बात यह है कि ऐप के बंद होने के बाद, हमें स्टोर किए जा रहे डेटा के बारे में चिंता करने की ज़रूरत नहीं है। :)

— अतुल ओ होलिक
स्रोत

साझा करें