如何在SharedPreferences中保存/存储对象?

小开

如果你的对象很复杂，我建议序列化/XML/JSON，并将这些内容保存到SD卡。你可以在这里找到关于如何保存到外部存储的其他信息: http://developer.android.com/guide/topics/data/data-storage.html#filesExternal

小开

更好的方法是创建一个全局Constants类来保存获取或保存数据的键或变量。

要保存数据，请调用此方法保存来自任何地方的数据。

public static void saveData(Context con, String variable, String data)
{
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(con);
prefs.edit().putString(variable, data).commit();
}

用它来获取数据。

public static String getData(Context con, String variable, String defaultValue)
{
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(con);
String data = prefs.getString(variable, defaultValue);
return data;
}

像这样的方法就可以了

public static User getUserInfo(Context con)
{
String id =  getData(con, Constants.USER_ID, null);
String name =  getData(con, Constants.USER_NAME, null);
if(id != null && name != null)
{
User user = new User(); //Hope you will have a user Object.
user.setId(id);
user.setName(name);
//Here set other credentials.
return user;
}
else
return null;
}

小开

你还没有声明在此之后对prefsEditor对象做什么，但为了持久化首选项数据，你还需要使用:

prefsEditor.commit();

小开

最佳答案

你可以使用gson.jar将类对象存储到SharedPreferences中。你可以从google-gson

下载这个jar

或者在Gradle文件中添加GSON依赖项:

implementation 'com.google.code.gson:gson:2.8.8'

你可以找到最新版本在这里

创建共享首选项:

SharedPreferences  mPrefs = getPreferences(MODE_PRIVATE);

保存:

MyObject myObject = new MyObject;
//set variables of 'myObject', etc.


Editor prefsEditor = mPrefs.edit();
Gson gson = new Gson();
String json = gson.toJson(myObject);
prefsEditor.putString("MyObject", json);
prefsEditor.commit();

检索:

Gson gson = new Gson();
String json = mPrefs.getString("MyObject", "");
MyObject obj = gson.fromJson(json, MyObject.class);

小开

要添加到@MuhammadAamirALi的答案，您可以使用Gson保存和检索对象列表

保存用户定义对象的列表到SharedPreferences

public static final String KEY_CONNECTIONS = "KEY_CONNECTIONS";
SharedPreferences.Editor editor = getPreferences(MODE_PRIVATE).edit();


User entity = new User();
// ... set entity fields


List<Connection> connections = entity.getConnections();
// convert java object to JSON format,
// and returned as JSON formatted string
String connectionsJSONString = new Gson().toJson(connections);
editor.putString(KEY_CONNECTIONS, connectionsJSONString);
editor.commit();

从SharedPreferences获取用户定义对象的列表

String connectionsJSONString = getPreferences(MODE_PRIVATE).getString(KEY_CONNECTIONS, null);
Type type = new TypeToken < List < Connection >> () {}.getType();
List < Connection > connections = new Gson().fromJson(connectionsJSONString, type);

小开

看这里，这可以帮助你:

public static boolean setObject(Context context, Object o) {
Field[] fields = o.getClass().getFields();
SharedPreferences sp = context.getSharedPreferences(o.getClass()
.getName(), Context.MODE_PRIVATE);
Editor editor = sp.edit();
for (int i = 0; i < fields.length; i++) {
Class<?> type = fields[i].getType();
if (isSingle(type)) {
try {
final String name = fields[i].getName();
if (type == Character.TYPE || type.equals(String.class)) {
Object value = fields[i].get(o);
if (null != value)
editor.putString(name, value.toString());
} else if (type.equals(int.class)
|| type.equals(Short.class))
editor.putInt(name, fields[i].getInt(o));
else if (type.equals(double.class))
editor.putFloat(name, (float) fields[i].getDouble(o));
else if (type.equals(float.class))
editor.putFloat(name, fields[i].getFloat(o));
else if (type.equals(long.class))
editor.putLong(name, fields[i].getLong(o));
else if (type.equals(Boolean.class))
editor.putBoolean(name, fields[i].getBoolean(o));


} catch (IllegalAccessException e) {
LogUtils.e(TAG, e);
} catch (IllegalArgumentException e) {
LogUtils.e(TAG, e);
}
} else {
// FIXME 是对象则不写入
}
}


return editor.commit();
}

