android - मूल्यों को स्टोर, लाने और संपादित करने के लिए एंड्रॉइड में साझा किए गए संदर्भों का उपयोग कैसे करें




sharedpreferences (20)

सरल और परेशानी मुक्त :: "एंड्रॉइड-साझा संदर्भ-सहायक" पुस्तकालय

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

  • एक लाइन प्रारंभिकरण और सेटअप
  • आसानी से चयन करना कि डिफ़ॉल्ट वरीयताओं या कस्टम वरीयता फ़ाइल का उपयोग करना है या नहीं
  • पूर्व निर्धारित (डेटा प्रकार डिफ़ॉल्ट) और अनुकूलन (आप क्या चुन सकते हैं) प्रत्येक डेटाटाइप के लिए डिफ़ॉल्ट मान
  • केवल एक अतिरिक्त पैरा के साथ एकल उपयोग के लिए अलग-अलग डिफ़ॉल्ट मान सेट करने की क्षमता
  • आप डिफ़ॉल्ट श्रेणी के लिए करते हैं, तो आप OnSharedPreferenceChangeListener को पंजीकृत और अनधिकृत कर सकते हैं
dependencies {
    ...
    ...
    compile(group: 'com.viralypatel.sharedpreferenceshelper', name: 'library', version: '1.1.0', ext: 'aar')
}

SharedPreferences की घोषणा हेल्पर ऑब्जेक्ट: (कक्षा स्तर पर अनुशंसित)

SharedPreferencesHelper sph; 

SharedPreferencesHelper ऑब्जेक्ट का इंस्टेंटेशन: (ऑनक्रेट () विधि में अनुशंसित)

// use one of the following ways to instantiate
sph = new SharedPreferencesHelper(this); //this will use default shared preferences
sph = new SharedPreferencesHelper(this, "myappprefs"); // this will create a named shared preference file
sph = new SharedPreferencesHelper(this, "myappprefs", 0); // this will allow you to specify a mode

मूल्यों को साझा प्राथमिकताओं में डालना

काफी सरल! डिफ़ॉल्ट तरीके से (जब SharePreferences क्लास का उपयोग करते हैं) आपको कभी भी .edit() और .commit() को कॉल करने की आवश्यकता नहीं होगी।

sph.putBoolean("boolKey", true);
sph.putInt("intKey", 123);
sph.putString("stringKey", "string value");
sph.putLong("longKey", 456876451);
sph.putFloat("floatKey", 1.51f);

// putStringSet is supported only for android versions above HONEYCOMB
Set name = new HashSet();
name.add("Viral");
name.add("Patel");
sph.putStringSet("name", name);

बस! आपके मान साझा प्राथमिकताओं में संग्रहीत हैं।

साझा वरीयताओं से मूल्य प्राप्त करना

फिर, कुंजी नाम के साथ बस एक साधारण विधि कॉल करें।

sph.getBoolean("boolKey");
sph.getInt("intKey");
sph.getString("stringKey");
sph.getLong("longKey");
sph.getFloat("floatKey");

// getStringSet is supported only for android versions above HONEYCOMB
sph.getStringSet("name");

इसमें कई अन्य विस्तारित कार्यक्षमताएं हैं

गिटहब रिपोजिटरी पेज पर विस्तारित कार्यक्षमता, उपयोग और स्थापना निर्देश आदि के विवरण देखें।

मैं एक समय मूल्य स्टोर करना चाहता हूं और उसे पुनः प्राप्त करने और संपादित करने की आवश्यकता है। ऐसा करने के लिए मैं SharedPreferences का उपयोग कैसे कर सकता हूं?


वरीयताओं में मूल्य निर्धारित करना:

// MY_PREFS_NAME - a static String variable like: 
//public static final String MY_PREFS_NAME = "MyPrefsFile";
SharedPreferences.Editor editor = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE).edit();
 editor.putString("name", "Elena");
 editor.putInt("idName", 12);
 editor.commit();

वरीयता से डेटा पुनर्प्राप्त करें:

SharedPreferences prefs = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE); 
String restoredText = prefs.getString("text", null);
if (restoredText != null) {
  String name = prefs.getString("name", "No name defined");//"No name defined" is the default value.
  int idName = prefs.getInt("idName", 0); //0 is the default value.
}

और जानकारी:

साझा प्राथमिकताओं का उपयोग करना

साझा प्राथमिकताएं


इस सरल पुस्तकालय का उपयोग करके, यहां बताया गया है कि आप साझा किए गए संदर्भों पर कॉल कैसे करते हैं ..

