No se puede poner el doble de SharedPreferences


90

Recibiendo un error, el método put double no está definido para este tipo de editor de preferencias compartidas. A Eclipse se le da una solución rápida para agregar cast al editor, pero cuando hago eso, todavía se dan errores, ¿por qué no puedo poner double?

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

2
¿Podría especificar qué error tiene?
dumbfingers

1
Mire la primera línea de la pregunta
Robert

Me pregunto cómo es que los chicos de Android no implementaron putDouble en API.
luky

Respuestas:


336

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

  1. Precisión perdida
  2. Desbordamiento
  3. Desbordamiento
  4. Gatitos muertos

Aquellos que sugieren un toString y parseString no están equivocados, pero es una solución ineficiente.

La forma correcta de lidiar con esto es convertir el doble en su equivalente de 'bits largos sin procesar' y almacenar ese tiempo. Cuando lea el valor, conviértalo de nuevo al doble.

Debido a que los dos tipos de datos tienen el mismo tamaño, no pierde precisión y no provoca un flujo {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));
}

9
Tan hermosa, limpia y elegante.
Bogdan Alexandru

9
Un método putDouble aún sería bueno y consistente con otras API dentro del ecosistema de Android (como parceable y bundles). Un caso típico en el que Google vuelve a ser rápido y descuidado.

2
¿Por qué guardarlo como cuerda es ineficaz?
KKO

2
@KKO El tipo de datos largo es un entero de complemento a dos de 64 bits. Por lo tanto, solo toma 4 bytes. ¡Pero si almacena ese doublevalor como una cadena, entonces arruina su almacenamiento y lo convierte en un desastre!
semsamot

1
prefs.getLong (clave, 0d) incorrecto no es un doble. debería estar sin el d.
Ahmed Hegazy

27

Forma de extensión de Kotlin (mucho más bonita que usar clases de utilidades extrañas 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)))

2
Genial, estaba pensando exactamente en poner esto aquí. ¡Gracias!
wzieba

16

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

4
Estás desperdiciando almacenamiento. También es mucho más lento que el doubleToRawLongBitsmétodo que ya se mencionó. Esta es la forma incorrecta , no porque no funcione, sino porque es muy ineficiente.
copolii

10
@copolii Académicamente, seguro. En la práctica, en la industria, realmente no hace una diferencia suficiente para importar en el 99% de los casos y, de hecho, esto es probablemente más legible y más fácil de entender cuando se trae a alguien nuevo.
Dennis L

@DennisL #PracticalDev
Aba

9

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

Esta es la respuesta correcta. Ojalá hubiera visto esto antes de empezar a escribir. ¿No sería más eficiente simplemente devolver 'esto' en los métodos del editor? Le ahorra llamar al método 'instanceof'. ¿O lo ha intentado y ha causado problemas?
copolii

0

Consulte esta esencia https://gist.github.com/john1jan/b8cb536ca51a0b2aa1da4e81566869c4

He creado una clase Preference Utils que manejará todos los casos.

Es fácil de usar

Guardar en preferencia

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

Obtener de preferencia

Double income = (Double) PrefUtils.getFromPrefs(getActivity(), PrefKeys.USER_INCOME, new Double(10));
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.