https://github.com/AltasT/PreferenceVObjectFile/blob/master/PreferenceVObjectFile/src/com/altas/lib/PreferenceUtils.java

小开

试试这个最好的方法:

PreferenceConnector.java

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


public class PreferenceConnector {
public static final String PREF_NAME = "ENUMERATOR_PREFERENCES";
public static final String PREF_NAME_REMEMBER = "ENUMERATOR_REMEMBER";
public static final int MODE = Context.MODE_PRIVATE;




public static final String name = "name";




public static void writeBoolean(Context context, String key, boolean value) {
getEditor(context).putBoolean(key, value).commit();
}


public static boolean readBoolean(Context context, String key,
boolean defValue) {
return getPreferences(context).getBoolean(key, defValue);
}


public static void writeInteger(Context context, String key, int value) {
getEditor(context).putInt(key, value).commit();


}


public static int readInteger(Context context, String key, int defValue) {
return getPreferences(context).getInt(key, defValue);
}


public static void writeString(Context context, String key, String value) {
getEditor(context).putString(key, value).commit();


}


public static String readString(Context context, String key, String defValue) {
return getPreferences(context).getString(key, defValue);
}


public static void writeLong(Context context, String key, long value) {
getEditor(context).putLong(key, value).commit();
}


public static long readLong(Context context, String key, long defValue) {
return getPreferences(context).getLong(key, defValue);
}


public static SharedPreferences getPreferences(Context context) {
return context.getSharedPreferences(PREF_NAME, MODE);
}


public static Editor getEditor(Context context) {
return getPreferences(context).edit();
}


}

写入值:

PreferenceConnector.writeString(this, PreferenceConnector.name,"Girish");

并获得价值使用:

String name= PreferenceConnector.readString(this, PreferenceConnector.name, "");

小开

我知道这个线程有点旧。但我还是要把这个贴出来，希望它能帮助到一些人。我们可以将任何对象的字段存储到共享首选项通过序列化，对象为String。这里我使用GSON来存储共享首选项的任何对象

保存对象到首选项:

public static void saveObjectToSharedPreference(Context context, String preferenceFileName, String serializedObjectKey, Object object) {
SharedPreferences sharedPreferences = context.getSharedPreferences(preferenceFileName, 0);
SharedPreferences.Editor sharedPreferencesEditor = sharedPreferences.edit();
final Gson gson = new Gson();
String serializedObject = gson.toJson(object);
sharedPreferencesEditor.putString(serializedObjectKey, serializedObject);
sharedPreferencesEditor.apply();
}

从首选项检索对象:

public static <GenericClass> GenericClass getSavedObjectFromPreference(Context context, String preferenceFileName, String preferenceKey, Class<GenericClass> classType) {
SharedPreferences sharedPreferences = context.getSharedPreferences(preferenceFileName, 0);
if (sharedPreferences.contains(preferenceKey)) {
final Gson gson = new Gson();
return gson.fromJson(sharedPreferences.getString(preferenceKey, ""), classType);
}
return null;
}

注意:

记得在gradle中添加compile 'com.google.code.gson:gson:2.6.2'到dependencies。

例子:

//assume SampleClass exists
SampleClass mObject = new SampleObject();


//to store an object
saveObjectToSharedPreference(context, "mPreference", "mObjectKey", mObject);


//to retrive object stored in preference
mObject = getSavedObjectFromPreference(context, "mPreference", "mObjectKey", SampleClass.class);

更新:

正如@Sharp_Edge在评论中指出的那样，上述解决方案不适用于List。

对签名getSavedObjectFromPreference() -从Class<GenericClass> classType到Type classType稍加修改，就可以使这个解决方案一般化。修改后的函数签名

public static <GenericClass> GenericClass getSavedObjectFromPreference(Context context, String preferenceFileName, String preferenceKey, Type classType)

用于调用,

getSavedObjectFromPreference(context, "mPreference", "mObjectKey", (Type) SampleClass.class)

快乐 编码!

小开

另一种不使用Json格式保存和恢复android sharedpreferences对象的方法

