Java.util.Mapをスマートな方法でパーセルに書き込む方法は？
文字列の一般的なマップ（キー、値）があり、このフィールドはBeanの一部であり、パーセル可能である必要があります。したがって、Parcel＃writeMapメソッドを使用できます。 APIドキュメントには次のように書かれています：
代わりにwriteBundle（Bundle）を使用してください。 Mapを現在のdataPosition（）でパーセルにフラット化し、必要に応じてdataCapacity（）を増やします。 MapキーはStringオブジェクトでなければなりません。 Map値はwriteValue（Object）を使用して書き込まれ、そこでの仕様に従う必要があります。このメソッドの代わりにwriteBundle（Bundle）を使用することを強くお勧めします。これは、Bundleクラスが、マーシャリングの時点で不可解な型エラーを回避できるタイプセーフAPIを提供するためです。
そのため、マップ内の各エントリを繰り返してバンドルに入れることができますが、それを実現するよりスマートな方法を探しています。 Android SDKに不足しているSDKのメソッドはありますか？
現時点では、次のようにしています：
final Bundle bundle = new Bundle();
final Iterator<Entry<String, String>> iter = links.entrySet().iterator();
while(iter.hasNext())
{
final Entry<String, String> entry =iter.next();
bundle.putString(entry.getKey(), entry.getValue());
}
parcel.writeBundle(bundle);
少し違ったやり方でやった。 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を簡単に使用できる場合
マップのkeyとvalueの両方がParcelableを拡張する場合、これに対する非常に気の利いたGenericsソリューションを使用できます。
コード
// 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);
良い質問。 APIには、putSerializableとwriteMap以外に知っているメソッドはありません。シリアル化は、パフォーマンス上の理由から 非推奨 であり、すでに指摘したように、やや不可解な理由からwriteMap（）も推奨されません。
今日はHashMapをパーセルする必要があったので、推奨される方法でBundleとの間でMapをパーセルするユーティリティメソッドをいくつか書いてみました。
// 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);
}
}
Edit：writeMapを変更して、entrySetを使用し、元の回答と同じデータ形式を保持するようにしました（トグルコメントの反対側に表示）。読み取り互換性を必要としない、または維持したくない場合は、@ bcorsoおよび@Anthony Naddeoの回答のように、各反復でキーと値のペアを保存する方が簡単な場合があります。
マップのキーが文字列の場合、javadocsで言及されているように、Bundleを使用できます。
/**
* 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));
}
}
したがって、Serializableの代わりにParcelableを使用できます
これはややシンプルですが、これまでのところKotlinでの実装で動作します。ニーズを満たさない場合は簡単に変更できます
ただし、通常のK,Vなどと異なる場合、String, Int,...はParcelableでなければならないことを忘れないでください。
書きます
parcel.writeMap(map)
読む
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
}
ここに記載されているすべてのソリューションは有効ですが、誰もが十分に普遍的ではありません。多くの場合、文字列、整数、浮動小数点数などの値やキーを含むマップがあります。このような場合、<... extends 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*/)
);