TinyDB tinydb = new TinyDB(context);

tinydb.putInt("clickCount", 2);

tinydb.putString("userName", "john");
tinydb.putBoolean("isUserMale", true); 

tinydb.putList("MyUsers", mUsersArray);
tinydb.putImagePNG("DropBox/WorkImages", "MeAtlunch.png", lunchBitmap);

//These plus the corresponding get methods are all Included

किसी भी एप्लिकेशन में, डिफ़ॉल्ट प्राथमिकताएं होती हैं जिन्हें वरीयता getDefaultSharedPreferences(Context) उदाहरण और इसके संबंधित विधि getDefaultSharedPreferences(Context) माध्यम से एक्सेस किया जा सकता है।

SharedPreference उदाहरण के साथ कोई getInt (स्ट्रिंग कुंजी, int defVal) के साथ किसी वरीयता के int मान को पुनर्प्राप्त कर सकता है। इस मामले में हम रुचि रखते हैं वरीयता है।

हमारे मामले में, हम संपादन () का उपयोग करके हमारे मामले में SharedPreference उदाहरण को संशोधित कर सकते हैं और putInt(String key, int newVal) उपयोग करते हैं putInt(String key, int newVal) हमने हमारे आवेदन के लिए गिनती बढ़ा दी है जो आवेदन से परे है और तदनुसार प्रदर्शित होती है।

इसे आगे बढ़ाने के लिए, पुनरारंभ करें और आप फिर से आवेदन करें, आप देखेंगे कि प्रत्येक बार जब आप एप्लिकेशन को पुनरारंभ करेंगे तो गिनती बढ़ेगी।

PreferencesDemo.java

कोड:

package org.example.preferences;
import android.app.Activity;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.widget.TextView;

public class PreferencesDemo extends Activity {
   /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Get the app's shared preferences
        SharedPreferences app_preferences = 
        PreferenceManager.getDefaultSharedPreferences(this);

        // Get the value for the run counter
        int counter = app_preferences.getInt("counter", 0);

        // Update the TextView
        TextView text = (TextView) findViewById(R.id.text);
        text.setText("This app has been started " + counter + " times.");

        // Increment the counter
        SharedPreferences.Editor editor = app_preferences.edit();
        editor.putInt("counter", ++counter);
        editor.commit(); // Very important
    }
}

main.xml

कोड:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
      android:orientation="vertical"
      android:layout_width="fill_parent"
      android:layout_height="fill_parent" >

        <TextView
            android:id="@+id/text"  
            android:layout_width="fill_parent" 
            android:layout_height="wrap_content" 
            android:text="@string/hello" />
</LinearLayout>

मैं यहां जोड़ना चाहता था कि इस प्रश्न के लिए अधिकांश स्निपेट में SharePreferences का उपयोग करते समय MODE_PRIVATE की तरह कुछ होगा। खैर, MODE_PRIVATE का अर्थ है कि जो भी आप इस साझा वरीयता में लिखते हैं केवल आपके आवेदन द्वारा ही पढ़ा जा सकता है।

शेडर्ड प्रेफरेंस () विधि प्राप्त करने के लिए आप जो भी कुंजी पास करते हैं, एंड्रॉइड उस नाम के साथ एक फाइल बनाता है और वरीयता डेटा को स्टोर करता है। यह भी याद रखें कि जब आप अपने आवेदन के लिए एकाधिक वरीयता फाइलों का इरादा रखते हैं तो getSharedPreferences () का उपयोग किया जाना चाहिए। यदि आप एकल वरीयता फ़ाइल का उपयोग करना चाहते हैं और इसमें सभी कुंजी-मूल्य जोड़ों को स्टोर करना चाहते हैं तो getSharedPreference () विधि का उपयोग करें। यह अजीब बात है कि क्यों हर कोई (स्वयं सहित) बस उपरोक्त दो के बीच अंतर को समझने के बिना getSharedPreferences () स्वाद का उपयोग करता है।

निम्नलिखित वीडियो ट्यूटोरियल को https://www.youtube.com/watch?v=2PcAQ1NBy98 सहायता करनी चाहिए


मैं साझा संदर्भों के लिए एक सहायक वर्ग लिखता हूं:

import android.content.Context;
import android.content.SharedPreferences;

/**
 * Created by mete_ on 23.12.2016.
 */
