blocks|key|1482636|text|在Java7中引入diamond+operator之前，可以使用用于创建泛型类型的静态工厂方法来减少重复类型参数的需要，从而减少冗长。(这是因为如果没有菱形运算符，Java永远不会在构造函数上推断类型参数，但它会在方法调用时推断类型参数。)+Google+Collections使用这种技术，因此您可以这样写：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1482637|Set<MyClassWithALongName>+set+=+Sets.newHashSet();|code-block|syntax|javascript|1482638|而不是：|1482639|Set<MyClassWithALongName>+set+=+new+HashSet<MyClassWithALongName>();|1482640|在Google+Collections的Lists、Sets和Maps类中查找以"new“开头的方法，以获得更多这样的示例。|style|CODE|1482641|除非您是在为旧版本的Java编写代码，否则从Java7开始，最好只使用菱形运算符。|1482642|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/4166966/what-is-the-point-of-the-diamond-operator-in-java-7|1|http://code.google.com/p/google-collections/^0|9|G|0|3D|I|1|0|0|0|0|K|5|Q|4|V|4|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]|$A|16|B|17|1|18]]|C|$]]|$1|D|3|E|5|F|7|19|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1A|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1B|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1C|8|@$A|1D|B|1E|O|P]|$A|1F|B|1G|O|P]|$A|1H|B|1I|O|P]]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]]]

Prior to the introduction of the <a href="https://stackoverflow.com/questions/4166966/what-is-the-point-of-the-diamond-operator-in-java-7">diamond operator</a> in Java 7, static factory methods for creating generic types could be used to reduce verbosity by reducing the need to repeat the type parameter. (This is because without the diamond operator, Java never infers the type parameter on constructors, but it will on methods calls.) <a href="http://code.google.com/p/google-collections/" rel="nofollow noreferrer">Google Collections</a> uses this technique, so you can write:

<pre><code>Set&lt;MyClassWithALongName&gt; set = Sets.newHashSet();
</code></pre>

instead of:

<pre><code>Set&lt;MyClassWithALongName&gt; set = new HashSet&lt;MyClassWithALongName&gt;();
</code></pre>

Look in the <code>Lists</code>, <code>Sets</code> and <code>Maps</code> classes of Google Collections for methods starting with "new" for more examples of this.

Unless you are writing for an old version of Java, as of Java 7 it is better to just use the diamond operator.

blocks|key|1268096|text|静态初始化器|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1268097|示例1(地图)：|1268098|Map<String,+String>+myMap+=+new+HashMap<String,+String>()+{{
++++put+("a",+"b");
++++put+("c",+"d");
}};|code-block|syntax|javascript|1268099|示例2(列表)：|1268100|List<String>+myList+=+new+ArrayList<String>()+{{
++++add("a");
++++add("b");
++++add("c");
}};|1268101|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Static initialisers

Example 1 (Map):

<pre><code>Map&lt;String, String&gt; myMap = new HashMap&lt;String, String&gt;() {{
 put ("a", "b");
 put ("c", "d");
}};
</code></pre>

Example 2(List):

<pre><code>List&lt;String&gt; myList = new ArrayList&lt;String&gt;() {{
 add("a");
 add("b");
 add("c");
}};
</code></pre>

blocks|key|1482762|text|我发现最多的(唯一？)编写简洁的java的有效方法是根本不编写java。在我需要快速编写与Java互操作的程序时，我发现Groovy是一个很好的选择。使用一种更简洁的语言，它仍然可以编译成JVM字节码，这可能是一个很好的解决方案。虽然我没有使用Scala的个人经验，但我听说在很多情况下Scala比Groovy更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1482763|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I've found that the most (only?) effective way to write concise java is to not write java at all. In cases where I needed to write something quickly that still interoperates with Java, I've found Groovy to be an excellent choice. Using a more concise language that still compiles to JVM bytecode can be an excellent solution. While I have no personal experiences with it, I've heard that Scala is an even better choice than Groovy in many cases.

blocks|key|1482787|text|查看lambdaj。它有许多功能，可以帮助您的代码更简洁和可读性更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1482788|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/p/lambdaj/^0|2|7|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Check out <a href="http://code.google.com/p/lambdaj/" rel="nofollow noreferrer">lambdaj</a>. It has lots of features that can help to make your code more concise and readable.

blocks|key|1482841|text|我发现一篇博客文章给出了一种有趣的技术，它允许用Java语言编写地图文字，就像你可以在Perl、Python、Ruby等中一样：Building+your+own+literals+in+Java+-+Tuples+and+Maps我真的很喜欢这种方法！我只在这里总结一下。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1482842|基本思想是创建一个泛型pair类，并定义构造对的静态函数，以及从varargs数组构造对的映射。这允许使用以下简明的map文字定义：|1482843|Map(o("height",+3),+o("width",+15),+o("weight",+27));|code-block|syntax|javascript|1482844|其中，o是用于构造一对T1和T2对象的静态函数的名称，对于任何对象类型T1和T2，Map是用于构造映射的静态函数的名称。我不确定我是否喜欢选择Map作为映射构造函数的名称，因为它与Java接口的名称相同，但概念仍然很好。|style|CODE|1482845|entityMap|0|LINK|mutability|MUTABLE|url|http://gleichmann.wordpress.com/2008/01/15/building-your-own-literals-in-java-tuples-and-maps/^0|1S|1G|0|0|0|0|3|1|15|3|1Z|3|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@$A|13|B|14|M|N]|$A|15|B|16|M|N]|$A|17|B|18|M|N]]|9|@]|C|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

