1

我有两个 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 间单人间。

我需要将每个“双人房”与每个“单人房”关联起来，这是因为每个房间都有自己的特点，比如互联网、更宜人的景观等等。所以我需要给用户所有的组合让他选择。

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

4

8 回答 8

1

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

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

于 2009-05-26T15:25:50.837 回答
0

收藏品是否准确排列？

HashMap map = new HashMap();
for (int i=0; i<c1.Size(); i++) {
   map.put(c1[i], c2[i]);
}
于 2009-05-26T14:37:58.093 回答
0

好吧，因为我不知道你是否需要搜索它们只有一个，所以 HashMap 不起作用。

我会创建一个接收 Pair.. 的类：

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

并与他们一起创建一个列表。

于 2009-05-26T14:45:04.897 回答
0

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

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

然后让你这样做：

//收藏室

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

当然，这是假设它们是分层建模的。如果不是，那么这是不合适的，但是在我看来，您要问的问题实际上是如何对它们之间的关系进行建模，而您尚未明确说明。

于 2009-05-26T14:52:33.557 回答
0

我假设：

  • 1 中的每个元素将匹配2collection中的单个元素 collection
  • 集合具有相同的大小
  • 集合可以排序，并且顺序匹配两个集合中的每个元素
  1. 按标识每个对象的属性对两个集合进行排序（以相同的顺序）。
  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);
    }
}
于 2009-05-26T14:54:54.817 回答
0

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

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

于 2009-05-26T14:59:00.767 回答
0

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

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;
于 2009-05-26T15:13:23.890 回答
-1

这是一个常见的问题。它被称为笛卡尔积。如果您有两个像您这样的集合，我会毫不犹豫地拥有两个嵌套循环。否则，请参阅此问题。

于 2009-05-26T15:20:10.973 回答