android - programacion - No se puede poner doble SharedPreferences

curso android desarrollo de aplicaciones móviles pdf

Question

Obteniendo el error, el método put double no está definido para este tipo de editor de SharedPreferences. Se le da a eclipse una solución rápida para que agregue el elenco al editor, pero cuando lo hago, sigue teniendo errores, por qué no puedo poner el doble.

El código:

@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

Aquellos que sugirieron usar putFloat y getFloat desafortunadamente están muy equivocados. Lanzar un doble a un flotador puede resultar en

1. Precisión perdida
2. Rebosar
3. Underflow
4. Gatitos muertos

Aquellos que sugieren un toString y parseString no son incorrectos, pero es una solución ineficiente.

La forma correcta de lidiar con esto es convertir el doble a su equivalente en "bits largos sin formato" y almacenar ese tiempo. Cuando estés leyendo el valor, vuelve a convertir en doble.

Debido a que los dos tipos de datos tienen el mismo tamaño, no pierde precisión y no provocará un flujo de {over, under}.

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

Alternativamente, puede escribir el captador como:

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

Comprueba esta idea: https://gist.github.com/john1jan/b8cb536ca51a0b2aa1da4e81566869c4

Creé una clase Utilidades de preferencia que manejará todos los casos.

Es fácil de usar

Almacenar en preferencia

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

Obteniendo de preferencia

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

Answer 3

Forma de extensión de Kotlin (mucho más bonita que usar clases utilitarias raras o lo que sea)

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 4

Lo que hice fue guardar la preferencia como una cadena:

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

y luego para recuperar el doble, simplemente use Double.parseDouble:

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

Answer 5

Siempre puede implementar SharedPreferences y ajustar la implementación de Android.

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