Comment associez-vous l'article de chaque collection à l'autre ses?

Question

J'ai deux objets de collection, je veux associer chaque objet de ces deux d'une manière lisible (HashMap, objet créé exprès, vous choisissez).

Je pensais à deux boucles imbriquées l'une dans l'autre, mais peut-être c'est un problème bien connu et a une solution communément compréhensible ...

Et si le nombre d'objets de collection soulève au-dessus de deux?

EDIT après commentaire Joseph Daigle: Les objets des objets de collection sont tous du même type, ils sont des chambres d'hôtels trouvés être réserver dans certaines conditions

.

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

EDIT 2: Je vais essayer d'expliquer mieux, désolé pour la question étant peu claire. Suit un exemple: Un utilisateur demande un double et une chambre simple. L'hôtel dispose de 3 chambres doubles et 4 simples disponibles.

Je dois associer chaque « chambre double » à chaque « chambre individuelle », c'est parce que chaque chambre a sa propre particularité dire Internet, une vue plus agréable, et ainsi de suite. Donc, je dois donner à l'utilisateur toutes les combinaisons qui lui permettent de choisir.

Ceci est le cas simple, dans lequel seulement deux collection d'objets Chambre sont impliqués, comment gérez-vous le problème quand dire à la fois hôtel et l'utilisateur peuvent offrir / demander plus de types de chambres?

Answer 1

Qu'est-ce que vous essayez de faire ici est d'obtenir toutes les permutations possibles de choisir X à partir d'un ensemble de Y. Ceci est un problème bien connu en mathématiques discrètes et je pense qu'il est simplement appelé combinatoires Mathématiques.

Pour résoudre votre problème, vous devez créer un super collection contenant tous vos types de chambres. Si cela est un tableau ou une liste que vous pouvez ensuite utiliser cet exemple pour calculer possible façons de choisir X de l'ensemble de Y. l'exemple vous donnera les indices de la liste / tableau.

Answer 2

Est-ce que les collections alignent exactement?

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

Answer 3

Eh bien, puisque je ne sais pas si vous devez chercher pour les deux d'entre eux ayant une seule, le HashMap ne fonctionnera pas.

Je voudrais créer une classe qui reçoit une paire .. sorte de:

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

Et créer une liste avec eux.

Answer 4

Votre exemple implique que la valeur de retour de « roomsFromB » est une sous-collection de la valeur de retour de « roomsFromA », de sorte qu'il serait plus naturel de ce modèle de cette façon:

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

qui vous permettra de le faire:

// pièces de la collection

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

Cela suppose qu'ils modélisés hiérarchiquement, bien sûr. Si elles ne sont pas alors c'est inappropriée, mais la question que vous vous demandez, il me semble, est vraiment comment modéliser la relation entre eux, et vous ne l'avez pas encore fait que explicite.

Answer 5

Vous pourriez revenir si vous avez besoin exactement cette logique. Vous introduisez un O (n ^ 2) le fonctionnement, ce qui peut rapidement sortir de la main. (Techniquement O (mn), mais je suppose que m et n sont à peu près le même ordre.)

Y at-il une autre solution à votre problème? Peut-être que vous pourriez créer un « ensemble » qui comprend tous A et B tous, et chaque objet A et B pourrait pointer vers cet ensemble, au lieu?

Answer 6

Je suppose que:

• Chaque élément de collection 1 sera correspondre à un seul élément dans collection 2
• Les collections ont la même taille
• Les collections peuvent être commandés et l'ordre correspondant à chaque élément de les deux collections

---

1. Commander des collections (dans la même ordre) par la propriété que identifie chaque objet.
2. itérer les deux collections avec une seule boucle, construire un objet relation et l'ajouter dans une nouvelle collection.

Voyez si cela vous aide:

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 7

Votre question est tout à fait claire. Si je comprends bien, vous voulez énumérer toutes les combinaisons de pièces, moins les doublons. Ici nous un code pour construire un tableau 2D de toutes les combinaisons des chambres. Pour plus de types de chambre, dans une autre boucle mettre imbriqué.

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

Il est un problème commun. Il est appelé un produit cartésien. Si vous avez deux collections comme dans votre cas, je ne serais pas hésiter à avoir deux boucles imbriquées. Dans le cas contraire, voir cette question.