Java 如何关联每个集合'；s项转换为另一项'；s

我有两个Collection对象，我想以可读的方式将这两个对象中的每个对象关联起来（HashMap，故意创建的对象，由您选择）

我在考虑两个循环，一个嵌套在另一个中，但可能这是一个众所周知的问题，并且有一个通常可以理解的解决方案

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

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

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

Collection roomsFromA=getRoomsFromA（）；
Collection roomsFromB=getRoomsFromB（）；
（房间A:RoomsFloma）{
用于（房间B:roomsFromB）{
//将roomA和roomB添加到某些内容中，这对于我需要的内容并不重要
//重要的是你如何处理之前的部分
//特别是当集合对象数量超过两个时
}
}

编辑2：我会尽量解释得更好，对不起，问题不清楚。 下面是一个例子： 用户请求双人房和单人房。 酒店有3间双人房和4间单人房

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

---

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

收藏是否准确排列

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

HashMap map=newhashmap（）；
对于（inti=0；i嗯，因为我不知道是否需要搜索两个只有一个的对象，所以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;
    }
} 

私有静态类对{
私人K-one；
二等兵；
公共对（K1，T2）{
这个1=1；
这个2=2；
}
/**
*@返回一个
*/
公共K getOne（）{
返回一个；
}
/**
*@返回两个
*/
公共T getTwo（）{
返回两个；
}
} 

然后用它们创建一个列表。
您的示例意味着“roomsFromB”的返回值是“roomsFromA”返回值的一个子集合，因此用这种方式建模更自然：

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

当然，这是假设它们是按层次进行建模的。如果它们不是，那么这是不合适的，但在我看来，你要问的问题实际上是如何对它们之间的关系进行建模，而你还没有明确说明这一点。
我假设：


集合中的每个元素将
匹配中的单个元素
收藏
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);
    }
}

公共静态教室{
私有整数；
私有字符串名称；
公共房间（整数、字符串名称）{
超级（）；
这个数字=数字；
this.name=名称；
}
public int getNumber（）{
返回号码；
}
公共字符串getName（）{
返回名称；
}
}
公共静态类关系{
私人房间a；
包房b；
公共客房关系（a室、b室）{
超级（）；
这个a=a；
这个.b=b；
}
公共休息室{
返回a；
}
公共休息室{
返回b；
}
@凌驾
公共字符串toString（）{
返回a.getName（）+“（“+a.getNumber（）+”）+b.getName（）+“（“+b.getNumber（）+”）”；
}
}
公共静态void main（字符串[]args）{
List roomsFromA=新建ArrayList（）；
List roomsFromB=新建ArrayList（）；
添加（新房间（1，“A房间”）；
添加（新房间（2，“A房间”）；
roomsFromB.添加（新房间（1，“B房间”）；
roomsFromB.添加（新房间（2，“B房间”）；
比较器c=新比较器（）{
@凌驾
公共int比较（o1室、o2室）{
返回o1.getNumber（）-o2.getNumber（）；
} };
收藏。分类（roomsFromA，c）；
集合。排序（roomsFromB，c）；
列表关系=新的ArrayList（）；
对于（int i=0；i
您可能会重新考虑是否需要这个逻辑。您正在引入一个O（n^2）操作，它很快就会失控。（从技术上讲是O（mn），但我猜m和n的顺序大致相同。）

您的问题还有其他解决方案吗？也许您可以创建一个包含所有a和B的“集合”，然后a和B中的每个对象都可以指向这个集合？
您的问题很不清楚。据我所知，您希望列出所有房间的组合，减去重复的房间。下面是一些代码，用于构建所有房间的2d数组e房间组合。对于更多类型的房间，请放入另一个嵌套循环

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;

Collection roomsFromA=getRoomsFromA（）；
Collection roomsFromB=getRoomsFromB（）；
房间[][]组合=新房间[roomsFromB.size（）][roomsFromB.size（）]；
int a=0；
int b=0；
（房间A:RoomsFloma）{
用于（房间B:roomsFromB）{
组合[a][b]=[roomA][roomB]；//构建阵列
b++；
}
a++；
}
收益组合；
这是一个常见的问题。它被称为a。如果您有两个像您这样的集合，我会毫不犹豫地使用两个嵌套循环。否则，请参阅。
您在这里尝试的是获取所有的pos
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;