缩短Java代码的语言技巧？

我目前正在重新发现Java（最近经常使用Ruby），并且我喜欢所有东西的编译时间检查。它使重构变得如此简单。但是，我怀念快速和松散地使用类型来执行

每个

循环。这是我最糟糕的代码

这是最短的吗？我有一个名为

looperTracks

的集合，其中有实现

Looper

的实例。我不想修改该集合，但我想遍历它的成员以及

this

（它还实现了

Looper

）

List allLoopers=new ArrayList（looperTracks.length+1）；
用于（LooperTrack轨迹：looperTracks）{
所有活套。添加（轨道）；
}
添加（此）；
for（活套活套：所有活套）{
//终于！我有活套了

我特别关注Java从1.5开始的新特性，我可能错过了这些特性。对于这个问题，我不是问JRuby或Groovy，尽管我知道它们可以解决这个问题

---

编辑：对不起（太多红宝石！）…

LooperTrack

属于

LooperTrack[]

类型，并且

LooperTrack

实现

Looper

至少有两种可能的内置方法可以缩短代码：

您可以使用它将集合中作为参数传递的每个元素追加到集合的末尾：

List<Looper> allLoopers = new ArrayList<Looper>();

...

allLoopers.addAll(looperTracks);
allLoopers.add(this);

for(Looper looper : allLoopers) {
  ...
}

List allLoopers=new ArrayList（）；
...
allLoopers.addAll（looperTracks）；
添加（此）；
for（活套活套：所有活套）{
...
}

或者可以使用将集合作为参数的构造函数：

List<Looper> allLoopers = new ArrayList<Looper>(looperTracks);

List allLoopers=new ArrayList（looperTracks）；

由于问题的变化：所有数组都可以使用

List someLooperTracks=Arrays.asList（looperTracks）。

---

这将把数组包装在一个固定大小的列表中。

您至少可以使用这样一个事实，即您可以使用另一个集合作为基值来构造一个集合。根据：

按照集合迭代器返回的顺序构造包含指定集合元素的列表。ArrayList实例的初始容量为指定集合大小的110%

这意味着在不必进行任何调整的情况下，可能会有空间容纳

此

List<Looper> allLoopers = new ArrayList<Looper>(looperTracks);
allLoopers.add(this);

for (Looper looper : allLoopers) {
    // Finally! I have a looper

List allLoopers=new ArrayList（looperTracks）；
添加（此）；
for（活套活套：所有活套）{
//终于！我有活套了

为什么不能将它们全部添加为构造函数调用的一部分

List<Looper> allLoopers = new ArrayList<Looper>(looperTracks);

allLoopers.add(this);

for(Looper looper : allLoopers) {
...
}

List allLoopers=new ArrayList（looperTracks）；
添加（此）；
for（活套活套：所有活套）{
...
}

根据键入的不同，您可以使用：

List<Looper> allLoopers = new ArrayList<Looper>(looperTracks);
allLoopers.add(this);

List allLoopers=new ArrayList（looperTracks）；
添加（此）；

或：

List allLoopers=new ArrayList（looperTracks.length+1）；
allLoopers.addAll（looperTracks）；
添加（此）；

我想你不能把它缩短到这个

for (Looper looper : new ArrayList<Looper>(looperTracks){{ add(EnclosingClass.this); }}) {
    // Finally! I have all loopers
}

for（Looper-Looper:newarraylist（looperTracks）{{add（enclosuringclass.this）；}}）{
//终于！我有了所有的活套
}

您可以使用

nCopies（）

方法尝试使用

公共静态列表nCopies（int n，to）

返回一个不可变的列表，该列表由 指定对象的n个副本。 新分配的数据对象是 极小（它包含一个引用） 此方法是 与 用于增长列表的List.addAll方法 返回的列表是可序列化的

---

这将避免第一个前缀迭代。

< P>因为您不想使用Groovy或JRube，因为它们的动态特性，应该考虑使用Scala。斯卡拉是静态类型的，但比java更简洁。

< P>我刚才实现了<强>迭代器<强> > <强> <强>（通过

Iterables.concat（Iterable…

）以更稳健/测试/审查的方式实施：

---

在您关心的情况下，实现是my（发布为LGPL3）的一部分。

是否要求您将所有内容组合到一个列表中？如果不是，这有什么问题

for (Looper looper : looperTracks) {
    doSomething(looper);
}
doSomething(this);

试一试

但是老实说，为什么不直接循环现有的数组，然后对

this

执行您想执行的任何操作呢

上述列表的

版本如下所示：

List<Looper> loop = new ArrayList<Looper>(Arrays.asList(looperTracks));
loop.add(this);
for (Looper l : loop) { ... }

List loop=newarraylist（Arrays.asList（looperTracks））；
循环。添加（此）；
for（Looper l:loop）{…}
让这变得非常简单：

for (Looper looper : ObjectArrays.concat(looperTracks, this)) {}

方法的文档是
ObjectArrays\concat
我只想把它扔出去，但不要试图以牺牲代码可读性为代价来缩短代码

当我开始编写代码时，可读代码始终是我的目标，因为我知道在将来的某个时候，我自己或其他人会看到它，并且必须理解它。
+1，我不确定你比我快了多少秒，但干得好！对不起，我把问题搞错了，LooperTrack是LooperTrack[]LooperTrack实现了Looper。复制一个列表只是为了能够为每个循环使用一个。这是一个糟糕的主意。在这种情况下，进行两步迭代并不坏。谢谢kgiannakakis，这是“担心”的一部分这绝对不是一个坏主意。如果它会降低性能到任何有问题的程度，这是一个坏主意。是否有特别的需要将此代码缩短？有时它会提高可读性，但过度编译的代码通常会降低可读性。由于我的一个错误，我更改了问题，但第一个答案肯定会起作用。很酷，感谢您的支持拿起问题中的更改。我也刚刚意识到：
List allLoopers=new ArrayList（Arrays.asList（looperTracks））；
您可以使用nCopies
// make a concatenation of iterables
public static <T> Iterable<T> $(final Iterable<T> first, final Iterable<T>... iterables) {
    List<Iterator<T>> allIterables = new LinkedList<Iterator<T>>();
    allIterables.add(first.iterator());

    for (Iterable<T> iterable : iterables) {
        allIterables.add(iterable.iterator());
    }

    final Iterator<Iterator<T>> iterators = allIterables.iterator();

    return new Iterable<T>() {

        @Override
        public Iterator<T> iterator() {
            return new Iterator<T>() {

                private Iterator<T> current = iterators.next();

                @Override
                public boolean hasNext() {
                    if (current.hasNext()) {
                        return true;
                    } else {
                        if (iterators.hasNext()) {
                            current = iterators.next();
                            return current.hasNext();
                        } else {
                            return false;
                        }
                    }
                }

                @Override
                public T next() {
                    return current.next();
                }

                @Override
                public void remove() {
                }
            };
        }
    };
}

for (Looper looper : $($(looperTracks), this)) {

}

for (Looper looper : looperTracks) {
    doSomething(looper);
}
doSomething(this);

Looper[] loop = new Looper[looperTracks.length + 1];
System.arraycopy(looperTracks, 0, loop, 0, looperTracks.length);
loop[looperTracks.length] = this;
for (Looper l : loop) { ... }

List<Looper> loop = new ArrayList<Looper>(Arrays.asList(looperTracks));
loop.add(this);
for (Looper l : loop) { ... }

for (Looper looper : ObjectArrays.concat(looperTracks, this)) {}