public class HelperSharedPref {

Context mContext;

public HelperSharedPref(Context mContext) {
    this.mContext = mContext;
}

/**
 *
 * @param key Constant RC
 * @param value Only String, Integer, Long, Float, Boolean types
 */
public void saveToSharedPref(String key, Object value) throws Exception {
    SharedPreferences.Editor editor = mContext.getSharedPreferences(key, Context.MODE_PRIVATE).edit();
    if (value instanceof String) {
        editor.putString(key, (String) value);
    } else if (value instanceof Integer) {
        editor.putInt(key, (Integer) value);
    } else if (value instanceof Long) {
        editor.putLong(key, (Long) value);
    } else if (value instanceof Float) {
        editor.putFloat(key, (Float) value);
    } else if (value instanceof Boolean) {
        editor.putBoolean(key, (Boolean) value);
    } else {
        throw new Exception("Unacceptable object type");
    }

    editor.commit();
}

/**
 * Return String
 * @param key
 * @return null default is null
 */
public String loadStringFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    String restoredText = prefs.getString(key, null);

    return restoredText;
}

/**
 * Return int
 * @param key
 * @return null default is -1
 */
public Integer loadIntegerFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Integer restoredText = prefs.getInt(key, -1);

    return restoredText;
}

/**
 * Return float
 * @param key
 * @return null default is -1
 */
public Float loadFloatFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Float restoredText = prefs.getFloat(key, -1);

    return restoredText;
}

/**
 * Return long
 * @param key
 * @return null default is -1
 */
public Long loadLongFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Long restoredText = prefs.getLong(key, -1);

    return restoredText;
}

/**
 * Return boolean
 * @param key
 * @return null default is false
 */
public Boolean loadBooleanFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Boolean restoredText = prefs.getBoolean(key, false);

    return restoredText;
}

}

लोगों द्वारा साझा किए गए साझाकरण का उपयोग करने के कई तरीके हैं। मैंने यहां एक डेमो परियोजना बनाई है । नमूना में मुख्य बिंदु अनुप्रयोगकॉन्टेक्स्ट और एकल साझा संदर्भ वस्तु का उपयोग करना है । यह दर्शाता है कि निम्नलिखित सुविधाओं के साथ साझा संदर्भों का उपयोग कैसे करें: -

  • साझा किए गए संदर्भों को एक्सेस / अपडेट करने के लिए सिंगलटन क्लास का उपयोग करना
  • साझा / संदर्भ साझा करने के लिए हमेशा संदर्भ पारित करने की आवश्यकता नहीं है
  • यह प्रतिबद्ध () के बजाय आवेदन () का उपयोग करता है
  • लागू करें () एसिंक्रोनस सेव है, कुछ भी वापस नहीं करता है, यह पहले स्मृति में मूल्य अपडेट करता है और बाद में डिस्क को एसिंक्रोनसली में लिखा जाता है।
  • प्रतिबद्ध () सिंक्रोनस बचाता है, यह परिणाम के आधार पर सही / गलत लौटाता है। परिवर्तन सिंक्रोनसली डिस्क पर लिखे गए हैं
  • एंड्रॉइड 2.3+ संस्करणों पर काम करता है

उपयोग उदाहरण नीचे के रूप में: -

MyAppPreference.getInstance().setSampleStringKey("some_value");
String value= MyAppPreference.getInstance().getSampleStringKey();

यहां स्रोत कोड प्राप्त करें और विस्तृत API को डेवलपर here पर here पाया जा सकता है


संपादित करें

SharedPreferences pref = getSharedPreferences("YourPref", MODE_PRIVATE);
SharedPreferences.Editor editor = pref.edit();
editor.putString("yourValue", value);
editor.commit();

पढ़ना

SharedPreferences pref = getSharedPreferences("YourPref", MODE_PRIVATE);
value= pref.getString("yourValue", "");

साझा किए गए संदर्भों का मूल विचार एक्सएमएल फ़ाइल पर चीजों को स्टोर करना है।

  1. अपने एक्सएमएल फ़ाइल पथ की घोषणा करें। (यदि आपके पास यह फ़ाइल नहीं है, तो एंड्रॉइड इसे बनाएगा। अगर आपके पास यह फ़ाइल है, तो एंड्रॉइड इसका उपयोग करेगा।)

    SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);
    
  2. साझा प्राथमिकताओं के लिए मूल्य लिखें

    prefs.edit().putLong("preference_file_key", 1010101).apply();
    

    preference_file_key साझा वरीयता फ़ाइलों का नाम है। और 1010101 वह मूल्य है जिसे आपको स्टोर करने की आवश्यकता है।

    अंत में apply() परिवर्तनों को सहेजना है। अगर आपको apply() से त्रुटि मिलती है, तो इसे commit() बदलें। तो यह वैकल्पिक वाक्य है

    prefs.edit().putLong("preference_file_key", 1010101).commit();
    
  3. साझा प्राथमिकताओं से पढ़ें

    SharedPreferences sp = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);
    long lsp = sp.getLong("preference_file_key", -1);
    

    lsp होगा -1 अगर preference_file_key का कोई मान नहीं है। यदि 'preference_file_key' का मान है, तो यह इसका मान वापस कर देगा।

