blocks|key|1542251|text|Java泛型实际上是由type+erasure实现的，所以字节码中没有类型信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1542252|例如，让我们看一下两个类，它们声明了一个List字段，一个是泛型的，另一个是非泛型的：|style|CODE|1542253|class+NonGeneric+{
++++List+list;
}|code-block|syntax|javascript|1542254|和,|1542255|class+Generic+{
++++List<String>+list;
}|1542256|在这两种情况下，结果字节码如下：|1542257|++Code:
+++Stack=3,+Locals=1,+Args_size=1
+++0:+++aload_0
+++1:+++invokespecial+++#1;+//Method+java/lang/Object."<init>":()V
+++4:+++aload_0
+++5:+++new+#2;+//class+java/util/ArrayList
+++8:+++dup
+++9:+++invokespecial+++#3;+//Method+java/util/ArrayList."<init>":()V
+++12:++putfield++++#4;+//Field+list:Ljava/util/List;
+++15:++return|1542258|没有对ArrayList或List中使用的String类型的引用。因此，我们可以看到泛型确实是通过类型擦除来实现的。|1542259|然而，如果我们看一下常量池，我们可以找到一个差异。|1542260|非泛型常量池：|1542261|++Constant+pool:
const+#1+=+Method+++#6.#15;+//++java/lang/Object."<init>":()V
const+#2+=+class++++#16;++++//++java/util/ArrayList
const+#3+=+Method+++#2.#15;+//++java/util/ArrayList."<init>":()V
const+#4+=+Field++++#5.#17;+//++NonGeneric.list:Ljava/util/List;
const+#5+=+class++++#18;++++//++NonGeneric
const+#6+=+class++++#19;++++//++java/lang/Object
const+#7+=+Asciz++++list;
const+#8+=+Asciz++++Ljava/util/List;;
const+#9+=+Asciz++++<init>;
const+#10+=+Asciz+++()V;
//+snip+the+rest+//|1542262|通用常量池：|1542263|++Constant+pool:
const+#1+=+Method+++#6.#17;+//++java/lang/Object."<init>":()V
const+#2+=+class++++#18;++++//++java/util/ArrayList
const+#3+=+Method+++#2.#17;+//++java/util/ArrayList."<init>":()V
const+#4+=+Field++++#5.#19;+//++Generic.list:Ljava/util/List;
const+#5+=+class++++#20;++++//++Generic
const+#6+=+class++++#21;++++//++java/lang/Object
const+#7+=+Asciz++++list;
const+#8+=+Asciz++++Ljava/util/List;;
const+#9+=+Asciz++++Signature;
const+#10+=+Asciz+++Ljava/util/List<Ljava/lang/String;>;;
const+#11+=+Asciz+++<init>;
const+#12+=+Asciz+++()V;
//+snip+the+rest//|1542264|可以看到，在Generic类中，我们可以看到常量池中有两个额外的常量，#9和#10，这表明List具有String的泛型类型。|1542265|(并结合我从Chris+Jester-Young's+answer学到的新知识)|1542266|进一步查看类文件的反汇编，在Generic类的Code:+block之前有一个对常量#10的引用：|1542267|java.util.List+list;
++Signature:+length+=+0x2
+++00+0A+|1542268|十六进制值0A是以十进制表示的10，它引用常量池#10|1542269|const+#10+=+Asciz+++Ljava/util/List<Ljava/lang/String;>;;|1542270|因此，使用常量池中的信息来指示字段是泛型类型。|1542271|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/docs/books/tutorial/java/generics/erasure.html|1|https://stackoverflow.com/questions/937933/where-are-generic-types-stored-in-java-class-files/937999#937999^0|B|C|0|0|K|4|0|0|0|0|0|0|3|9|D|4|L|6|0|0|0|0|0|0|6|7|Z|2|12|3|19|4|1F|6|0|6|R|1|0|E|7|N|B|0|0|5|2|F|2|O|3|0|0|0^^$0|@$1|2|3|4|5|6|7|1U|8|@]|9|@$A|1V|B|1W|1|1X]]|C|$]]|$1|D|3|E|5|6|7|1Y|8|@$A|1Z|B|20|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|21|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|22|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|23|8|@]|9|@]|C|$K|L]]|$1|Q|3|R|5|6|7|24|8|@]|9|@]|C|$]]|$1|S|3|T|5|J|7|25|8|@]|9|@]|C|$K|L]]|$1|U|3|V|5|6|7|26|8|@$A|27|B|28|F|G]|$A|29|B|2A|F|G]|$A|2B|B|2C|F|G]]|9|@]|C|$]]|$1|W|3|X|5|6|7|2D|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|6|7|2E|8|@]|9|@]|C|$]]|$1|10|3|11|5|J|7|2F|8|@]|9|@]|C|$K|L]]|$1|12|3|13|5|6|7|2G|8|@]|9|@]|C|$]]|$1|14|3|15|5|J|7|2H|8|@]|9|@]|C|$K|L]]|$1|16|3|17|5|6|7|2I|8|@$A|2J|B|2K|F|G]|$A|2L|B|2M|F|G]|$A|2N|B|2O|F|G]|$A|2P|B|2Q|F|G]|$A|2R|B|2S|F|G]]|9|@]|C|$]]|$1|18|3|19|5|6|7|2T|8|@]|9|@$A|2U|B|2V|1|2W]]|C|$]]|$1|1A|3|1B|5|6|7|2X|8|@$A|2Y|B|2Z|F|G]|$A|30|B|31|F|G]]|9|@]|C|$]]|$1|1C|3|1D|5|J|7|32|8|@]|9|@]|C|$K|L]]|$1|1E|3|1F|5|6|7|33|8|@$A|34|B|35|F|G]|$A|36|B|37|F|G]|$A|38|B|39|F|G]]|9|@]|C|$]]|$1|1G|3|1H|5|J|7|3A|8|@]|9|@]|C|$K|L]]|$1|1I|3|1J|5|6|7|3B|8|@]|9|@]|C|$]]|$1|1K|3|-4|5|6|7|3C|8|@]|9|@]|C|$]]]|1L|$1M|$5|1N|1O|1P|C|$1Q|1R]]|1S|$5|1N|1O|1P|C|$1Q|1T]]]]

