Come si associa un oggetto da ogni collezione ad un altro di?

Question

Ho due oggetti Collection, voglio associare ogni oggetto di questi due in modo leggibile (HashMap, oggetto creato apposta, si sceglie).

stavo pensando di due anelli uno annidato dentro l'altro, ma forse è un problema ben noto e ha una soluzione comunemente comprensibile ...

Che cosa succede se il numero di oggetti Collection eleva al di sopra di due?

EDIT dopo che Joseph Daigle commento: Le voci degli oggetti Collection sono tutti dello stesso tipo, che sono camere di alberghi trovati a essere prenotabile in certe condizioni

.

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: Cercherò di spiegare meglio, mi dispiace per la domanda di essere poco chiara. Segue un esempio: Un utente richiede per una doppia e una camera singola. L'hotel dispone di 3 doppie e 4 camere singole disponibili.

Ho bisogno di associare ogni "camera doppia" per ogni "stanza singola", questo perché ogni camera ha la sua particolarità dire internet, più piacevole vista, e così via. Così ho bisogno di dare all'utente tutte le combinazioni per fargli scegliere.

Questo è il caso semplice, in cui sono coinvolti solo due Raccolta di oggetti di camera, come si fa a gestire il problema quando dicono che sia la struttura e l'utente può offrire / richiedere altri tipi di camere?

Answer 1

Quello che si sta cercando di fare qui è quello di ottenere tutte le possibili permutazioni di scegliere X da un insieme di Y. Questo è un problema ben noto in matematica discreta e penso che è appena chiamato combinatorie Matematica.

Per risolvere il problema è necessario creare una super raccolta che contiene tutti i tipi di camere. Se questo è un array o un elenco è quindi possibile utilizzare questo esempio per calcolare tutte le possibili modi di scegliere X dal set di Y. l'esempio vi darà gli indici dalla lista / matrice.

Answer 2

fare le collezioni allineano esattamente?

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

Answer 3

Bene, visto che non so se è necessario per la ricerca di entrambi avere un solo, il HashMap non funzionerà.

Vorrei creare una classe che riceve un paio .. sorta di:

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

e creare un elenco con loro.

Answer 4

Il vostro esempio implica che il valore di ritorno da "roomsFromB" è un sottoinsieme del valore di ritorno di "roomsFromA", quindi sarebbe più naturale per modellare in questo modo:

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

che poi permetterà di fare:

// camere Collection

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

Questo è supponendo che stanno modellato gerarchicamente, naturalmente. Se non sono, allora questo non è appropriato, ma allora la domanda che stai chiedendo, mi sembra, è davvero come modellare il rapporto tra loro, e non hai ancora fatto che esplicito.

Answer 5

Si potrebbe riconsiderare se avete bisogno di esattamente questa logica. Si sta introducendo un O (n ^ 2) il funzionamento, in grado di ottenere rapidamente di mano. (Tecnicamente O (mn), ma sto cercando di indovinare m e n sono più o meno nello stesso ordine.)

C'è un'altra soluzione al vostro problema? Forse si potrebbe creare un 'set' che include tutti A e tutta la B, e poi ogni oggetto in A e B potrebbe puntare a questo insieme, invece?

Answer 6

Si considera che:

• Ogni elemento collection 1 sarà corrispondere un singolo elemento collection 2
• Le collezioni hanno la stessa dimensione
• Le collezioni possono essere ordinati e l'ordine corrisponde a ogni elemento in entrambe le collezioni

---

1. Ordinare entrambe le collezioni (nello stesso ordine) dalla proprietà che identifica ciascun oggetto.
2. Scorrere entrambe le collezioni con un singolo ciclo, costruire un oggetto di relazione e aggiungerlo in una nuova collezione.

Vedere se questo ti aiuta:

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

La tua domanda è abbastanza chiara. Mi pare di capire che si desidera elencare tutte le combinazioni di camere, meno duplicati. noi qui qualche codice per costruire una matrice 2D di tutte le combinazioni camera. Per più tipi di camera, messo in un altro ciclo nidificato.

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

Si tratta di un problema comune. Si chiama un cartesiana prodotto . Se si dispone di due collezioni, come nel tuo caso, non esiterei ad avere due cicli annidati. In caso contrario, vedere questa domanda .