private static ExampleObject getObject(Context c,String db_name){
SharedPreferences sharedPreferences = c.getSharedPreferences(db_name, Context.MODE_PRIVATE);
ExampleObject o = new ExampleObject();
Field[] fields = o.getClass().getFields();
try {
for (Field field : fields) {
Class<?> type = field.getType();
try {
final String name = field.getName();
if (type == Character.TYPE || type.equals(String.class)) {
field.set(o,sharedPreferences.getString(name, ""));
} else if (type.equals(int.class) || type.equals(Short.class))
field.setInt(o,sharedPreferences.getInt(name, 0));
else if (type.equals(double.class))
field.setDouble(o,sharedPreferences.getFloat(name, 0));
else if (type.equals(float.class))
field.setFloat(o,sharedPreferences.getFloat(name, 0));
else if (type.equals(long.class))
field.setLong(o,sharedPreferences.getLong(name, 0));
else if (type.equals(Boolean.class))
field.setBoolean(o,sharedPreferences.getBoolean(name, false));
else if (type.equals(UUID.class))
field.set(
o,
UUID.fromString(
sharedPreferences.getString(
name,
UUID.nameUUIDFromBytes("".getBytes()).toString()
)
)
);


} catch (IllegalAccessException e) {
Log.e(StaticConfig.app_name, "IllegalAccessException", e);
} catch (IllegalArgumentException e) {
Log.e(StaticConfig.app_name, "IllegalArgumentException", e);
}
}
} catch (Exception e) {
System.out.println("Exception: " + e);
}
return o;
}
private static void setObject(Context context, Object o, String db_name) {
Field[] fields = o.getClass().getFields();
SharedPreferences sp = context.getSharedPreferences(db_name, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
for (Field field : fields) {
Class<?> type = field.getType();
try {
final String name = field.getName();
if (type == Character.TYPE || type.equals(String.class)) {
Object value = field.get(o);
if (value != null)
editor.putString(name, value.toString());
} else if (type.equals(int.class) || type.equals(Short.class))
editor.putInt(name, field.getInt(o));
else if (type.equals(double.class))
editor.putFloat(name, (float) field.getDouble(o));
else if (type.equals(float.class))
editor.putFloat(name, field.getFloat(o));
else if (type.equals(long.class))
editor.putLong(name, field.getLong(o));
else if (type.equals(Boolean.class))
editor.putBoolean(name, field.getBoolean(o));
else if (type.equals(UUID.class))
editor.putString(name, field.get(o).toString());


} catch (IllegalAccessException e) {
Log.e(StaticConfig.app_name, "IllegalAccessException", e);
} catch (IllegalArgumentException e) {
Log.e(StaticConfig.app_name, "IllegalArgumentException", e);
}
}


editor.apply();
}

小开

如果你想存储你从响应中得到的整个对象，它可以通过这样做来实现，

首先，在util类中创建一个将JSON转换为字符串的方法，如下所示。

 public static <T> T fromJson(String jsonString, Class<T> theClass) {
return new Gson().fromJson(jsonString, theClass);
}

然后在共享偏好类中执行如下操作，

 public void storeLoginResponse(yourResponseClass objName) {


String loginJSON = UtilClass.toJson(customer);
if (!TextUtils.isEmpty(customerJSON)) {
editor.putString(AppConst.PREF_CUSTOMER, customerJSON);
editor.commit();
}
}

然后为getPreferences创建一个方法

public Customer getCustomerDetails() {
String customerDetail = pref.getString(AppConst.PREF_CUSTOMER, null);
if (!TextUtils.isEmpty(customerDetail)) {
return GSONConverter.fromJson(customerDetail, Customer.class);
} else {
return new Customer();
}
}

当你得到响应时，只调用第一个方法其次，当你需要从

这样的共享偏好中获取数据时

String token = SharedPrefHelper.get().getCustomerDetails().getAccessToken();

这是所有。

希望对你有所帮助。

Happy Coding();

小开

你可以保存对象在首选项不使用任何库，首先你的对象类必须实现Serializable:

public class callModel implements Serializable {


private long pointTime;
private boolean callisConnected;


public callModel(boolean callisConnected,  long pointTime) {
this.callisConnected = callisConnected;
this.pointTime = pointTime;
}
public boolean isCallisConnected() {
return callisConnected;
}
public long getPointTime() {
return pointTime;
}

｝

然后你可以很容易地使用这两个方法来转换对象到字符串和字符串到对象:

 public static <T extends Serializable> T stringToObjectS(String string) {
byte[] bytes = Base64.decode(string, 0);
T object = null;
try {
ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(bytes));
object = (T) objectInputStream.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return object;
}


public static String objectToString(Parcelable object) {
String encoded = null;
try {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(object);
objectOutputStream.close();
encoded = new String(Base64.encodeToString(byteArrayOutputStream.toByteArray(), 0));
} catch (IOException e) {
e.printStackTrace();
}
return encoded;
}

保存:

SharedPreferences  mPrefs = getPreferences(MODE_PRIVATE);
Editor prefsEditor = mPrefs.edit();
prefsEditor.putString("MyObject", objectToString(callModelObject));
prefsEditor.commit();

阅读

String value= mPrefs.getString("MyObject", "");
MyObject obj = stringToObjectS(value);

小开

在你的java文件中复制粘贴这两个函数。

 public void setDefaults(String key, String value, Context context) {
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
SharedPreferences.Editor editor = preferences.edit();
editor.putString(key, value);
editor.commit();
}




public static String getDefaults(String key, Context context) {
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
return preferences.getString(key, null);
}

<强>步骤2: 要节省使用:

 setDefaults("key","value",this);

检索使用:

String retrieve= getDefaults("key",this);

你可以通过使用不同的键名来设置不同的共享首选项，比如:

setDefaults("key1","xyz",this);


setDefaults("key2","abc",this);


setDefaults("key3","pqr",this);

小开

有两个文件解决了你所有关于sharedpreferences的问题

 1) AppPersistence.java 

    public class AppPersistence {
public enum keys {
USER_NAME, USER_ID, USER_NUMBER, USER_EMAIL, USER_ADDRESS, CITY, USER_IMAGE,
DOB, MRG_Anniversary, COMPANY, USER_TYPE, support_phone
}


private static AppPersistence mAppPersistance;
private SharedPreferences sharedPreferences;


public static AppPersistence start(Context context) {
if (mAppPersistance == null) {
mAppPersistance = new AppPersistence(context);
}
return mAppPersistance;
}


private AppPersistence(Context context) {
sharedPreferences = context.getSharedPreferences(context.getString(R.string.prefrence_file_name),
Context.MODE_PRIVATE);
}


public Object get(Enum key) {
Map<String, ?> all = sharedPreferences.getAll();
return all.get(key.toString());
}


void save(Enum key, Object val) {
SharedPreferences.Editor editor = sharedPreferences.edit();
if (val instanceof Integer) {
editor.putInt(key.toString(), (Integer) val);
} else if (val instanceof String) {
editor.putString(key.toString(), String.valueOf(val));
} else if (val instanceof Float) {
editor.putFloat(key.toString(), (Float) val);
} else if (val instanceof Long) {
editor.putLong(key.toString(), (Long) val);
} else if (val instanceof Boolean) {
editor.putBoolean(key.toString(), (Boolean) val);
}
editor.apply();
}


void remove(Enum key) {
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.remove(key.toString());
editor.apply();
}


public void removeAll() {
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.clear();
editor.apply();
}
}

 2) AppPreference.java 