लेखन के लिए पूरा कोड है

    SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);    // Declare xml file
    prefs.edit().putLong("preference_file_key", 1010101).apply();    // Write the value to key.

पढ़ने के लिए कोड है

    SharedPreferences sf = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);    // Declare xml file
    long lsp = sp.getLong("preference_file_key", -1);    // Read the key and store in lsp

साझा प्राथमिकताओं को प्राप्त करने के लिए, निम्न विधि का उपयोग अपनी गतिविधि में करें:

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

वरीयताओं को पढ़ने के लिए:

String dateTimeKey = "com.example.app.datetime";

// use a default value using new Date()
long l = prefs.getLong(dateTimeKey, new Date().getTime()); 

वरीयताओं को संपादित और सहेजने के लिए

Date dt = getSomeDate();
prefs.edit().putLong(dateTimeKey, dt.getTime()).apply();

एंड्रॉइड एसडीके की नमूना निर्देशिका में साझा प्राथमिकताओं को पुनर्प्राप्त करने और संग्रहीत करने का एक उदाहरण है। यह में स्थित है:

<android-sdk-home>/samples/android-<platformversion>/ApiDemos directory

संपादित करें ==>

मैंने देखा, commit() और apply() बीच अंतर लिखना महत्वपूर्ण है।

commit() true वापस लौटाएं यदि मूल्य सफलतापूर्वक सहेजा गया अन्यथा false । यह मूल्यों को समेकित रूप से साझा किए गए संदर्भों में सहेजता है।

apply() 2.3 में जोड़ा गया था और सफलता या विफलता पर कोई भी मूल्य वापस नहीं करता है। यह तुरंत SharePreferences के मानों को बचाता है लेकिन एक एसिंक्रोनस प्रतिबद्धता शुरू करता है। अधिक जानकारी here


सिंगलटन साझा प्राथमिकता कक्षा। यह भविष्य में दूसरों के लिए मदद कर सकता है।

  import android.app.Activity;
import android.content.Context;
import android.content.SharedPreferences;

public class SharedPref
{
    private static SharedPreferences mSharedPref;
    public static final String NAME = "NAME";
    public static final String AGE = "AGE";
    public static final String IS_SELECT = "IS_SELECT";

    private SharedPref()
    {

    }

    public static void init(Context context)
    {
        if(mSharedPref == null)
            mSharedPref = context.getSharedPreferences(context.getPackageName(), Activity.MODE_PRIVATE);
    }

    public static String read(String key, String defValue) {
        return mSharedPref.getString(key, defValue);
    }

    public static void write(String key, String value) {
        SharedPreferences.Editor prefsEditor = mSharedPref.edit();
        prefsEditor.putString(key, value);
        prefsEditor.commit();
    }

    public static boolean read(String key, boolean defValue) {
        return mSharedPref.getBoolean(key, defValue);
    }

    public static void write(String key, boolean value) {
        SharedPreferences.Editor prefsEditor = mSharedPref.edit();
        prefsEditor.putBoolean(key, value);
        prefsEditor.commit();
    }

    public static Integer read(String key, int defValue) {
        return mSharedPref.getInt(key, defValue);
    }

    public static void write(String key, Integer value) {
        SharedPreferences.Editor prefsEditor = mSharedPref.edit();
        prefsEditor.putInt(key, value).commit();
    }
}

केवल एक बार मुख्य क्रियाकलाप पर SharedPref.init () को कॉल करें

SharedPref.init(getApplicationContext());

डेटा लिखने के लिए

SharedPref.write(SharedPref.NAME, "XXXX");//save string in shared preference.
SharedPref.write(SharedPref.AGE, 25);//save int in shared preference.
SharedPref.write(SharedPref.IS_SELECT, true);//save boolean in shared preference.

डेटा पढ़ने के लिए

String name = SharedPref.read(SharedPref.NAME, null);//read string in shared preference.
int age = SharedPref.read(SharedPref.AGE, 0);//read int in shared preference.
boolean isSelect = SharedPref.read(SharedPref.IS_SELECT, false);//read boolean in shared preference.

SharedPreferences द्वारा लॉगिन मूल्य को स्टोर करने का सरल समाधान।

आप MainActivity क्लास या अन्य क्लास का विस्तार कर सकते हैं जहां आप "उस चीज़ का मूल्य" स्टोर करेंगे जिसे आप रखना चाहते हैं "। इसे लेखक और पाठक वर्गों में रखें:

public static final String GAME_PREFERENCES_LOGIN = "Login";

यहां इनपुट क्लास इनपुट है और आउटपुट क्लास क्रमशः आउटपुट क्लास है।

// This is a storage, put this in a class which you can extend or in both classes:
//(input and output)
public static final String GAME_PREFERENCES_LOGIN = "Login";

// String from the text input (can be from anywhere)
String login = inputLogin.getText().toString();

// then to add a value in InputCalss "SAVE",
SharedPreferences example = getSharedPreferences(GAME_PREFERENCES_LOGIN, 0);
Editor editor = example.edit();
editor.putString("value", login);
editor.commit();

अब आप इसे अन्य वर्ग की तरह कहीं और इस्तेमाल कर सकते हैं। निम्नलिखित OutputClass

SharedPreferences example = getSharedPreferences(GAME_PREFERENCES_LOGIN, 0);
String userString = example.getString("value", "defValue");

// the following will print it out in console
Logger.getLogger("Name of a OutputClass".class.getName()).log(Level.INFO, userString);

इस उदाहरण का उपयोग सरल और स्पष्ट और चेक किया गया उपयोग करें

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
   package="com.example.sairamkrishna.myapplication" >

   <application
      android:allowBackup="true"
      android:icon="@mipmap/ic_launcher"
      android:label="@string/app_name"
      android:theme="@style/AppTheme" >

      <activity
         android:name=".MainActivity"
         android:label="@string/app_name" >

         <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
         </intent-filter>

      </activity>

   </application>
</manifest>
public class MainActivity extends AppCompatActivity {
   EditText ed1,ed2,ed3;
   Button b1;

   public static final String MyPREFERENCES = "MyPrefs" ;
   public static final String Name = "nameKey";
   public static final String Phone = "phoneKey";
   public static final String Email = "emailKey";

   SharedPreferences sharedpreferences;

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

      ed1=(EditText)findViewById(R.id.editText);
      ed2=(EditText)findViewById(R.id.editText2);
      ed3=(EditText)findViewById(R.id.editText3);

      b1=(Button)findViewById(R.id.button);
      sharedpreferences = getSharedPreferences(MyPREFERENCES, Context.MODE_PRIVATE);

      b1.setOnClickListener(new View.OnClickListener() {
         @Override
         public void onClick(View v) {
            String n  = ed1.getText().toString();
            String ph  = ed2.getText().toString();
            String e  = ed3.getText().toString();

            SharedPreferences.Editor editor = sharedpreferences.edit();

            editor.putString(Name, n);
            editor.putString(Phone, ph);
            editor.putString(Email, e);
            editor.commit();
            Toast.makeText(MainActivity.this,"Thanks",Toast.LENGTH_LONG).show();
         }
      });
   }

}

बचाना

PreferenceManager.getDefaultSharedPreferences(this).edit().putString("VarName","your value").apply();

पीछे हटने के लिए:

String name = PreferenceManager.getDefaultSharedPreferences(this).getString("VarName","defaultValue");

डिफ़ॉल्ट मान है: यदि यह वरीयता मौजूद नहीं है तो वापस लौटने के मान।

आप कुछ मामलों में getActivity () या getAplicationContext () के साथ " यह " बदल सकते हैं


सबसे अच्छा अभ्यास कभी

वरीयता प्रबंधक के साथ नामित इंटरफ़ेस बनाएं:

// Interface to save values in shared preferences and also for retrieve values from shared preferences
public interface PreferenceManager {

    SharedPreferences getPreferences();
    Editor editPreferences();

    void setString(String key, String value);
    String getString(String key);

    void setBoolean(String key, boolean value);
    boolean getBoolean(String key);

    void setInteger(String key, int value);
    int getInteger(String key);

    void setFloat(String key, float value);
    float getFloat(String key);

}

गतिविधि / टुकड़े के साथ कैसे उपयोग करें:

public class HomeActivity extends AppCompatActivity implements PreferenceManager{

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout_activity_home);
    }

    @Override
    public SharedPreferences getPreferences(){
        return getSharedPreferences("SP_TITLE", Context.MODE_PRIVATE);
    }

    @Override
    public SharedPreferences.Editor editPreferences(){
        return getPreferences().edit();
    }

    @Override
    public void setString(String key, String value) {
        editPreferences().putString(key, value).commit();
    }

    @Override
    public String getString(String key) {
        return getPreferences().getString(key, "");
    }

    @Override
    public void setBoolean(String key, boolean value) {
        editPreferences().putBoolean(key, value).commit();
    }

    @Override
    public boolean getBoolean(String key) {
        return  getPreferences().getBoolean(key, false);
    }

    @Override
    public void setInteger(String key, int value) {
        editPreferences().putInt(key, value).commit();
    }

    @Override
    public int getInteger(String key) {
        return getPreferences().getInt(key, 0);
    }

    @Override
    public void setFloat(String key, float value) {
        editPreferences().putFloat(key, value).commit();
    }

    @Override
    public float getFloat(String key) {
        return getPreferences().getFloat(key, 0);
    }
}

नोट: SP_TITLE के साथ साझा Preference की अपनी कुंजी बदलें।

उदाहरण:

शेयरपेरेंस में स्टोर स्ट्रिंग :

setString("my_key", "my_value");

शेयरपेरेंस से स्ट्रिंग प्राप्त करें :

String strValue = getString("my_key");

आशा है कि यह आपकी मदद करेगा।


साझा संदर्भों में स्टोर करें

SharedPreferences preferences = getSharedPreferences("temp", getApplicationContext().MODE_PRIVATE);
Editor editor = preferences.edit();
editor.putString("name", name);
editor.commit();

साझा किए गए संदर्भों में प्राप्त करें

SharedPreferences preferences=getSharedPreferences("temp", getApplicationContext().MODE_PRIVATE);
String name=preferences.getString("name",null);

नोट: "temp" साझा संदर्भ नाम है और "नाम" इनपुट मान है। अगर मूल्य बाहर नहीं निकलता है तो शून्य वापस आ जाता है


I have created a Helper class to make my Life easy. This is a generic class and has a-lot of methods those are commonly used in Apps like Shared Preferences, Email Validity, Date Time Format. Copy this class in your code and access it's methods wherever you need.

 import android.app.AlertDialog;
 import android.app.ProgressDialog;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.SharedPreferences;
 import android.support.v4.app.FragmentActivity;
 import android.view.inputmethod.InputMethodManager;
 import android.widget.EditText;
 import android.widget.Toast;

 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Random;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;

/**
* Created by Zohaib Hassan on 3/4/2016.
*/
 public class Helper {

private static ProgressDialog pd;

public static void saveData(String key, String value, Context context) {
    SharedPreferences sp = context.getApplicationContext()
            .getSharedPreferences("appData", 0);
    SharedPreferences.Editor editor;
    editor = sp.edit();
    editor.putString(key, value);
    editor.commit();
}

public static void deleteData(String key, Context context){
    SharedPreferences sp = context.getApplicationContext()
            .getSharedPreferences("appData", 0);
    SharedPreferences.Editor editor;
    editor = sp.edit();
    editor.remove(key);
    editor.commit();

}

public static String getSaveData(String key, Context context) {
    SharedPreferences sp = context.getApplicationContext()
            .getSharedPreferences("appData", 0);
    String data = sp.getString(key, "");
    return data;

}




public static long dateToUnix(String dt, String format) {
    SimpleDateFormat formatter;
    Date date = null;
    long unixtime;
    formatter = new SimpleDateFormat(format);
    try {
        date = formatter.parse(dt);
    } catch (Exception ex) {

        ex.printStackTrace();
    }
    unixtime = date.getTime();
    return unixtime;

}

public static String getData(long unixTime, String formate) {

    long unixSeconds = unixTime;
    Date date = new Date(unixSeconds);
    SimpleDateFormat sdf = new SimpleDateFormat(formate);
    String formattedDate = sdf.format(date);
    return formattedDate;
}

public static String getFormattedDate(String date, String currentFormat,
                                      String desiredFormat) {
    return getData(dateToUnix(date, currentFormat), desiredFormat);
}




public static double distance(double lat1, double lon1, double lat2,
                              double lon2, char unit) {
    double theta = lon1 - lon2;
    double dist = Math.sin(deg2rad(lat1)) * Math.sin(deg2rad(lat2))
            + Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2))
            * Math.cos(deg2rad(theta));
    dist = Math.acos(dist);
    dist = rad2deg(dist);
    dist = dist * 60 * 1.1515;
    if (unit == 'K') {
        dist = dist * 1.609344;
    } else if (unit == 'N') {
        dist = dist * 0.8684;
    }
    return (dist);
}

/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
/* :: This function converts decimal degrees to radians : */
/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
private static double deg2rad(double deg) {
    return (deg * Math.PI / 180.0);
}

