我第二Nat的答案，除了我将使用一个循环，而不是创建并立即从asList(elements)中抛出隐式列表:

static public Set<T> setOf(T ... elements) {
    Set set=new HashSet<T>(elements.size());
    for(T elm: elements) { set.add(elm); }
    return set;
    }

我正在研究这个问题，并决定做一个比有效答案提供的更深入的测试。

代码如下:https://gist.github.com/4368924

这就是我的结论

I was surprised to find that in most of the run tests the internal initiation was actually faster (almost double in some cases). When working with large numbers the benefit seems to fade away. Interestingly, the case that creates 3 objects on the loop loses it's benefit rans out sooner than on the other cases. I am not sure why this is happening and more testing should be done to reach any conclusions. Creating concrete implementations may help to avoid the class definition to be reloaded (if that's what's happening) However, it is clear that not much overhead it observed in most cases for the single item building, even with large numbers. One set back would be the fact that each of the double brace initiations creates a new class file that adds a whole disk block to the size of our application (or about 1k when compressed). A small footprint, but if it's used in many places it could potentially have an impact. Use this 1000 times and you are potentially adding a whole MiB to you applicaiton, which may be concerning on an embedded environment. My conclusion? It can be ok to use as long as it is not abused.

让我知道你的想法:)

撇开效率不谈，我发现自己很少希望在单元测试之外创建声明式集合。我相信双大括号语法是非常可读的。

实现列表的声明式构造的另一种方法是使用数组。asList(T…)像这样:

List<String> aList = Arrays.asList("vanilla", "strawberry", "chocolate");

当然，这种方法的局限性在于您不能控制要生成的列表的特定类型。

虽然这种语法很方便，但它也添加了大量的$0引用，因为这些引用是嵌套的，并且很难对初始化器进行步进调试，除非在每个初始化器上设置断点。出于这个原因，我只建议在普通的设置器，特别是设置为常量，以及匿名子类无关紧要的地方使用这个方法(比如不涉及序列化)。

这将为每个成员调用add()。如果你能找到一种更有效的方法将项放入散列集中，那么就使用它。注意，内部类可能会生成垃圾，如果您对此很敏感的话。 在我看来，上下文似乎是new返回的对象，也就是HashSet。 如果你需要问…更有可能的是:在你之后的人会知道这一点吗?它容易理解和解释吗?如果两个问题你都能回答“是”，那就随便用吧。

There's generally nothing particularly inefficient about it. It doesn't generally matter to the JVM that you've made a subclass and added a constructor to it-- that's a normal, everyday thing to do in an object-oriented language. I can think of quite contrived cases where you could cause an inefficiency by doing this (e.g. you have a repeatedly-called method that ends up taking a mixture of different classes because of this subclass, whereas ordinary the class passed in would be totally predictable-- in the latter case, the JIT compiler could make optimisations that are not feasible in the first). But really, I think the cases where it'll matter are very contrived.

我更倾向于从你是否想用大量的匿名类“把事情弄得乱七八糟”的角度来看待这个问题。作为一个粗略的指南，可以考虑使用这个习惯用法，就像使用匿名类作为事件处理程序一样。

在(2)中，您处于对象的构造函数内部，因此“this”指的是您正在构造的对象。这和其他构造函数没有什么不同。

As for (3), that really depends on who's maintaining your code, I guess. If you don't know this in advance, then a benchmark that I would suggest using is "do you see this in the source code to the JDK?" (in this case, I don't recall seeing many anonymous initialisers, and certainly not in cases where that's the only content of the anonymous class). In most moderately sized projects, I'd argue you're really going to need your programmers to understand the JDK source at some point or other, so any syntax or idiom used there is "fair game". Beyond that, I'd say, train people on that syntax if you have control of who's maintaining the code, else comment or avoid.