blocks|key|326515|text|在Java中，枚举实际上只是加了一些语法糖的类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|326516|因此，每当您定义新的枚举时，Java编译器都会为您创建一个相应的Class文件。(无论枚举有多简单)。|326517|除了不使用枚举之外，没有办法绕过这一点。|326518|如果空间很重要，你可以直接使用常量来代替。|326519|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

In Java, Enumerations are really just Classes with some syntactic sugar thrown on. 

So anytime you define a new Enumeration, the Java compiler will create a corresponding Class file for you. (No matter how simple the Enumeration is).

No way to get around this, other then not using Enumerations. 

If space is a premium, you can always just use Constants instead.

blocks|key|324254|text|当您使用Java枚举的“每个实例的方法实现”特性时，会出现$1等文件，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|324255|public+enum+Foo{
++++YEA{
++++++++public+void+foo(){+return+true+};
++++},
++++NAY{
++++++++public+void+foo(){+return+false+};
++++};

++++public+abstract+boolean+foo();
}|code-block|syntax|javascript|324256|上面的代码将创建三个类文件，一个用于基础枚举类，一个用于YEA和NAY，用于保存foo()的不同实现。|324257|在字节码级别上，枚举只是类，为了让每个枚举实例以不同的方式实现方法，每个实例需要有一个不同的类，|324258|但是，这并不包括为枚举用户生成的其他类文件，我怀疑这些文件只是匿名类的结果，与枚举无关。|324259|因此，为了避免生成此类额外的类文件，请不要使用每个实例的方法实现。在上述方法返回常量的情况下，您可以使用构造函数中设置的公共final字段(如果您愿意，也可以使用带有公共getter的私有字段)。如果您确实需要对不同的enum实例使用具有不同逻辑的方法，那么您无法避免额外的类，但我认为这是一个非常奇特且很少需要的特性。|324260|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The $1 etc. files occur when you use the "per-instance method implementation" feature of Java's enums, like this:

<pre><code>public enum Foo{
 YEA{
 public void foo(){ return true };
 },
 NAY{
 public void foo(){ return false };
 };

 public abstract boolean foo();
}
</code></pre>

The above will create three class files, one for the base enum class and one each for YEA and NAY to hold the different implementations of foo().

On the bytecode level, enums are just classes, and in order for each enum instance to implement a method differently, there needs to be a different class for each instance,

However, this does not account for additional class files generated for users of the enum, and I suspect those are just the result of anonymous classes and have nothing to do with enums.

Thus, in order to avoid such extra class files to be generated, do not use per-instance method implementations. In cases such as above where the methods return constants, you can use a public final field set in a constructor instead (or a private field with a public getter if you prefer). If you really need methods with different logic for different enum instances, then you can't avoid the extra classes, but I'd consider it a rather exotic and rarely needed feature.

blocks|key|3075850|text|据我所知，给定一个名为Operation的枚举，如果您像这样使用abstract+method，您将获得额外的类文件，不包括明显的Operation.class，并且每个枚举值一个：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3075851|enum+Operation+{

+++ADD+{
++++++double+op(double+a,+double+b)+{+
++++++++++return+a+%2B+b;
++++++}
+++},

+++SUB+{
++++++double+op(double+a,+double+b)+{+
++++++++++return+a+-+b;
++++++}
+++};

+++abstract+double+op(double+a,+double+b);
}|code-block|syntax|javascript|3075852|entityMap^0|B|9|W|F|1T|F|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

as far I know, given an enum named <code>Operation</code> you will get additional class files, excluding the obvious <code>Operation.class</code>, and one per enum value, if you are using <code>abstract method</code> like this one:

<pre><code>enum Operation {

 ADD {
 double op(double a, double b) { 
 return a + b;
 }
 },

 SUB {
 double op(double a, double b) { 
 return a - b;
 }
 };

 abstract double op(double a, double b);
}
</code></pre>

