Unable to add double SharedPreferences

Question

Acquiring an error, the put double method is undefined for this type of editor sharedPreferences.Eclipse provides one quick add-on for adding to the editor, but when I do this, I still get errors, why can't I put a double.

The code:

@Override protected void onPause() { // TODO Auto-generated method stub super.onPause(); if (TextUtils.isEmpty(editBl.getText().toString())) { numberOfBl = 0; } else { numberOfBl = Integer.parseInt(editBl.getText().toString(); } if (TextUtils.isEmpty(editSt.getText().toString())) { tonOfSt = 0; } else { tonOfSt = Double.parseDouble(editSt.getText().toString()); } SharedPreferences prefs = getSharedPreferences( "SavedTotals", Context.MODE_PRIVATE); SharedPreferences.Editor editor = prefs.edit(); editor.putInt("savedBl", numberOfBl); editor.putDouble("savedSt", tonOfSt); editor.commit(); } 

Answer 1

Those who suggested using putFloat and getFloat, unfortunately, are very mistaken. Bringing the double to the float may result in

• Lost accuracy
• Overflow
• Underflow
• Dead kittens

Those that offer toString and parseString are not mistaken, but this is an inefficient solution.

The right way to handle this is to convert the double to its raw long bits equivalent and keep it long. When you read the value, convert back to double.

Since the two types of data are the same size, you will not lose accuracy, and you will not call the {over, under} stream.

 Editor putDouble(final Editor edit, final String key, final double value) { return edit.putLong(key, Double.doubleToRawLongBits(value)); } double getDouble(final SharedPreferences prefs, final String key, final double defaultValue) { return Double.longBitsToDouble(prefs.getLong(key, Double.doubleToLongBits(defaultValue))); } 

Alternatively, you can record the recipient as:

 double getDouble(final SharedPreferences prefs, final String key, final double defaultValue) { if ( !prefs.contains(key)) return defaultValue; return Double.longBitsToDouble(prefs.getLong(key, 0)); } 

Answer 2

You can always implement SharedPreferences and wrap the android implementation.

 package com.company.sharedpreferences; import android.content.Context; import android.content.SharedPreferences; import java.util.Map; import java.util.Set; public class EnhancedSharedPreferences implements SharedPreferences { public static class NameSpaces { public static String MY_FUN_NAMESPACE = "MyFunNameSpacePrefs"; } public static EnhancedSharedPreferences getPreferences(String prefsName) { return new EnhancedSharedPreferences(SomeSingleton.getInstance().getApplicationContext().getSharedPreferences(prefsName, Context.MODE_PRIVATE)); } private SharedPreferences _sharedPreferences; public EnhancedSharedPreferences(SharedPreferences sharedPreferences) { _sharedPreferences = sharedPreferences; } //region Overrides @Override public Map<String, ?> getAll() { return _sharedPreferences.getAll(); } @Override public String getString(String key, String defValue) { return _sharedPreferences.getString(key, defValue); } @Override public Set<String> getStringSet(String key, Set<String> defValues) { return _sharedPreferences.getStringSet(key, defValues); } @Override public int getInt(String key, int defValue) { return _sharedPreferences.getInt(key, defValue); } @Override public long getLong(String key, long defValue) { return _sharedPreferences.getLong(key, defValue); } @Override public float getFloat(String key, float defValue) { return _sharedPreferences.getFloat(key, defValue); } @Override public boolean getBoolean(String key, boolean defValue) { return _sharedPreferences.getBoolean(key, defValue); } @Override public boolean contains(String key) { return _sharedPreferences.contains(key); } @Override public Editor edit() { return new Editor(_sharedPreferences.edit()); } @Override public void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) { _sharedPreferences.registerOnSharedPreferenceChangeListener(listener); } @Override public void unregisterOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) { _sharedPreferences.unregisterOnSharedPreferenceChangeListener(listener); } //endregion //region Extension public Double getDouble(String key, Double defValue) { return Double.longBitsToDouble(_sharedPreferences.getLong(key, Double.doubleToRawLongBits(defValue))); } //endregion public static class Editor implements SharedPreferences.Editor { private SharedPreferences.Editor _editor; public Editor(SharedPreferences.Editor editor) { _editor = editor; } private Editor ReturnEditor(SharedPreferences.Editor editor) { if(editor instanceof Editor) return (Editor)editor; return new Editor(editor); } //region Overrides @Override public Editor putString(String key, String value) { return ReturnEditor(_editor.putString(key, value)); } @Override public Editor putStringSet(String key, Set<String> values) { return ReturnEditor(_editor.putStringSet(key, values)); } @Override public Editor putInt(String key, int value) { return ReturnEditor(_editor.putInt(key, value)); } @Override public Editor putLong(String key, long value) { return ReturnEditor(_editor.putLong(key, value)); } @Override public Editor putFloat(String key, float value) { return ReturnEditor(_editor.putFloat(key, value)); } @Override public Editor putBoolean(String key, boolean value) { return ReturnEditor(_editor.putBoolean(key, value)); } @Override public Editor remove(String key) { return ReturnEditor(_editor.remove(key)); } @Override public Editor clear() { return ReturnEditor(_editor.clear()); } @Override public boolean commit() { return _editor.commit(); } @Override public void apply() { _editor.apply(); } //endregion //region Extensions public Editor putDouble(String key, double value) { return new Editor(_editor.putLong(key, Double.doubleToRawLongBits(value))); } //endregion } } 

Answer 3

What I did was save the preference as a String:

 getSharedPreferences("PREFERENCE", MODE_PRIVATE).edit().putString("double", "0.01").commit(); 

and then to get double just use Double.parseDouble:

 Double.parseDouble(getSharedPreferences("PREFERENCE", MODE_PRIVATE).getString("double", "0.01")); 

Answer 4

Kotlin extension method (much prettier than using weird utils classes or something else)

 fun SharedPreferences.Editor.putDouble(key: String, double: Double) = putLong(key, java.lang.Double.doubleToRawLongBits(double)) fun SharedPreferences.getDouble(key: String, default: Double) = java.lang.Double.longBitsToDouble(getLong(key, java.lang.Double.doubleToRawLongBits(default))) 

Answer 5

Check this gist https://gist.github.com/john1jan/b8cb536ca51a0b2aa1da4e81566869c4

I created a Utils preference class that will handle all cases.

Easy to use

Saving Preferences

 PrefUtils.saveToPrefs(getActivity(), PrefKeys.USER_INCOME, income); 

Getting Preferences

 Double income = (Double) PrefUtils.getFromPrefs(getActivity(), PrefKeys.USER_INCOME, new Double(10));