Practica1

package Practica1;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class practica1 {

    public static void main(String[] args) {
    }

    /**
     *  Método que toma dos conjuntos de enteros y separa los elementos entre aquellos que sólo aparecen una vez
     *  y aquellos que aparecen repetidos. El método modifica los conjuntos que toma como parámetros.
     * @param unicos    A la entrada un conjunto de enteros. A la sálida los elementos que solo aparecen en uno de
     *                  los conjuntos.
     * @param repetidos A la entrada un conjunto de enteros. A la salida los elementos que aparecen en ambos conjuntos.
     */
    static public void separa(Set<String> unicos, Set<String> repetidos) {
        Set<String> v1 = new HashSet<>();
        v1.addAll(unicos);
        unicos.addAll(repetidos);
        repetidos.retainAll(v1);
        unicos.removeAll(repetidos);

    }

    /**
     *  Toma un iterador a una colección de enteros positivos y devuelve como resultado un conjunto con aquellos elementos
     *  de la colección que no son múltiplos de algún otro de la colección. Los ceros son descartados
     * @param iter  Iterador a una colección de enteros
     * @return Conjunto de de enteros.
     */
    static public Set <Integer> filtra(Iterator<Integer> iter) {
        Set<Integer> v1 = new HashSet<>();
        Iterator<Integer> iter2;
        boolean meter = false;
        while (iter.hasNext()){
            int num = iter.next();

            if (v1.size() == 0 && num != 0) {
                v1.add(num);
            } else {
                iter2 = v1.iterator();
                while (iter2.hasNext()) {
                    int num2 = iter2.next();
                    if ((num % num2 == 0) || (num2 % num == 0)) {
                        if (num < num2 && num > 0) {
                            meter = true;
                            v1.remove(num2);
                        }
                    }
                }
                if (meter) {
                    v1.add(num);
                }
            }
        }

        return v1;
    }

    /**
     * Toma una colección de conjuntos de <i>String</i> y devuelve como resultado un conjunto con aquellos <i>String </i>
     * Que aparecen en al menos dos conjuntos de la colección.
     * @param col Coleccion de conjuntos de <i>String</i>
     * @return Conjunto de <i>String</i> repetidos.
     */
    static public Set<String> repetidos(Collection<Set<String>> col) {
        Set<String> aux1 = new HashSet<>();
        Set<String> aux2 = new HashSet<>();

        for (Set<String> aCol : col){
            Set<String> colection = new HashSet<>(aCol);
            for (String elem : colection) {
                if (aux1.contains(elem)) {
                    aux2.add(elem);
                } else {
                    aux1.add(elem);
                }
            }
        }

        return aux2;
    }
}