blocks|key|323706|text|我只是被这种行为所困扰，当我在谷歌上搜索时，这个问题出现了。我想我应该分享我发现的一点额外信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|323707|每次在枚举上使用开关时，javac+1.5和1.6都会创建一个额外的合成类。该类包含一个所谓的"switch+map“，它将枚举索引映射到交换表跳转编号。重要的是，合成类是为发生切换的类创建的，而不是枚举类。|323708|下面是一个生成内容的示例：|323709|EnumClass.java|323710|public+enum+EnumClass+{+VALUE1,+VALUE2,+VALUE3+}|code-block|syntax|javascript|323711|EnumUser.java|323712|public+class+EnumUser+{
++++public+String+getName(EnumClass+value)+{
++++++++switch+(value)+{
++++++++++++case+VALUE1:+return+"value+1";
++++++++++++//+No+VALUE2+case.
++++++++++++case+VALUE3:+return+"value+3";
++++++++++++default:+++++return+"other";
++++++++}
++++}
}|323713|合成EnumUser$1.class|323714|class+EnumUser$1+{
++++static+final+int[]+$SwitchMap$EnumClass+=+new+int[EnumClass.values().length];

++++static+{
++++++++$SwitchMap$EnumClass[EnumClass.VALUE1.ordinal()]+=+1;
++++++++$SwitchMap$EnumClass[EnumClass.VALUE3.ordinal()]+=+2;
++++};
}|323715|然后，此开关映射用于为lookupswitch或tableswitch+JVM指令生成索引。它将每个枚举值转换为从1到切换案例数的对应索引。|offset|length|style|CODE|323716|EnumUser.class|323717|public+java.lang.String+getName(EnumClass);
++Code:
+++0:+++getstatic+++++++#2;+//Field+EnumUser$1.$SwitchMap$EnumClass:[I
+++3:+++aload_1
+++4:+++invokevirtual+++#3;+//Method+EnumClass.ordinal:()I
+++7:+++iaload
+++8:+++lookupswitch{+//2
++++++++++++++++1:+36;
++++++++++++++++2:+39;
++++++++++++++++default:+42+}
+++36:++ldc+++++#4;+//String+value+1
+++38:++areturn
+++39:++ldc+++++#5;+//String+value+3
+++41:++areturn
+++42:++ldc+++++#6;+//String+other
+++44:++areturn|323718|如果有三个或更多的切换情况，则使用tableswitch，因为它执行的是更有效的恒定时间查找，而不是lookupswitch的线性搜索。从技术上讲，当它使用lookupswitch时，它可以通过合成切换映射省略整个业务。|323719|猜测：我手头没有可以测试的Eclipse编译器，但我想它不会使用合成类，而是简单地使用lookupswitch。或者，它可能需要比测试的原始请求者更多的切换用例，然后才能将其"ugprades“到tableswitch。|BOLD|323720|entityMap^0|0|0|0|0|0|0|0|0|0|B|C|O|B|0|0|0|H|B|1E|C|26|C|0|0|3|17|C|2Q|B|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1D|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1E|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1F|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1H|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1I|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|1J|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|1K|8|@$W|1L|X|1M|Y|Z]|$W|1N|X|1O|Y|Z]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1P|8|@]|9|@]|A|$]]|$1|12|3|13|5|J|7|1Q|8|@]|9|@]|A|$K|L]]|$1|14|3|15|5|6|7|1R|8|@$W|1S|X|1T|Y|Z]|$W|1U|X|1V|Y|Z]|$W|1W|X|1X|Y|Z]]|9|@]|A|$]]|$1|16|3|17|5|6|7|1Y|8|@$W|1Z|X|20|Y|18]|$W|21|X|22|Y|Z]|$W|23|X|24|Y|Z]]|9|@]|A|$]]|$1|19|3|-4|5|6|7|25|8|@]|9|@]|A|$]]]|1A|$]]

I was just bit by this behavior and this question showed up when Googling. I thought I'd share the little bit of extra information I found out.

javac 1.5 and 1.6 create an additional synthetic class each time you use a switch on an enum. The class contains a so-called "switch map" which maps enum indices to switch table jump numbers. Importantly, the synthetic class is created for the class in which the switch occurs, not the enum class.

Here's an example of what gets generated:

<h3>EnumClass.java</h3>

<pre><code>public enum EnumClass { VALUE1, VALUE2, VALUE3 }
</code></pre>

<h3>EnumUser.java</h3>

<pre><code>public class EnumUser {
 public String getName(EnumClass value) {
 switch (value) {
 case VALUE1: return "value 1";
 // No VALUE2 case.
 case VALUE3: return "value 3";
 default: return "other";
 }
 }
}
</code></pre>