/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
/* :: This function converts radians to decimal degrees : */
/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
private static double rad2deg(double rad) {
    return (rad * 180.0 / Math.PI);
}

public static int getRendNumber() {
    Random r = new Random();
    return r.nextInt(360);
}

public static void hideKeyboard(Context context, EditText editText) {
    InputMethodManager imm = (InputMethodManager) context
            .getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
}

public static void showLoder(Context context, String message) {
    pd = new ProgressDialog(context);

    pd.setCancelable(false);
    pd.setMessage(message);
    pd.show();
}

public static void showLoderImage(Context context, String message) {
    pd = new ProgressDialog(context);
    pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
    pd.setCancelable(false);
    pd.setMessage(message);
    pd.show();
}

public static void dismissLoder() {
    pd.dismiss();
}

public static void toast(Context context, String text) {

    Toast.makeText(context, text, Toast.LENGTH_LONG).show();
}
/*
     public static Boolean connection(Context context) {
    ConnectionDetector connection = new ConnectionDetector(context);
    if (!connection.isConnectingToInternet()) {

        Helper.showAlert(context, "No Internet access...!");
        //Helper.toast(context, "No internet access..!");
        return false;
    } else
        return true;
}*/

public static void removeMapFrgment(FragmentActivity fa, int id) {

    android.support.v4.app.Fragment fragment;
    android.support.v4.app.FragmentManager fm;
    android.support.v4.app.FragmentTransaction ft;
    fm = fa.getSupportFragmentManager();
    fragment = fm.findFragmentById(id);
    ft = fa.getSupportFragmentManager().beginTransaction();
    ft.remove(fragment);
    ft.commit();

}

public static AlertDialog showDialog(Context context, String message) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setMessage(message);

    builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int id) {
            // TODO Auto-generated method stub

        }
    });

    return builder.create();
}

public static void showAlert(Context context, String message) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setTitle("Alert");
    builder.setMessage(message)
            .setPositiveButton("Ok", new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int id) {
                    dialog.dismiss();
                }
            }).show();
}

public static boolean isURL(String url) {
    if (url == null)
        return false;

    boolean foundMatch = false;
    try {
        Pattern regex = Pattern
                .compile(
                        "\\b(?:(https?|ftp|file)://|www\\.)?[-A-Z0-9+&#/%?=~_|$!:,.;]*[A-Z0-9+&@#/%=~_|$]\\.[-A-Z0-9+&@#/%?=~_|$!:,.;]*[A-Z0-9+&@#/%=~_|$]",
                        Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
        Matcher regexMatcher = regex.matcher(url);
        foundMatch = regexMatcher.matches();
        return foundMatch;
    } catch (PatternSyntaxException ex) {
        // Syntax error in the regular expression
        return false;
    }
}

public static boolean atLeastOneChr(String string) {
    if (string == null)
        return false;

    boolean foundMatch = false;
    try {
        Pattern regex = Pattern.compile("[a-zA-Z0-9]",
                Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
        Matcher regexMatcher = regex.matcher(string);
        foundMatch = regexMatcher.matches();
        return foundMatch;
    } catch (PatternSyntaxException ex) {
        // Syntax error in the regular expression
        return false;
    }
}

public static boolean isValidEmail(String email, Context context) {
    String expression = "^[\\w\\.-][email protected]([\\w\\-]+\\.)+[A-Z]{2,4}$";
    CharSequence inputStr = email;
    Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(inputStr);
    if (matcher.matches()) {
        return true;
    } else {
        // Helper.toast(context, "Email is not valid..!");

        return false;
    }
}

public static boolean isValidUserName(String email, Context context) {
    String expression = "^[0-9a-zA-Z]+$";
    CharSequence inputStr = email;
    Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(inputStr);
    if (matcher.matches()) {
        return true;
    } else {
        Helper.toast(context, "Username is not valid..!");
        return false;
    }
}

public static boolean isValidDateSlash(String inDate) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd/mm/yyyy");
    dateFormat.setLenient(false);
    try {
        dateFormat.parse(inDate.trim());
    } catch (ParseException pe) {
        return false;
    }
    return true;
}

public static boolean isValidDateDash(String inDate) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd-mm-yyyy");
    dateFormat.setLenient(false);
    try {
        dateFormat.parse(inDate.trim());
    } catch (ParseException pe) {
        return false;
    }
    return true;
}

public static boolean isValidDateDot(String inDate) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd.mm.yyyy");
    dateFormat.setLenient(false);
    try {
        dateFormat.parse(inDate.trim());
    } catch (ParseException pe) {
        return false;
    }
    return true;
}

}