I found a blog post giving an interesting technique which allows for writing a map literal in Java like you would be able to do in Perl, Python, Ruby, etc: <a href="http://gleichmann.wordpress.com/2008/01/15/building-your-own-literals-in-java-tuples-and-maps/" rel="nofollow noreferrer">Building your own literals in Java - Tuples and Maps</a>
I really like this approach! I'll just summarize it here.

The basic idea is to create a generic pair class and define static functions that will construct a pair, and a map from a varargs array of pairs. This allows the following concise map literal definition:

<pre><code>Map(o("height", 3), o("width", 15), o("weight", 27));
</code></pre>

Where <code>o</code> is the name of the static function to construct a pair of T1 and T2 objects, for any object types T1 and T2, and <code>Map</code> is the name of the static function to construct a Map. I'm not sure I like the choice of <code>Map</code> as the name of the map construction function because it is the same as the name of the Java interface, but the concept is still good.

blocks|key|1268288|text|初始化不可变映射(我发现这是一种比初始化可变映射更常见的情况)更好的方法是：ImmutableMap.of(...)+variants|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1268289|Map<Service,+Long>+timeouts+=+ImmutableMap.of(
++++orderService,+1500,+
++++itemService,+500);|code-block|syntax|javascript|1268290|entityMap|0|LINK|mutability|MUTABLE|url|http://guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/common/collect/ImmutableMap.html#of%2528K,%2520V,%2520K,%2520V,%2520K,%2520V,%2520K,%2520V%2529^0|12|T|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

More Guave goodness to initialize immutable maps (which I'm finding to be a way more common case than initializing mutable maps): the <a href="http://guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/common/collect/ImmutableMap.html#of%28K,%20V,%20K,%20V,%20K,%20V,%20K,%20V%29" rel="nofollow">ImmutableMap.of(...) variants</a>

<pre><code>Map&lt;Service, Long&gt; timeouts = ImmutableMap.of(
 orderService, 1500, 
 itemService, 500);
</code></pre>

blocks|key|1482895|text|是否曾经需要遍历一个集合，仅仅是为了通过它的一个属性来映射它的元素？没有了，多亏了Maps.uniqueIndex()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1482896|private+void+process(List<Module>+modules)+{

++++Map<String,+Module>+byName+=+Maps.uniqueIndex(modules,+new+Function<Module,+String>()+{
++++++++++++@Override+public+String+apply(Module+input)+{
++++++++++++++++return+input.getName();
++++++++++++}
++++++++});|code-block|syntax|javascript|1482897|或者，如果这种情况足够频繁，则将该函数设置为Module的public+static+final成员，以便将上述代码简化为：|1482898|++++Map<String,+Module>+byName+=+Maps.uniqueIndex(modules,+Module.KEY_FUNCTION);|1482899|entityMap|0|LINK|mutability|MUTABLE|url|http://guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/common/collect/Maps.html#uniqueIndex%2528java.lang.Iterable,%2520com.google.common.base.Function%2529^0|15|I|15|I|0|0|0|M|6|T|J|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

Ever have to iterate through a collection, just to map its elements by one of its properties? No more, thanks to <a href="http://guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/common/collect/Maps.html#uniqueIndex%28java.lang.Iterable,%20com.google.common.base.Function%29" rel="nofollow"><code>Maps.uniqueIndex()</code></a>:

<pre><code>private void process(List&lt;Module&gt; modules) {

 Map&lt;String, Module&gt; byName = Maps.uniqueIndex(modules, new Function&lt;Module, String&gt;() {
 @Override public String apply(Module input) {
 return input.getName();
 }
 });
</code></pre>

or if this is frequent enough, make the function a <code>public static final</code> member of <code>Module</code> so that the above is reduced to:

<pre><code> Map&lt;String, Module&gt; byName = Maps.uniqueIndex(modules, Module.KEY_FUNCTION);
</code></pre>

One of the things that can be a little annoying about Java is the amount of code you need to express concepts. I am a believer in the "less code is better" philosophy, and I'd like to know how I can write Java without being so frustratingly verbose. Recently, I read the <a href="https://stackoverflow.com/questions/15496/hidden-features-of-java">Hidden Features of Java</a> question and was introduced to using <a href="http://www.c2.com/cgi/wiki?DoubleBraceInitialization" rel="nofollow noreferrer">double-brace initialization</a> to simulate a List or Map literal. There are, of course, drawbacks to using this method, but it does allow you to do certain things with significantly fewer characters and (if you format it right) make the code a lot cleaner and clearer. I'm wondering if there aren't other clever tricks and lesser known language features which could make my code more concise.

I'd like to see answers with an explanation of the technique, the more verbose way which it replaces, and any potential drawbacks to using the technique.

What are good patterns / techniques to reduce verbosity of Java

Python

Java

Perl

Java有一点让人讨厌的一件事就是表达概念所需的代码量。我信奉“代码越少越好”的哲学，我想知道如何才能写出不那么冗长的Java。最近，我读到了问题，并被介绍使用来模拟列表或映射文字。当然，使用这种方法也有缺点，但它确实允许您用明显较少的字符来做某些事情，并且(如果格式正确)使代码更加整洁和清晰。我想知道是否有其他聪明的...

问有什么好的模式/技术可以减少Java的冗长
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有什么好的模式/技术可以减少Java的冗长EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有什么好的模式/技术可以减少Java的冗长
EN