<h3>Synthetic EnumUser$1.class</h3>

<pre><code>class EnumUser$1 {
 static final int[] $SwitchMap$EnumClass = new int[EnumClass.values().length];

 static {
 $SwitchMap$EnumClass[EnumClass.VALUE1.ordinal()] = 1;
 $SwitchMap$EnumClass[EnumClass.VALUE3.ordinal()] = 2;
 };
}
</code></pre>

This switch map is then used to generate an index for a <code>lookupswitch</code> or <code>tableswitch</code> JVM instruction. It converts each enum value into a corresponding index from 1 to [number of switch cases].

<h3>EnumUser.class</h3>

<pre><code>public java.lang.String getName(EnumClass);
 Code:
 0: getstatic #2; //Field EnumUser$1.$SwitchMap$EnumClass:[I
 3: aload_1
 4: invokevirtual #3; //Method EnumClass.ordinal:()I
 7: iaload
 8: lookupswitch{ //2
 1: 36;
 2: 39;
 default: 42 }
 36: ldc #4; //String value 1
 38: areturn
 39: ldc #5; //String value 3
 41: areturn
 42: ldc #6; //String other
 44: areturn
</code></pre>

<code>tableswitch</code> is used if there are three or more switch cases as it performs a more efficient constant-time lookup vs. <code>lookupswitch</code>'s linear search. Technically speaking javac could omit this whole business with the synthetic switch map when it uses <code>lookupswitch</code>.

Speculation: I don't have Eclipse's compiler on hand to test with but I imagine that it doesn't bother with a synthetic class and simply uses <code>lookupswitch</code>. Or perhaps it requires more switch cases than the original asker tested with before it "ugprades" to <code>tableswitch</code>.

blocks|key|323722|text|我相信这样做是为了防止开关在枚举的顺序改变时中断，同时不会使用开关重新编译类。考虑以下情况：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|323723|enum+A{
++++ONE,+//ordinal+0
++++TWO;+//ordinal+1
}
class+B{
+++++void+foo(A+a){
+++++++++switch(a){
++++++++++++++case+ONE:
+++++++++++++++++++System.out.println("One");
+++++++++++++++++++break;
++++++++++++++case+TWO:
+++++++++++++++++++System.out.println("Two");
+++++++++++++++++++break;
+++++++++}
+++++}
}|code-block|syntax|javascript|323724|如果没有开关映射，foo()将大致转换为：|offset|length|style|CODE|323725|+void+foo(A+a){
+++++++++switch(a.ordinal()){
++++++++++++++case+0:+//ONE.ordinal()
+++++++++++++++++++System.out.println("One");
+++++++++++++++++++break;
++++++++++++++case+1:+//TWO.ordinal()
+++++++++++++++++++System.out.println("Two");
+++++++++++++++++++break;
+++++++++}
+++++}|323726|因为case语句必须是编译时常量(例如，不是方法调用)。在这种情况下，如果A的顺序被改变，foo()将打印“1”作为2，反之亦然。|323727|entityMap^0|0|0|9|5|0|0|11|1|19|5|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@$I|Z|J|10|K|L]|$I|11|J|12|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

I believe this is done to prevent switches from breaking if the ordering of the enum is changed, while not recompiling the class with the switch. Consider the following case:

<pre><code>enum A{
 ONE, //ordinal 0
 TWO; //ordinal 1
}
class B{
 void foo(A a){
 switch(a){
 case ONE:
 System.out.println("One");
 break;
 case TWO:
 System.out.println("Two");
 break;
 }
 }
}
</code></pre>

Without the switch map, <code>foo()</code> would roughly translate to:

<pre><code> void foo(A a){
 switch(a.ordinal()){
 case 0: //ONE.ordinal()
 System.out.println("One");
 break;
 case 1: //TWO.ordinal()
 System.out.println("Two");
 break;
 }
 }
</code></pre>

Since case statements must be compile-time constants (e.g. not method calls). In this case, if the ordering of <code>A</code> is switched, <code>foo()</code> would print out "One" for TWO, and vice versa.