public static void setPreference(Context context, Enum Name, String Value) {
AppPersistence.start(context).save(Name, Value);
}


public static String getPreference(Context context, Enum Name) {
return (String) AppPersistence.start(context).get(Name);
}


public static void removePreference(Context context, Enum Name) {
AppPersistence.start(context).remove(Name);
}
}

现在你可以保存，删除或者获取，

保存

AppPreference.setPreference(context, AppPersistence.keys.USER_ID, userID);

删除

AppPreference.removePreference(context, AppPersistence.keys.USER_ID);

在闲暇

 AppPreference.getPreference(context, AppPersistence.keys.USER_ID);

小开

将数据存储在SharedPreference中

SharedPreferences mprefs = getSharedPreferences(AppConstant.PREFS_NAME, MODE_PRIVATE)
mprefs.edit().putString(AppConstant.USER_ID, resUserID).apply();

小开

我的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 putObject(String key, T value) {
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putString(key, gson.toJson(value));
editor.apply();
}


public <T> T getObject(String key, Class<T> clazz) {
return gson.fromJson(getString(key, null), clazz);
}
}

使用

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


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

。 我的utils的完整代码 //在活动代码中使用示例检查

小开

// SharedPrefHelper is a class contains the get and save sharedPrefernce data
public class SharedPrefHelper {


// save data in sharedPrefences
public static void setSharedOBJECT(Context context, String key,
Object value) {


SharedPreferences sharedPreferences =  context.getSharedPreferences(
context.getPackageName(), Context.MODE_PRIVATE);


SharedPreferences.Editor prefsEditor = sharedPreferences.edit();
Gson gson = new Gson();
String json = gson.toJson(value);
prefsEditor.putString(key, json);
prefsEditor.apply();
}


// get data from sharedPrefences
public static Object getSharedOBJECT(Context context, String key) {


SharedPreferences sharedPreferences = context.getSharedPreferences(
context.getPackageName(), Context.MODE_PRIVATE);


Gson gson = new Gson();
String json = sharedPreferences.getString(key, "");
Object obj = gson.fromJson(json, Object.class);
User objData = new Gson().fromJson(obj.toString(), User.class);
return objData;
}
}

