7 ответов
Если ключ Вашей карты является Строкой, можно просто использовать Пакет, как это упомянуло в javadocs:
/**
* Please use {@link #writeBundle} instead. Flattens a Map into the parcel
* at the current dataPosition(),
* growing dataCapacity() if needed. The Map keys must be String objects.
* The Map values are written using {@link #writeValue} and must follow
* the specification there.
*
* <p>It is strongly recommended to use {@link #writeBundle} instead of
* this method, since the Bundle class provides a type-safe API that
* allows you to avoid mysterious type errors at the point of marshalling.
*/
public final void writeMap(Map val) {
writeMapInternal((Map<String, Object>) val);
}
, Таким образом, я написал следующий код:
private void writeMapAsBundle(Parcel dest, Map<String, Serializable> map) {
Bundle bundle = new Bundle();
for (Map.Entry<String, Serializable> entry : map.entrySet()) {
bundle.putSerializable(entry.getKey(), entry.getValue());
}
dest.writeBundle(bundle);
}
private void readMapFromBundle(Parcel in, Map<String, Serializable> map, ClassLoader keyClassLoader) {
Bundle bundle = in.readBundle(keyClassLoader);
for (String key : bundle.keySet()) {
map.put(key, bundle.getSerializable(key));
}
}
Соответственно, можно использовать Parcelable вместо сериализуемого
Вот мой несколько простой но рабочий до сих пор для меня реализация в Kotlin. Это может быть изменено легко, если не удовлетворяет, что каждому нужно
, Но не забывайте, что K,V должен быть Parcelable, если отличающийся, чем обычное String, Int,... и т.д.
Запись
parcel.writeMap(map)
Read
parcel.readMap(map)
перегрузка чтения
fun<K,V> Parcel.readMap(map: MutableMap<K,V>) : MutableMap<K,V>{
val tempMap = LinkedHashMap<Any?,Any?>()
readMap(tempMap, map.javaClass.classLoader)
tempMap.forEach {
map[it.key as K] = it.value as V
}
/* It populates and returns the map as well
(useful for constructor parameters inits)*/
return map
}
Все решения, упомянутые здесь, допустимы, но никто не достаточно универсален. Часто у Вас есть карты, содержащие Строки, Целые числа, Плавания и т.д. оценивает и/или ключи. В таком случае Вы не можете использовать <... расширяет Parcelable>, и я не хочу писать пользовательские методы для любых других комбинаций ключа/значения. Для того случая можно использовать этот код:
@FunctionalInterface
public interface ParcelWriter<T> {
void writeToParcel(@NonNull final T value,
@NonNull final Parcel parcel, final int flags);
}
@FunctionalInterface
public interface ParcelReader<T> {
T readFromParcel(@NonNull final Parcel parcel);
}
public static <K, V> void writeParcelableMap(
@NonNull final Map<K, V> map,
@NonNull final Parcel parcel,
final int flags,
@NonNull final ParcelWriter<Map.Entry<K, V>> parcelWriter) {
parcel.writeInt(map.size());
for (final Map.Entry<K, V> e : map.entrySet()) {
parcelWriter.writeToParcel(e, parcel, flags);
}
}
public static <K, V> Map<K, V> readParcelableMap(
@NonNull final Parcel parcel,
@NonNull final ParcelReader<Map.Entry<K, V>> parcelReader) {
int size = parcel.readInt();
final Map<K, V> map = new HashMap<>(size);
for (int i = 0; i < size; i++) {
final Map.Entry<K, V> value = parcelReader.readFromParcel(parcel);
map.put(value.getKey(), value.getValue());
}
return map;
}
Это является более подробным, но универсальным. Вот использование записи:
writeParcelableMap(map, dest, flags, (mapEntry, parcel, __) -> {
parcel.write...; //key from mapEntry
parcel.write...; //value from mapEntry
});
и читайте:
map = readParcelableMap(in, parcel ->
new AbstractMap.SimpleEntry<>(parcel.read... /*key*/, parcel.read... /*value*/)
);
Если и key и value из карты расширяются Parcelable, у Вас может быть довольно изящное решение для Дженериков этого:
Код
// For writing to a Parcel
public <K extends Parcelable,V extends Parcelable> void writeParcelableMap(
Parcel parcel, int flags, Map<K, V > map)
{
parcel.writeInt(map.size());
for(Map.Entry<K, V> e : map.entrySet()){
parcel.writeParcelable(e.getKey(), flags);
parcel.writeParcelable(e.getValue(), flags);
}
}
// For reading from a Parcel
public <K extends Parcelable,V extends Parcelable> Map<K,V> readParcelableMap(
Parcel parcel, Class<K> kClass, Class<V> vClass)
{
int size = parcel.readInt();
Map<K, V> map = new HashMap<K, V>(size);
for(int i = 0; i < size; i++){
map.put(kClass.cast(parcel.readParcelable(kClass.getClassLoader())),
vClass.cast(parcel.readParcelable(vClass.getClassLoader())));
}
return map;
}
Использование
// MyClass1 and MyClass2 must extend Parcelable
Map<MyClass1, MyClass2> map;
// Writing to a parcel
writeParcelableMap(parcel, flags, map);
// Reading from a parcel
map = readParcelableMap(parcel, MyClass1.class, MyClass2.class);
Я закончил тем, что делал его немного по-другому. Это следует за шаблоном, который Вы ожидали бы для контакта с Parcelables, таким образом, это должно быть знакомо.
public void writeToParcel(Parcel out, int flags){
out.writeInt(map.size());
for(Map.Entry<String,String> entry : map.entrySet()){
out.writeString(entry.getKey());
out.writeString(entry.getValue());
}
}
private MyParcelable(Parcel in){
//initialize your map before
int size = in.readInt();
for(int i = 0; i < size; i++){
String key = in.readString();
String value = in.readString();
map.put(key,value);
}
}
В моем приложении, порядок ключей в карте имел значение. Я использовал LinkedHashMap для сохранения упорядочивания и выполнения его, этот путь гарантировал, что ключи появятся в том же порядке, будучи извлеченным из Parcel.
можно попробовать:
bundle.putSerializable(yourSerializableMap);
, если Ваша выбранная карта реализует сериализуемый (как HashMap) и затем можно использовать writeBundle в простоте
Хороший вопрос. Нет никаких методов в API, о котором я знаю кроме putSerializable и writeMap. Сериализация не рекомендована по причинам производительности, и writeMap () также не рекомендуется по несколько таинственным причинам, как Вы уже указали.
я должен был распределить HashMap сегодня, таким образом, я попробовал силы в записи некоторых служебных методов для завертывания в пакеты Карты к и от Пакета рекомендуемым способом:
// Usage:
// read map into a HashMap<String,Foo>
links = readMap(parcel, Foo.class);
// another way that lets you use a different Map implementation
links = new SuperDooperMap<String, Foo>;
readMap(links, parcel, Foo.class);
// write map out
writeMap(links, parcel);
////////////////////////////////////////////////////////////////////
// Parcel methods
/**
* Reads a Map from a Parcel that was stored using a String array and a Bundle.
*
* @param in the Parcel to retrieve the map from
* @param type the class used for the value objects in the map, equivalent to V.class before type erasure
* @return a map containing the items retrieved from the parcel
*/
public static <V extends Parcelable> Map<String,V> readMap(Parcel in, Class<? extends V> type) {
Map<String,V> map = new HashMap<String,V>();
if(in != null) {
String[] keys = in.createStringArray();
Bundle bundle = in.readBundle(type.getClassLoader());
for(String key : keys)
map.put(key, type.cast(bundle.getParcelable(key)));
}
return map;
}
/**
* Reads into an existing Map from a Parcel that was stored using a String array and a Bundle.
*
* @param map the Map<String,V> that will receive the items from the parcel
* @param in the Parcel to retrieve the map from
* @param type the class used for the value objects in the map, equivalent to V.class before type erasure
*/
public static <V extends Parcelable> void readMap(Map<String,V> map, Parcel in, Class<V> type) {
if(map != null) {
map.clear();
if(in != null) {
String[] keys = in.createStringArray();
Bundle bundle = in.readBundle(type.getClassLoader());
for(String key : keys)
map.put(key, type.cast(bundle.getParcelable(key)));
}
}
}
/**
* Writes a Map to a Parcel using a String array and a Bundle.
*
* @param map the Map<String,V> to store in the parcel
* @param out the Parcel to store the map in
*/
public static void writeMap(Map<String,? extends Parcelable> map, Parcel out) {
if(map != null && map.size() > 0) {
/*
Set<String> keySet = map.keySet();
Bundle b = new Bundle();
for(String key : keySet)
b.putParcelable(key, map.get(key));
String[] array = keySet.toArray(new String[keySet.size()]);
out.writeStringArray(array);
out.writeBundle(b);
/*/
// alternative using an entrySet, keeping output data format the same
// (if you don't need to preserve the data format, you might prefer to just write the key-value pairs directly to the parcel)
Bundle bundle = new Bundle();
for(Map.Entry<String, ? extends Parcelable> entry : map.entrySet()) {
bundle.putParcelable(entry.getKey(), entry.getValue());
}
final Set<String> keySet = map.keySet();
final String[] array = keySet.toArray(new String[keySet.size()]);
out.writeStringArray(array);
out.writeBundle(bundle);
/**/
}
else {
//String[] array = Collections.<String>emptySet().toArray(new String[0]);
// you can use a static instance of String[0] here instead
out.writeStringArray(new String[0]);
out.writeBundle(Bundle.EMPTY);
}
}
Редактирование: изменил writeMap для использования entrySet при сохранении того же формата данных как в моем исходном ответе (показанный с другой стороны комментария переключателя). Если Вы не нуждаетесь или хотите сохранить совместимость чтения, может быть более просто просто сохранить пары "ключ-значение" на каждом повторении, как в @bcorso и ответах @Anthony Naddeo.