blocks|key|324345|text|考虑到并非所有Java开发人员都知道Java的这种行为，我创建了几个视频来解释Java中的Switch语句是如何工作的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|324346|在Java13-+https://www.youtube.com/watch?v=suFn87Irpb4中使用枚举-+https://www.youtube.com/watch?v=HlsPHEB_xz4|offset|length|324347|Switch和字符串-+https://www.youtube.com/watch?v=cg9O815FeWY|unordered-list-item|324348|
|324349|About+|324350|324351|和LookupSwitch+-https://www.youtube.com/watch?v=HlsPHEB_xz4|324352|324353|Switch表达式的|324354|开关|ordered-list-item|324355|324356|324357|324358|entityMap|0|LINK|mutability|MUTABLE|url|https://www.youtube.com/watch?v=suFn87Irpb4|1|https://www.youtube.com/watch?v=HlsPHEB_xz4|2|https://www.youtube.com/watch?v=cg9O815FeWY|3^0|0|9|17|0|1N|17|1|0|C|17|2|0|0|0|0|F|17|3|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@]|9|@$D|1D|E|1E|1|1F]|$D|1G|E|1H|1|1I]]|A|$]]|$1|F|3|G|5|H|7|1J|8|@]|9|@$D|1K|E|1L|1|1M]]|A|$]]|$1|I|3|J|5|6|7|1N|8|@]|9|@]|A|$]]|$1|K|3|L|5|H|7|1O|8|@]|9|@]|A|$]]|$1|M|3|J|5|6|7|1P|8|@]|9|@]|A|$]]|$1|N|3|O|5|H|7|1Q|8|@]|9|@$D|1R|E|1S|1|1T]]|A|$]]|$1|P|3|J|5|6|7|1U|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|1V|8|@]|9|@]|A|$]]|$1|S|3|T|5|U|7|1W|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|20|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|17]]|18|$5|11|12|13|A|$14|19]]|1A|$5|11|12|13|A|$14|17]]]]

Considering this behaviour of Java is not known to all Java developers, I created few videos explaining how Switch statements in Java works.

<ol>
<li>Switch with Enums - <a href="https://www.youtube.com/watch?v=HlsPHEB_xz4" rel="nofollow noreferrer">https://www.youtube.com/watch?v=HlsPHEB_xz4</a></li>
<li>Switch with Strings - <a href="https://www.youtube.com/watch?v=cg9O815FeWY" rel="nofollow noreferrer">https://www.youtube.com/watch?v=cg9O815FeWY</a></li>
<li>About TableSwitch and LookupSwitch - <a href="https://www.youtube.com/watch?v=OHwDczHbPcw" rel="nofollow noreferrer">https://www.youtube.com/watch?v=OHwDczHbPcw</a></li>
<li>Switch Expression in Java 13 - <a href="https://www.youtube.com/watch?v=suFn87Irpb4" rel="nofollow noreferrer">https://www.youtube.com/watch?v=suFn87Irpb4</a></li>
</ol>

This might not answer the question in a straight way. However, it does definitely answers how the switch statements in Java works.

I've noticed <code>enums</code> introduce many additional class files (Class$1) after compilation bloating the total size. It seems to be attached to every class that even uses an enum, and these are often duplicated.

Why does this occur and is there a way to prevent this without removing the enum.

(Reason for question is space is at a premium for me)

EDIT

On investigating the issue further, Sun's Javac 1.6 creates an additional synthetic class each time you use a switch on an Enum. It uses some kind of SwitchMap. <a href="http://jakeherringbone.com/2009/04/switchmap/" rel="noreferrer">This</a> site has some more information, and <a href="https://stackoverflow.com/questions/1163076/how-is-values-implemented-for-java-6-enums/1163121#1163121">here</a> tells you how to analyse what Javac is doing.

An additional physical file seems a high price to pay each time you use a switch on an enum!

Interestingly, Eclipe's compiler does not produce these additional files. I wonder if the only solution is to switch compilers?

Java enum and additional class files

编译器

Eclipse

Java

我注意到enums在编译后引入了许多额外的类文件( class $1)，使总大小膨胀。它似乎附加到甚至使用枚举的每个类，并且这些类通常是重复的。为什么会发生这种情况，有没有一种方法可以在不删除枚举的情况下防止这种情况。(提出问题的原因是空间对我来说很重要)编辑在进一步研究这个问题时，Sun Javac1.6在每次您在上...

问Java枚举和其他类文件
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java枚举和其他类文件EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java枚举和其他类文件
EN