// save data in your activity


User user = new User("Hussein","h@h.com","3107310890983");
SharedPrefHelper.setSharedOBJECT(this,"your_key",user);
User data = (User) SharedPrefHelper.getSharedOBJECT(this,"your_key");


Toast.makeText(this,data.getName()+"\n"+data.getEmail()+"\n"+data.getPhone(),Toast.LENGTH_LONG).show();

// User is the class you want to save its objects


public class User {


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public String getEmail() {
return email;
}


public void setEmail(String email) {
this.email = email;
}


public String getPhone() {
return phone;
}


public void setPhone(String phone) {
this.phone = phone;
}


private String name,email,phone;
public User(String name,String email,String phone){
this.name=name;
this.email=email;
this.phone=phone;
}
}

// put this in gradle


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

希望这对你有所帮助:)

小开

我在使用已接受的答案访问跨活动的共享首选项数据时遇到了麻烦。在这些步骤中，您将为getSharedPreferences提供一个名称以访问它。

在构建中添加以下依赖项。Gradle脚本下的gradel (Module: app)文件:

implementation 'com.google.code.gson:gson:2.8.5'

保存:

MyObject myObject = new MyObject;
//set variables of 'myObject', etc.


SharedPreferences mPrefs = getSharedPreferences("Name", Context.MODE_PRIVATE);


Editor prefsEditor = mPrefs.edit();
Gson gson = new Gson();
String json = gson.toJson(myObject);
prefsEditor.putString("Key", json);
prefsEditor.commit();

在不同的活动中检索:

SharedPreferences mPrefs = getSharedPreferences("Name", Context.MODE_PRIVATE);


Gson gson = new Gson();
String json = mPrefs.getString("Key", "");
MyObject obj = gson.fromJson(json, MyObject.class);

小开

我已经使用jackson来存储我的对象(杰克逊)。

添加杰克逊库到gradle:

api 'com.fasterxml.jackson.core:jackson-core:2.9.4'
api 'com.fasterxml.jackson.core:jackson-annotations:2.9.4'
api 'com.fasterxml.jackson.core:jackson-databind:2.9.4'

我的测试类:

public class Car {
private String color;
private String type;
// standard getters setters
}

Java对象转换为JSON:

ObjectMapper objectMapper = new ObjectMapper();
String carAsString = objectMapper.writeValueAsString(car);

存储在共享首选项中:

preferences.edit().car().put(carAsString).apply();

从共享首选项中恢复:

ObjectMapper objectMapper = new ObjectMapper();
Car car = objectMapper.readValue(preferences.car().get(), Car.class);

小开

下面是我从在这里中获得的Kotlin委托属性的使用，但扩展并允许一个简单的机制来获取/设置SharedPreference属性。

对于String， Int， Long， Float或Boolean，它使用标准的SharePreference getter和setter。然而，对于所有其他数据类，它使用GSON序列化为String，用于setter。然后为getter反序列化为数据对象。

与其他解决方案类似，这需要在gradle文件中添加GSON作为依赖项:

implementation 'com.google.code.gson:gson:2.8.6'

下面是一个简单的数据类的例子，我们希望能够保存并存储到SharedPreferences:

data class User(val first: String, val last: String)

下面是一个实现属性委托的类:

object UserPreferenceProperty : PreferenceProperty<User>(
key = "USER_OBJECT",
defaultValue = User(first = "Jane", last = "Doe"),
clazz = User::class.java)


