从Parcelable类读取和写入java.util.Date

我在包裹班工作。如何在这个类中读写

java.util.Date

对象？

Date

类实现了

Serializable

这样你就可以写作了

parcel.writeSerializable(java.util.Date)

你可以像这样阅读

java.util.Date date = (java.util.Date)parcel.readSerializable();

在日期可序列化的位置使用。（但这不是一个好主意。请参阅下面的另一个更好的方法）

---

---

但是序列化操作会消耗很多性能。如何克服 这个

所以更好的用法是在写入时将日期转换为Long，然后读取Long并传递给日期构造函数以获取日期。请参阅下面的代码

这样试试看：：

对于书面：

yourParse.writeSerializable(YourGivenDate)

供阅读：

Date myDate = yourParse.readSerializable();

使用date.getTime（）获取长格式：

public class MiClass implements Parcelable {
    Date date;

    public MiClass(Date date) {
        this.date = date;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeLong(date != null ? date.getTime() : -1);
    }

    protected MiClass(Parcel in) {
        long tmpDate = in.readLong();
        this.date = tmpDate == -1 ? null : new Date(tmpDate);
    }

    public static final Parcelable.Creator<MiClass> CREATOR = new Parcelable.Creator<MiClass>() {
        public MiClass createFromParcel(Parcel source) {
            return new MiClass(source);
        }

        public MiClass[] newArray(int size) {
            return new MiClass[size];
        }
    };
}

public类MiClass实现可包裹{
日期；
公共微类（日期）{
this.date=日期；
}
@凌驾
公共int描述内容（）{
返回0；
}
@凌驾
公共无效写入包裹（包裹目的地，内部标志）{
dest.writeLong（date！=null？date.getTime（）：-1）；
}
受保护微类（包裹中）{
long tmpDate=in.readLong（）；
this.date=tmpDate==-1？空：新日期（tmpDate）；
}
public static final Parcelable.Creator=新建Parcelable.Creator（）{
公共微类createFromParcel（地块源）{
返回新的MiClass（源）；
}
公共MiClass[]新数组（整数大小）{
返回新的MiClass[大小]；
}
};
}

在Kotlin中，我们可以为地块创建扩展-最简单的解决方案

fun Parcel.writeDate(date: Date?) {
    writeLong(date?.time ?: -1)
}

fun Parcel.readDate(): Date? {
    val long = readLong()
    return if (long != -1L) Date(long) else null
}

并使用它

parcel.writeDate(date)
parcel.readDate()

试试这个（Kotlin）：

数据类DateParcel（val日期：日期？）：Parcelable{
构造函数（parcel:parcel）：这个（parcel.readValue（Date:：class.java.classLoader）作为？日期
)
覆盖地块（地块：地块，标志：Int）{
包裹书面价值（日期）
}
覆盖有趣的描述内容（）：Int{
返回0
}
同伴对象创建者：Parcelable.CREATOR{
覆盖createFromParcel（地块：地块）：日期地块{
寄回日期包裹（包裹）
}
覆盖新数组（大小：Int）：数组{
返回阵列fnulls（大小）
}
}}

但是序列化操作会消耗很多性能。如何克服这个问题？您确实应该使用long，因为可序列化对性能没有好处，这在旧设备上是显而易见的。你可能还想看看Joda，因为它包含了很多有用的工具，并且有一个DateTime对象，我经常发现它更有用。我更喜欢使用long而不是序列化。@Mesut很棒！康斯，你找到解决办法了。@JockyDoe，不会的。包裹和取消包裹时的字段顺序。因此，请检查这两个字段是否使用相同的顺序。虽然这会起作用，但我建议So的用户使用long来查看答案。这是一个很好的解决方案，但对于1970年1月1日之前的日期，这将无法正常工作-1L实际上是表示1970年1月1日前一毫秒的有效值。因此，为了更好的安全性，我宁愿使用Long.MIN_值这样的值。

fun Parcel.writeDate(date: Date?) {
    writeLong(date?.time ?: -1)
}

fun Parcel.readDate(): Date? {
    val long = readLong()
    return if (long != -1L) Date(long) else null
}

parcel.writeDate(date)
parcel.readDate()

data class DateParcel(val date: Date?):Parcelable {
constructor(parcel: Parcel) : this(parcel.readValue(Date::class.java.classLoader) as? Date
)

override fun writeToParcel(parcel: Parcel, flags: Int) {
    parcel.writeValue(date)
}

override fun describeContents(): Int {
    return 0
}

companion object CREATOR : Parcelable.Creator<DateParcel> {
    override fun createFromParcel(parcel: Parcel): DateParcel {
        return DateParcel(parcel)
    }

    override fun newArray(size: Int): Array<DateParcel?> {
        return arrayOfNulls(size)
    }
}}