To store and retrieve global variables in a function way. To test, make sure you have Textview items on your page, uncomment the two lines in the code and run. Then comment the two lines again, and run.
Here the id of the TextView is username and password.

In every Class where you want to use it, add these two routines at the end. I would like this routine to be global routines, but do not know how. This works.

The variabels are available everywhere. It stores the variables in "MyFile". You may change it your way.

You call it using

 storeSession("username","frans");
 storeSession("password","!2#4%");***

the variable username will be filled with "frans" and the password with "!2#4%". Even after a restart they are available.

and you retrieve it using

 password.setText(getSession(("password")));
 usernames.setText(getSession(("username")));

below the entire code of my grid.java

    package nl.yentel.yenteldb2;
    import android.content.SharedPreferences;
    import android.os.Bundle;
    import android.support.design.widget.FloatingActionButton;
    import android.support.design.widget.Snackbar;
    import android.support.v7.app.AppCompatActivity;
    import android.support.v7.widget.Toolbar;
    import android.view.View;
    import android.widget.EditText;
    import android.widget.TextView;

    public class Grid extends AppCompatActivity {
    private TextView usernames;
    private TextView password;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_grid);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
        fab.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                        .setAction("Action", null).show();
            }
        });
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);

      ***//  storeSession("username","[email protected]");
        //storeSession("password","mijn wachtwoord");***
        password = (TextView) findViewById(R.id.password);
        password.setText(getSession(("password")));
        usernames=(TextView) findViewById(R.id.username);
        usernames.setText(getSession(("username")));
    }

    public void storeSession(String key, String waarde) { 
        SharedPreferences pref = getApplicationContext().getSharedPreferences("MyFile", MODE_PRIVATE);
        SharedPreferences.Editor editor = pref.edit();
        editor.putString(key, waarde);
        editor.commit();
    }

    public String getSession(String key) {
//http://androidexample.com/Android_SharedPreferences_Basics/index.php?view=article_discription&aid=126&aaid=146
        SharedPreferences pref = getApplicationContext().getSharedPreferences("MyFile", MODE_PRIVATE);
        SharedPreferences.Editor editor = pref.edit();
        String output = pref.getString(key, null);
        return output;
    }

    }

below you find the textview items

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="usernames"
    android:id="@+id/username"
    android:layout_below="@+id/textView"
    android:layout_alignParentStart="true"
    android:layout_marginTop="39dp"
    android:hint="hier komt de username" />

 <TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="password"
    android:id="@+id/password"
    android:layout_below="@+id/user"
    android:layout_alignParentStart="true"
    android:hint="hier komt het wachtwoord" />

साझा वरीयताओं में मूल्यों को स्टोर करने के लिए:

SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferences.Editor editor = sp.edit();
editor.putString("Name","Jayesh");
editor.commit();

साझा वरीयताओं से मूल्यों को पुनर्प्राप्त करने के लिए:

SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
String name = sp.getString("Name", "");

SharedPreferences.Editor editor = getSharedPreferences("identifier", 
MODE_PRIVATE).edit();
//identifier is the unique to fetch data from your SharedPreference.


editor.putInt("keyword", 0); 
// saved value place with 0.
//use this "keyword" to fetch saved value again.
editor.commit();//important line without this line your value is not stored in preference   

// fetch the stored data using ....

SharedPreferences prefs = getSharedPreferences("identifier", MODE_PRIVATE); 
// here both identifier will same

int fetchvalue = prefs.getInt("keyword", 0);
// here keyword will same as used above.
// 0 is default value when you nothing save in preference that time fetch value is 0.

आपको एडाप्टर क्लास या किसी अन्य में साझा किए गए संदर्भों का उपयोग करने की आवश्यकता है। उस समय बस इस घोषणा का उपयोग करें और उपरोक्त एक ही गधे का उपयोग करें।

SharedPreferences.Editor editor = context.getSharedPreferences("idetifier", 
Context.MODE_PRIVATE).edit();
SharedPreferences prefs = context.getSharedPreferences("identifier", Context.MODE_PRIVATE);

//here context is your application context

स्ट्रिंग या बुलियन मूल्य के लिए

editor.putString("stringkeyword", "your string"); 
editor.putBoolean("booleankeyword","your boolean value");
editor.commit();

उपरोक्त के रूप में डेटा लाने के लिए

String fetchvalue = prefs.getString("keyword", "");
Boolean fetchvalue = prefs.getBoolean("keyword", "");




sharedpreferences