object NullableUserPreferenceProperty : NullablePreferenceProperty<User?, User>(
key = "NULLABLE_USER_OBJECT",
defaultValue = null,
clazz = User::class.java)


object FirstTimeUser : PreferenceProperty<Boolean>(
key = "FIRST_TIME_USER",
defaultValue = false,
clazz = Boolean::class.java
)


sealed class PreferenceProperty<T : Any>(key: String,
defaultValue: T,
clazz: Class<T>) : NullablePreferenceProperty<T, T>(key, defaultValue, clazz)


@Suppress("UNCHECKED_CAST")
sealed class NullablePreferenceProperty<T : Any?, U : Any>(private val key: String,
private val defaultValue: T,
private val clazz: Class<U>) : ReadWriteProperty<Any, T> {


override fun getValue(thisRef: Any, property: KProperty<*>): T = HandstandApplication.appContext().getPreferences()
.run {
when {
clazz.isAssignableFrom(String::class.java) -> getString(key, defaultValue as String?) as T
clazz.isAssignableFrom(Int::class.java) -> getInt(key, defaultValue as Int) as T
clazz.isAssignableFrom(Long::class.java) -> getLong(key, defaultValue as Long) as T
clazz.isAssignableFrom(Float::class.java) -> getFloat(key, defaultValue as Float) as T
clazz.isAssignableFrom(Boolean::class.java) -> getBoolean(key, defaultValue as Boolean) as T
else -> getObject(key, defaultValue, clazz)
}
}


override fun setValue(thisRef: Any, property: KProperty<*>, value: T) = HandstandApplication.appContext().getPreferences()
.edit()
.apply {
when {
clazz.isAssignableFrom(String::class.java) -> putString(key, value as String?) as T
clazz.isAssignableFrom(Int::class.java) -> putInt(key, value as Int) as T
clazz.isAssignableFrom(Long::class.java) -> putLong(key, value as Long) as T
clazz.isAssignableFrom(Float::class.java) -> putFloat(key, value as Float) as T
clazz.isAssignableFrom(Boolean::class.java) -> putBoolean(key, value as Boolean) as T
else -> putObject(key, value)
}
}
.apply()


private fun Context.getPreferences(): SharedPreferences = getSharedPreferences(APP_PREF_NAME, Context.MODE_PRIVATE)


private fun <T, U> SharedPreferences.getObject(key: String, defValue: T, clazz: Class<U>): T =
Gson().fromJson(getString(key, null), clazz) as T ?: defValue


private fun <T> SharedPreferences.Editor.putObject(key: String, value: T) = putString(key, Gson().toJson(value))


companion object {
private const val APP_PREF_NAME = "APP_PREF"
}
}

注意:你不需要更新sealed class中的任何东西。委托的属性是Object/ singleton UserPreferenceProperty， NullableUserPreferenceProperty和FirstTimeUser。

为了从SharedPreferences中保存/获取一个新的数据对象，现在只需要添加四行就可以了:

object NewPreferenceProperty : PreferenceProperty<String>(
key = "NEW_PROPERTY",
defaultValue = "",
clazz = String::class.java)

最后，你可以通过使用by关键字来读取/写入SharedPreferences的值:

private var user: User by UserPreferenceProperty
private var nullableUser: User? by NullableUserPreferenceProperty
private var isFirstTimeUser: Boolean by


Log.d("TAG", user) // outputs the `defaultValue` for User the first time
user = User(first = "John", last = "Doe") // saves this User to the Shared Preferences
Log.d("TAG", user) // outputs the newly retrieved User (John Doe) from Shared Preferences

小开

使用delegate Kotlin，我们可以轻松地从共享首选项中放置和获取数据。

    inline fun <reified T> Context.sharedPrefs(key: String) = object : ReadWriteProperty<Any?, T> {


val sharedPrefs by lazy { this@sharedPrefs.getSharedPreferences("APP_DATA", Context.MODE_PRIVATE) }
val gson by lazy { Gson() }
var newData: T = (T::class.java).newInstance()


override fun getValue(thisRef: Any?, property: KProperty<*>): T {
return getPrefs()
}


override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
this.newData = value
putPrefs(newData)
}