Java generics are indeed implemented by <a href="http://java.sun.com/docs/books/tutorial/java/generics/erasure.html" rel="noreferrer">type erasure</a>, so there is no type information in the bytecode.

For example, let's take a look two classes which declare a <code>List</code> field, one in generic and the other in non-generic form:

<pre><code>class NonGeneric {
 List list;
}
</code></pre>

And,

<pre><code>class Generic {
 List&lt;String&gt; list;
}
</code></pre>

In both cases, the resulting bytecode is the following:

<pre><code> Code:
 Stack=3, Locals=1, Args_size=1
 0: aload_0
 1: invokespecial #1; //Method java/lang/Object."&lt;init&gt;":()V
 4: aload_0
 5: new #2; //class java/util/ArrayList
 8: dup
 9: invokespecial #3; //Method java/util/ArrayList."&lt;init&gt;":()V
 12: putfield #4; //Field list:Ljava/util/List;
 15: return
</code></pre>

There is no reference to the <code>String</code> type used in the <code>ArrayList</code> nor <code>List</code>. So, we can see that generics is indeed implemented by type erasure.

However, if we look at the constant pool, we can find a difference.

The non-generic constant pool:

<pre><code> Constant pool:
const #1 = Method #6.#15; // java/lang/Object."&lt;init&gt;":()V
const #2 = class #16; // java/util/ArrayList
const #3 = Method #2.#15; // java/util/ArrayList."&lt;init&gt;":()V
const #4 = Field #5.#17; // NonGeneric.list:Ljava/util/List;
const #5 = class #18; // NonGeneric
const #6 = class #19; // java/lang/Object
const #7 = Asciz list;
const #8 = Asciz Ljava/util/List;;
const #9 = Asciz &lt;init&gt;;
const #10 = Asciz ()V;
// snip the rest //
</code></pre>

The generic constant pool:

<pre><code> Constant pool:
const #1 = Method #6.#17; // java/lang/Object."&lt;init&gt;":()V
const #2 = class #18; // java/util/ArrayList
const #3 = Method #2.#17; // java/util/ArrayList."&lt;init&gt;":()V
const #4 = Field #5.#19; // Generic.list:Ljava/util/List;
const #5 = class #20; // Generic
const #6 = class #21; // java/lang/Object
const #7 = Asciz list;
const #8 = Asciz Ljava/util/List;;
const #9 = Asciz Signature;
const #10 = Asciz Ljava/util/List&lt;Ljava/lang/String;&gt;;;
const #11 = Asciz &lt;init&gt;;
const #12 = Asciz ()V;
// snip the rest//
</code></pre>

As can be seen, in the <code>Generic</code> class, we can see there are two extra constants, <code>#9</code> and <code>#10</code>, in the constant pool, which mentions that the <code>List</code> has the generic type of <code>String</code>. 

(And incorporating new knowledge that I learned from <a href="https://stackoverflow.com/questions/937933/where-are-generic-types-stored-in-java-class-files/937999#937999">Chris Jester-Young's answer</a>)

Looking further at the disassembly of the class file, there is a reference to the constant #10 right before the <code>Code: block</code> of the <code>Generic</code> class:

<pre><code>java.util.List list;
 Signature: length = 0x2
 00 0A 
</code></pre>

The hexadecimal value <code>0A</code> is <code>10</code> in decimal, which refers to the constant pool <code>#10</code>:

<pre><code>const #10 = Asciz Ljava/util/List&lt;Ljava/lang/String;&gt;;;
</code></pre>

Therefore, the information from the constant pool is used in order to indicate that a field is of a generic type.

blocks|key|1542345|text|它们存储在Signature属性中；有关字段类型签名的格式，请参阅updated+Java+Virtual+Machine+Specification的4.8.8小节，以及4.4.4小节。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1542346|下面是一个使用javap+-verbose+java.util.Map的示例|1542347|public+interface+java.util.Map
++SourceFile:+"Map.java"
++Signature:+length+=+0x2
+++00+1E+
++[other+attributes+omitted]|code-block|syntax|javascript|1542348|这里的Signature属性指定常量池值#30+(30+=+0x1E)。那么让我们来看看这里：|1542349|const+#30+=+Asciz+++++++<K:Ljava/lang/Object;V:Ljava/lang/Object;>Ljava/lang/Object;;|1542350|在4.4.4中指定的语法上下文中阅读本文。因此，它使用了两个类型参数：K+extends+java.lang.Object和V+extends+java.lang.Object。类型本身(Map)也扩展了类java.lang.Object，并且没有接口。|1542351|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/docs/books/jvms/second_edition/jvms-clarify.html^0|5|9|X|16|0|0|7|S|0|0|3|9|0|0|Z|Q|1Q|Q|2M|3|2V|G|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|19|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

They are stored in <code>Signature</code> attributes; see section 4.8.8 of the <a href="http://java.sun.com/docs/books/jvms/second_edition/jvms-clarify.html" rel="noreferrer">updated Java Virtual Machine Specification</a>, as well as section 4.4.4 for the format of the field type signature.

Here's an example using <code>javap -verbose java.util.Map</code>:

<pre><code>public interface java.util.Map
 SourceFile: "Map.java"
 Signature: length = 0x2
 00 1E 
 [other attributes omitted]
</code></pre>

The <code>Signature</code> attribute here specifies (if you read this as big-endian, like all integer quantities in the JVM class file format are) constant pool value #30 (30 = 0x1E). So let's have a look there:

<pre><code>const #30 = Asciz &lt;K:Ljava/lang/Object;V:Ljava/lang/Object;&gt;Ljava/lang/Object;;
</code></pre>

Read this in the context of the grammar specified in 4.4.4. So, this uses two type parameters, <code>K extends java.lang.Object</code> and <code>V extends java.lang.Object</code>. The type itself (<code>Map</code>) also extends class <code>java.lang.Object</code>, and no interfaces.

I am well aware that generic types are erased from Java code when it is compiled. What information (attributes?) do 1.5+ JVMs use to implement <code>getGenericType</code> , etc. ?

Where are generic types stored in java class files?

Java

我很清楚，泛型类型在编译时会从Java代码中删除。什么信息(属性？)1.5+ JVM是否用于实现getGenericType等？

问泛型类型存储在java类文件中的什么地方？
EN

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问泛型类型存储在java类文件中的什么地方？EN