Question

我有以下代码，我在课堂上经常使用这些代码。

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
        }
    }
}

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

我有什么方法可以创建一个辅助方法，所以我不必重复循环代码。

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

我希望能够声明变量动作并调用辅助方法。

感谢。

Answer 1

你可以做类似的事情（我不知道列表中的类型，我称之为元素）：

public interface ApplySomeAction
{
    public apply(Element e1, Element e2);
}

...

public void applyActionToAllElements(ApplySomeAction action)
{
    for (int i = 0; i < someList.size(); i++) {
       for (int j = 0; j < someList.size(); j++) {
           if (i != j) {
               action.apply(someList.get(i), someList.get(j));
           }
       }
    }
}

稍后用：

调用它

applyActionToAllElements(new ApplySomeAction() {
    public apply(Element e1, Element e2)
    {
        e1.sendMessageTo(e2));
    }
};

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

Answer 2

你可以通过这种方式摆脱其中一个循环：

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

使用@ NESPowerGlove的解决方案来抽象出所谓的方法。

Answer 3

我让我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 + "]");
    }
}

然后定义一个交互机制 - 使用Lambdas几乎是微不足道的：

// 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

重构嵌套循环

3 个答案: