Question

我有两个Collection对象，我想以可读的方式关联这两个对象（HashMap，有意创建的对象，你选择）。

我想到了两个嵌套在另一个循环中的循环，但也许这是一个众所周知的问题，并且有一个通常可以理解的解决方案......

如果Collection对象的数量增加到两个以上怎么办？

Joseph Daigle评论后编辑：Collection对象的项目都是相同的类型，它们是在某些条件下可以预订的酒店房间。

Collection<Room> roomsFromA = getRoomsFromA();
Collection<Room> roomsFromB = getRoomsFromB();
for(Room roomA : roomsFromA){
    for(Room roomB : roomsFromB){
        //add roomA and roomB to something, this is not important for what I need
        //the important part is how you handle the part before
        //especially if Collection objects number grows beyond two
    }
}

编辑2：我会尝试更好地解释，抱歉这个问题不清楚。举个例子：用户请求双人房和单人房。酒店设有3间双人间和4间单人间。

我需要将每个“双人间”与每个“单人间”联系起来，这是因为每个房间都有自己的特色，比如说互联网，更愉快的看法，等等。所以我需要给用户所有组合让他选择。

这是一个简单的案例，其中只涉及两个Room of Room对象，当酒店和用户可以提供/请求更多房间类型时，如何管理问题？

Answer 1

你在这里要做的是获得从一组Y中选择X的所有可能的排列。这是离散数学中众所周知的问题，我认为它只是被称为组合数学。

要解决您的问题，您需要创建一个包含所有房间类型的超级集合。如果这是一个数组或一个List，那么你可以使用this example计算从Y的集合中选择X的所有可能方法。该例子将为您提供列表/数组中的索引。

Answer 2

集合是否完全排列？

HashMap map = new HashMap();
for (int i=0; i<c1.Size(); i++) {
   map.put(c1[i], c2[i]);
}

Answer 3

好吧，既然我不知道你是否需要搜索只有一个的HashMap，那么HashMap将不起作用。

我会创建一个接收一对的类......排序：

private static class Pair<K, T> {
    private K one;
    private T two;

    public Pair(K one, T two) {
        this.one = one;
        this.two = two;
    }

    /**
     * @return the one
     */
    public K getOne() {
        return one;
    }

    /**
     * @return the two
     */
    public T getTwo() {
        return two;
    }
}

用它们创建一个List。

Answer 4

您的示例暗示“roomsFromB”的返回值是“roomsFromA”的返回值的子集合，因此以这种方式对其进行建模更为自然：

class Room {
   public Collection<Room> getRoomsFromB { ... 
}

然后会让你这样做：

//收集房间

for (Room a: rooms)
{ 
   for(Room b a.getRoomsFromB){ ...

这假设他们当然是按层次结构建模的。如果他们不是那么这是不合适的，但是在我看来，你问的问题实际上是如何模拟他们之间的关系，你还没有明确表达。

Answer 5

我认为：

collection 1中的每个元素都会匹配单个元素 collection 2
收藏品也一样大小
可以订购收藏品订单匹配中的每个元素两个集合

订购两个系列（同一个订购）由财产识别每个对象。
使用单个循环遍历两个集合，构建关系对象并将其添加到新集合中。

看看这是否对您有所帮助：

public static class Room {
    private int number;
    private String name;

    public Room(int number, String name) {
        super();
        this.number = number;
        this.name = name;
    }

    public int getNumber() {
        return number;
    }

    public String getName() {
        return name;
    }
}

public static class RoomRelation {
    private Room a;
    private Room b;

    public RoomRelation(Room a, Room b) {
        super();
        this.a = a;
        this.b = b;
    }

    public Room getA() {
        return a;
    }

    public Room getB() {
        return b;
    }

    @Override
    public String toString() {
        return a.getName() + "(" + a.getNumber() + ") " + b.getName() + "(" + b.getNumber() + ")";
    }
}

public static void main(String[] args) {

    List<Room> roomsFromA = new ArrayList<Room>();
    List<Room> roomsFromB = new ArrayList<Room>();

    roomsFromA.add(new Room(1,"Room A"));
    roomsFromA.add(new Room(2,"Room A"));

    roomsFromB.add(new Room(1,"Room B"));
    roomsFromB.add(new Room(2,"Room B"));

    Comparator<Room> c = new Comparator<Room>() {
        @Override
        public int compare(Room o1, Room o2) {
            return o1.getNumber() - o2.getNumber();
        } };

    Collections.sort(roomsFromA, c);
    Collections.sort(roomsFromB, c);

    List<RoomRelation> relations = new ArrayList<RoomRelation>();

    for (int i = 0; i < roomsFromA.size(); i++) {
        relations.add(new RoomRelation(roomsFromA.get(i), roomsFromB.get(i)));
    }

    for (RoomRelation roomRelation : relations) {
        System.out.println(roomRelation);
    }
}

Answer 6

您可能会重新考虑是否需要这种逻辑。你正在引入一个O（n ^ 2）操作，它很快就会失控。（技术上是O（mn），但我猜m和n的顺序大致相同。）

您的问题还有其他解决方案吗？也许你可以创建一个包含A和B全部的“集合”，然后A和B中的每个对象都可以指向这个集合，而不是？

Answer 7

你的问题很不清楚。据我所知，你想要列出所有房间组合，减去重复。这里有一些代码来构建所有房间组合的二维数组。对于更多类型的房间，请放入另一个嵌套循环。

Collection<Room> roomsFromA = getRoomsFromA();
Collection<Room> roomsFromB = getRoomsFromB();

Room[][] combinations = new Room[roomsFromA .size()][roomsFromB .size()];

int a = 0;
int b = 0;

for(Room roomA : roomsFromA){

   for(Room roomB : roomsFromB){
      combinations [a][b] = [roomA][roomB]; //Build up array
      b++; 
   }
   a++;
}

return combinations;

Answer 8

这是一个常见问题。它被称为Cartesian product。如果你有两个像你的情况一样的集合，我会毫不犹豫地有两个嵌套循环。否则，请参阅this question。

如何将每个Collection的项目与另一个项目相关联？

8 个答案: