transient HashMap使用目的分析

看HashSet源码有这么一句：

private transient HashMap<E,Object> map;

再看HashSet的Add方法：

实际上HashSet是复用HashMap了。

而我们去看看HashMap也会发现一样使用了transient

而不管是HashSet还是HashMapdou都要求是Serializable的：

public class HashMap<K,V> extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializable {

public class HashSet<E>extends AbstractSet<E>implements Set<E>, Cloneable, java.io.Serializable

而transient实际上是不序列化的，这就好像有点“矛盾”，再回答这个问题之前先看看transient。

测试代码如下：

import java.io.Serializable;public class EmployeeTransient implements Serializable {public String getConfidentialInfo() {return confidentialInfo;}public void setConfidentialInfo(String confidentialInfo) {this.confidentialInfo = confidentialInfo;}public String getFirstName() {return firstName;}public void setFirstName(String firstName) {this.firstName = firstName;}public String getLastName() {return lastName;}public void setLastName(String lastName) {this.lastName = lastName;}private transient String confidentialInfo;private String firstName;private String lastName;
}

现在让我们先序列化再反序列化回java对象，并验证是否保存了“ confidentialInfo ”？

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;public class TransientTest {public static void main(String args[]) {try {ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("empInfo.ser"));EmployeeTransient emp = new EmployeeTransient();emp.setFirstName("Lokesh");emp.setLastName("Gupta");emp.setConfidentialInfo("password");//Serialize the objectoos.writeObject(emp);oos.close();} catch (Exception e) {System.out.println(e);}try {ObjectInputStream ooi = new ObjectInputStream(new FileInputStream("empInfo.ser"));//Read the object backEmployeeTransient readEmpInfo = (EmployeeTransient) ooi.readObject();System.out.println(readEmpInfo.getFirstName());System.out.println(readEmpInfo.getLastName());System.out.println(readEmpInfo.getConfidentialInfo());ooi.close();} catch (Exception e) {System.out.println(e);}}
}

很明显，“ confidentialInfo ”在序列化时没有保存到持久状态，这正是我们在java中使用“ transient ”关键字的原因。

什么时候应该在java中使用transient关键字？

现在我们对“ transient  ”关键字非常了解。让我们通过确定您需要使用transient关键字的情况来扩展理解。

1. 第一个也是非常合乎逻辑的情况是，您可能拥有从类实例中的其他字段派生/计算的字段。应该每次都以编程方式计算它们，而不是通过序列化来保持状态。一个例子可以是基于时间戳的价值; 例如人的年龄或时间戳和当前时间戳之间的持续时间。在这两种情况下，您将根据当前系统时间而不是序列化实例来计算变量的值。
2. 第二个逻辑示例可以是任何不应以任何形式泄漏到JVM外部的安全信息（在数据库或字节流中）。
3. 另一个例子可能是在JDK或应用程序代码中未标记为“Serializable”的字段。未实现Serializable接口并在任何可序列化类中引用的类无法序列化; 并将抛出“java.io.NotSerializableException”异常。在序列化主类之前，应将这些不可序列化的引用标记为“transient ”。
4. 最后，有时候序列化某些字段根本没有意义。期。例如，在任何类中，如果添加了记录器引用，那么序列化该记录器实例的用途是什么。绝对没用。您可以逻辑地序列化表示实例状态的信息。Loggers永远不要分享实例的状态。它们只是用于编程/调试目的的实用程序。类似的例子可以是一个Thread类的引用。线程表示任何给定时间点的进程状态，并且没有用于将线程状态存储到您的实例中; 仅仅因为它们不构成你班级实例的状态。

//final field 1
public final transient String confidentialInfo = "password";

现在当我再次运行序列化（写/读）时，会输出出password。

原因是，只要任何最终字段/引用被评估为“ 常量表达式 ”，它就会被JVM序列化，忽略transient关键字的存在。

如果要保持非可序列化字段的状态，请使用readObject（）和writeObject（）方法。writeObject（）/ readObject（）通常在内部链接到序列化/反序列化机制，因此自动调用。 ：java中的SerialVersionUID及相关

HashMap如何使用transient关键字？

HashMap用于存储键值对，我们都知道。并且我们还知道内部密钥的位置HashMap是基于例如密钥获得的哈希码来计算的。现在当我们序列化一个HashMap意味着内部的所有键HashMap和键的各个值也将被序列化。序列化后，当我们反序列化HashMap实例时，所有键实例也将被反序列化。我们知道在这个序列化/反序列化过程中，可能会丢失信息（用于计算哈希码），最重要的是它本身就是一个新的实例。

在java中，任何两个实例（即使是同一个类）都不能具有相同的哈希码。这是一个很大的问题，因为根据新的哈希码应该放置键的位置不在正确的位置。检索键的值时，您将在此新HashMap中引用错误的索引。

：在java中使用hashCode和equals方法

因此，当序列化哈希映射时，这意味着哈希索引，因此表的顺序不再有效，不应保留。这是问题陈述。

HashMap类使用writeObject（）和readObject（）方法，如下所示：

/*** Save the state of the <tt>HashMap</tt> instance to a stream (i.e.,* serialize it).** @serialData The <i>capacity</i> of the HashMap (the length of the*             bucket array) is emitted (int), followed by the*             <i>size</i> (an int, the number of key-value*             mappings), followed by the key (Object) and value (Object)*             for each key-value mapping.  The key-value mappings are*             emitted in no particular order.*/private void writeObject(java.io.ObjectOutputStream s)throws IOException {int buckets = capacity();// Write out the threshold, loadfactor, and any hidden stuffs.defaultWriteObject();s.writeInt(buckets);s.writeInt(size);internalWriteEntries(s);}

// Callbacks to allow LinkedHashMap post-actionsvoid afterNodeAccess(Node<K,V> p) { }void afterNodeInsertion(boolean evict) { }void afterNodeRemoval(Node<K,V> p) { }// Called only from writeObject, to ensure compatible ordering.void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {Node<K,V>[] tab;if (size > 0 && (tab = table) != null) {for (int i = 0; i < tab.length; ++i) {for (Node<K,V> e = tab[i]; e != null; e = e.next) {s.writeObject(e.key);s.writeObject(e.value);}}}}

下面是HashSet中的实现，思路都是一样的。都是把key,value都写到序列化里去，

/*** Save the state of this <tt>HashSet</tt> instance to a stream (that is,* serialize it).** @serialData The capacity of the backing <tt>HashMap</tt> instance*             (int), and its load factor (float) are emitted, followed by*             the size of the set (the number of elements it contains)*             (int), followed by all of its elements (each an Object) in*             no particular order.*/private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException {// Write out any hidden serialization magics.defaultWriteObject();// Write out HashMap capacity and load factors.writeInt(map.capacity());s.writeFloat(map.loadFactor());// Write out sizes.writeInt(map.size());// Write out all elements in the proper order.for (E e : map.keySet())s.writeObject(e);}

然后反序列化的时候就是重新hash一次的过程

下面是HashMap的readObject：

下面是HashSet的readObject：

使用上面的代码，HashMap仍然可以像通常那样处理非transient字段，但是它们一个接一个地在字节数组的末尾写入存储的键值对。在反序列化时，它会通过默认的反序列化过程处理非transient变量，然后逐个读取键值对。对于每个键，哈希和索引再次计算并插入到表中的正确位置，以便可以再次检索它而不会出现任何错误。

参考：Java transient关键字示例

扩展阅读：

为什么HashMap的哈希表标记为transient，尽管该类是可序列化的

图解集合4：HashMap