Java 重构嵌套循环

我有下面的代码，我在课堂上用了很多次

for (int i = 0; i < someList.size(); i++) {
    for (int j = 0; j < someList.size(); j++) {
        if (i != j) {
            someList.get(i).sendMessageTo(someList.get(j))); //variable action
        }
    }
}

for（int i=0；i

循环的目的是使列表中的每个元素向列表中除自身之外的每个元素发送消息（或执行另一个操作）

有没有办法创建一个helper方法，这样我就不必重复循环代码了

编辑： 我只需要一个助手方法来处理for循环和if算法。我将提供列表和我需要使用的任何操作。它应该适用于所有人

我希望能够声明变量操作并调用helper方法

---

谢谢。

您可以这样做（我不知道列表中是什么类型，我称之为元素）：

---

如果您经常只使用其中一个元素执行操作，则可以使用其中一个元素创建另一个interface+方法。

您可以通过以下方式摆脱其中一个循环：

for (int i = 0; i < someList.size() - 1; i++) {
    someList.get(i).sendMessageTo(someList.get(i + 1))); //variable action
}

for（int i=0；i

---

并使用@nespowerglood的解决方案来抽象所调用的方法。

我会使我成为一个

Iterable

/**
 * Returns all pairs of the list except those where i == j.
 * @param <T> 
 */
public class AllPairs<T> implements Iterable<Pair<T, T>> {
    // The list.
    private final List<T> list;

    public AllPairs(List<T> list) {
        this.list = list;
    }

    @Override
    public Iterator<Pair<T, T>> iterator() {
        return new PairIterator();
    }

    private class PairIterator implements Iterator<Pair<T, T>> {
        // The indexes.
        int i = 0;
        int j = 0;
        // The next to return.
        Pair<T, T> next = null;
        // Easier to read.
        int size = list.size();

        @Override
        public boolean hasNext() {
            while (next == null && (i < size || j < size)) {
                // Step j.
                j += 1;
                // Wrap j.
                if (j >= size && i < size) {
                    j = 0;
                    i += 1;
                }
                if (i < size && j < size && j != i) {
                    // Grab it.
                    next = new Pair<>(list.get(i), list.get(j));
                }
            }
            return next != null;
        }

        @Override
        public Pair<T, T> next() {
            Pair<T, T> it = next;
            next = null;
            return it;
        }
    }

}

/**
 * A simple Pair
 */
public static class Pair<P, Q> {

    public final P p;
    public final Q q;

    public Pair(P p, Q q) {
        this.p = p;
        this.q = q;
    }
}

public void test() {
    System.out.println("Hello");
    List<Integer> l = Arrays.asList(0, 1, 2, 3);
    for (Pair<Integer, Integer> p : new AllPairs<>(l)) {
        System.out.println("[" + p.p + "," + p.q + "]");
    }
}

---

做这件事的一个非常糟糕的方法可能是将枚举用于另一层间接寻址（我甚至不能100%确定这是否可行），但我觉得一定有更好的方法…

do

恰好是一个保留字；通常会选择

apply

。如果将该

do

重命名为

doer

，也会将调用更新为

doer.apply（…）

。在Java8中，可以改用闭包。

for (int i = 0; i < someList.size() - 1; i++) {
    someList.get(i).sendMessageTo(someList.get(i + 1))); //variable action
}

/**
 * Returns all pairs of the list except those where i == j.
 * @param <T> 
 */
public class AllPairs<T> implements Iterable<Pair<T, T>> {
    // The list.
    private final List<T> list;

    public AllPairs(List<T> list) {
        this.list = list;
    }

    @Override
    public Iterator<Pair<T, T>> iterator() {
        return new PairIterator();
    }

    private class PairIterator implements Iterator<Pair<T, T>> {
        // The indexes.
        int i = 0;
        int j = 0;
        // The next to return.
        Pair<T, T> next = null;
        // Easier to read.
        int size = list.size();

        @Override
        public boolean hasNext() {
            while (next == null && (i < size || j < size)) {
                // Step j.
                j += 1;
                // Wrap j.
                if (j >= size && i < size) {
                    j = 0;
                    i += 1;
                }
                if (i < size && j < size && j != i) {
                    // Grab it.
                    next = new Pair<>(list.get(i), list.get(j));
                }
            }
            return next != null;
        }

        @Override
        public Pair<T, T> next() {
            Pair<T, T> it = next;
            next = null;
            return it;
        }
    }

}

/**
 * A simple Pair
 */
public static class Pair<P, Q> {

    public final P p;
    public final Q q;

    public Pair(P p, Q q) {
        this.p = p;
        this.q = q;
    }
}

public void test() {
    System.out.println("Hello");
    List<Integer> l = Arrays.asList(0, 1, 2, 3);
    for (Pair<Integer, Integer> p : new AllPairs<>(l)) {
        System.out.println("[" + p.p + "," + p.q + "]");
    }
}

// Objects that can interact with each other.
public interface Interacts<T extends Interacts<T>> {

    public void interact(T with);
}

public static <T extends Interacts<T>> void interactAllPairs(List<T> l) {
    // Interact all pairs.
    for (Pair<T, T> p : new AllPairs<>(l)) {
        p.p.interact(p.q);
    }
}

// Interact by sending a message.
public class Messenger implements Interacts<Messenger> {

    private final int me;

    public Messenger(int me) {
        this.me = me;
    }

    @Override
    public void interact(Messenger with) {
        sendMessage(with);
    }

    public void sendMessage(Messenger to) {
        System.out.println(this + "->" + to);
    }

    @Override
    public String toString() {
        return Integer.toString(me);
    }
}

public void test() {
    // Meassage list.
    List<Messenger> messages = new ArrayList<>();
    for (int i = 0; i < 4; i++) {
        messages.add(new Messenger(i));
    }
    interactAllPairs(messages);
}

0->1
0->2
0->3
1->0
1->2
1->3
2->0
2->1
2->3
3->0
3->1
3->2