fun putPrefs(value: T?) {
sharedPrefs.edit {
when (value) {
is Int -> putInt(key, value)
is Boolean -> putBoolean(key, value)
is String -> putString(key, value)
is Long -> putLong(key, value)
is Float -> putFloat(key, value)
is Parcelable -> putString(key, gson.toJson(value))
else          -> throw Throwable("no such type exist to put data")
}
}
}


fun getPrefs(): T {
return when (newData) {
is Int -> sharedPrefs.getInt(key, 0) as T
is Boolean -> sharedPrefs.getBoolean(key, false) as T
is String -> sharedPrefs.getString(key, "") as T ?: "" as T
is Long -> sharedPrefs.getLong(key, 0L) as T
is Float -> sharedPrefs.getFloat(key, 0.0f) as T
is Parcelable -> gson.fromJson(sharedPrefs.getString(key, "") ?: "", T::class.java)
else          -> throw Throwable("no such type exist to put data")
} ?: newData
}


}


//use this delegation in activity and fragment in following way
var ourData by sharedPrefs<String>("otherDatas")

小开

这么多好答案，她是我的2美分

我更喜欢使用内联函数和旧风格的put和get值

object PreferenceHelper {


private const val PREFERENCES_KEY = "MyLocalPreference"


private fun getPreference(context: Context): SharedPreferences {
return context.getSharedPreferences(
PREFERENCES_KEY,
Context.MODE_PRIVATE
)
}


fun setBoolean(appContext: Context, key: String?, value: Boolean?) =
getPreference(appContext).edit().putBoolean(key, value!!).apply()


fun setInteger(appContext: Context, key: String?, value: Int) =
getPreference(appContext).edit().putInt(key, value).apply()


fun setFloat(appContext: Context, key: String?, value: Float) =
getPreference(appContext).edit().putFloat(key, value).apply()


fun setString(appContext: Context, key: String?, value: String?) =
getPreference(appContext).edit().putString(key, value).apply()


// To retrieve values from shared preferences:
fun getBoolean(appContext: Context, key: String?, defaultValue: Boolean?): Boolean =
getPreference(appContext).getBoolean(key, defaultValue!!)


fun getInteger(appContext: Context, key: String?, defaultValue: Int): Int =
getPreference(appContext)
.getInt(key, defaultValue)


fun getString(appContext: Context, key: String?, defaultValue: String?): String? =
getPreference(appContext)
.getString(key, defaultValue)




}

使用

PreferenceHelper.setString(context,"CUSTOMER_NAME", "HITESH")


Toast.makeText(context, "Hello " + PreferenceHelper.getString(context,"CUSTOMER_NAME", "User"), Toast.LENGTH_LONG).show()

小开

您可以使用以下代码存储类对象，并从共享首选项检索任何对象。

将以下依赖项添加到应用gradle中

dependencies {
implementation 'com.google.code.gson:gson:2.8.6'
//Other dependencies of our project
}

在共享pref文件中添加以下代码。

 /**
* Saves object into the Preferences.
*
* @param `object` Object of model class (of type [T]) to save
* @param key Key with which Shared preferences to
**/
fun <T> put(`object`: T, key: String) {
//Convert object to JSON String.
val jsonString = GsonBuilder().create().toJson(`object`)
//Save that String in SharedPreferences
preferences.edit().putString(key, jsonString).apply()
}


/**
* Used to retrieve object from the Preferences.
*
* @param key Shared Preference key with which object was saved.
**/
inline fun <reified T> get(key: String): T? {
//We read JSON String which was saved.
val value = preferences.getString(key, null)
//JSON String was found which means object can be read.
//We convert this JSON String to model object. Parameter "c" (of
//type Class < T >" is used to cast.
return GsonBuilder().create().fromJson(value, T::class.java)
}
}

小开

关于这个问题有很多很好的答案，在Kotlin中使用泛型方法实现穆罕默德·阿米尔·阿里&muhame El-Banna的答案。

为了节省

fun storeObjectInSharedPref(dataObject: Any, prefName: String): Boolean{
val dataObjectInJson = Gson().toJson(dataObject)
prefsEditor.putString(prefName, dataObjectInJson)
return prefsEditor.commit()
}

检索

fun <T> retrieveStoredObject(prefName: String, baseClass: Class<T>): T?{
val dataObject: String? = preferences.getString(prefName, "")
return Gson().fromJson(dataObject, baseClass)
}

学习Kotlin 访问这里中的泛型