Conjuntos

Conjuntos.java

import java.util.Iterator;
import java.util.TreeSet;
import java.util.Scanner;

public class Conjunto {
	/**
	 * Conjunto de elementos Foi Escolhido TreeSet(Integer) devido a impossibilidade de duplicidade em 
	 * Collections to tipo Set, e TreeSet, devido a sua ordenação automática
	 */
	private TreeSet<Integer> elementos;
	//Limite mínimo do conjunto
	private int minimo;
	//Um nome para o conjunto
	private String label;
	//Define se o grupo é infinito
	private boolean infinito;

	/**
	 * Conjunto constructor
	 * Inicializa vazio, com label vazia, elemento mínimo 0 e não é infinito
	 */
	public Conjunto() {
		elementos = new TreeSet<Integer>();
		label = "";
		minimo = 0;
		infinito = false;
	}

	/**
	 * Conjunto constructor
	 * Inicializa vazio, com label definida no construtor, elemento mínimo 0 e não é infinito
	 */
	public Conjunto(String l) {
		elementos = new TreeSet<Integer>();
		label = l;
		minimo = 0;
		infinito = false;
	}

	/**
	 * Conjunto constructor
	 * Inicializa com os elementos, com label vazia, elemento mínimo 0 e não é infinito
	 */
	public Conjunto(String l, TreeSet<Integer> init) {
		//cria um conjunto vazio
		elementos = new TreeSet<Integer>();
		//adiciona os elementos iniciais
		elementos.addAll(init);
		label = l; 
		minimo = 0;
		infinito = false;
	}

	/**
	 * Conjunto constructor
	 * Inicializa vazio, com label vazia, elemento mínimo 0 e não é infinito
	 */
	public Conjunto(String l, Conjunto init) {
		//cria um conjunto vazio
		elementos = new TreeSet<Integer>();
		//adiciona os elementos iniciais
		this.addAll(init);
		label = l;
		minimo = 0;
		infinito = false;
	}

	/**
	 * Obtém os elementos do Conjunto
	 * @return os elementos desse conjunto
	 */
	public TreeSet<Integer> getElementos() {
		return this.elementos;
	}

	/**
	 * Adiciona elementos unitários ao conjunto
	 * @param elemento O elemento a ser adicionado
	 */
	public void add(int elemento) {
		elementos.add(elemento);
	}

	/**
	 * Adiciona vários elementos ao conjunto
	 * @param b Conjunto cujo elementos serão adicionados
	 */
	public void addAll(Conjunto b) {
		Iterator<Integer> it = b.getElementos().iterator();
		while(it.hasNext()) {
			elementos.add(it.next());
		}
	}

	/**
	 * Adiciona vários elementos ao conjunto
	 * @param b Conjunto cujo elementos serão adicionados
	 */
	public void addAll(TreeSet<Integer> b) {
		elementos.addAll(b);
	}

	/**
	 * Remove o elemento designado do conjunto
	 * @param elemento Elemento a ser removido
	 */
	public void remove(int elemento) {
		elementos.remove(elemento);
	}

	/**
	 * Verifica se o conjunto contém um elemento
	 * @param  elemento Elemento a ser verificado
	 * @return retorna true se o conjunto contém o elemento, false caso contrário
	 */
	public boolean contains(int elemento) {
		return elementos.contains(elemento);
	}

	/**
	 * Remove todos os elementos do conjunto
	 */
	public void clear() {
		elementos.clear();
	}

	/**
	 * Obtém o tamanho do conjunto
	 * @return o tamanho do conjunto
	 */
	public int tamanho() {
		return this.elementos.size();
	}

	/**
	 * Creates uma interface para obter os elementos do conjunto a partir da entrada do usuário
	 */
	public void init() {
		int valor;
		Scanner in = new Scanner(System.in);

		this.clear();
		do {
			System.out.print("Digite o elemento do conjunto " + label + " (maior ou igual a " + minimo + "): ");
			valor = in.nextInt();
			if(valor >= minimo) {
				this.add(valor);
			}
		} while(valor >= minimo);
		
	}

	/**
	 * Imprime o conteúdo atual do conjunto
	 */
	public void imprimir() {
		boolean first = true;
		Iterator iterator = elementos.iterator();

		System.out.print("{ ");

		while (iterator.hasNext()) {
			if(first) {
				System.out.print(iterator.next());
			} else {
				System.out.print(", " + iterator.next());
			}
			first = false;
		}

		if(infinito) {
			System.out.println(", ... }\n");
		} else {
			System.out.println(" }\n");
		}
	}

	/**
	 * Determina se o conjunto é infinito
	 * @param i novo valor para boolean infinito
	 */
	private void isInfinito(boolean i) {
		infinito = i;
	}

	/**
	 * Verifica se o conjunto é infinito
	 * @return true se é infinito, false caso contrário
	 */
	public boolean isInfinito() {
		return infinito;
	}

	/**
	 * Retona o conjunto como uma string
	 * @return valor(es) do conjunto como texto
	 */
	public String toString() {
		boolean first = true;
		Iterator iterator = elementos.iterator();
		String out = "";

		out += "{ ";

		while (iterator.hasNext()) {
			if(first) {
				out += iterator.next();
			} else {
				out += ", " + iterator.next();
			}
			first = false;
		}

		out += " }\n";
		return out;
	}


	/**
	 * Retorna o complemento do conjunto atual em relação ao conjunto Universo
	 * @param  extra Quantos elementos devem ser impressos a mais para demostrar que é um conjunto infinito
	 * @return       Conjunto complemento do conjunto instância
	 */
	public Conjunto complemento(int extra) {
		Conjunto temp = new Conjunto();
		int ceiling = this.elementos.last() + extra;

		for(int i = 1; i <= ceiling; i++) {
			if(!this.elementos.contains(i)) {
				temp.add(i);
			}
		}

		temp.isInfinito(true);

		return temp;
	}

	/**
	 * Retorna o complemento do conjunto atual em relação ao conjunto Universo
	 * @return       Conjunto complemento do conjunto instância
	 */
	public Conjunto complemento() {
		return complemento(10);
	}


	/**
	 * [complemento description]
	 * @param  b Conjunto a ser complementado
	 * @return   Conjunto complemento da instância em relação ao passado por parâmetro
	 */
	public Conjunto complemento(Conjunto b) {
		Conjunto temp = new Conjunto();
		Iterator<Integer> iteratorA = elementos.iterator();

		while(iteratorA.hasNext()) {
			int atual = iteratorA.next();
			if(!b.contains(atual)) {
				temp.add(atual);
			}
		}

		return temp;
	}


	/**
	 * Obtém a união de dois conjuntos
	 * @param  b Conjunto a ser unido
	 * @return   União dos conjuntos
	 */
	public Conjunto uniao(Conjunto b) {
		Conjunto temp = new Conjunto();
		temp.addAll(b);
		temp.addAll(elementos);
		return temp;
	}

	/**
	 * Obtém a intersecção de dois conjuntos
	 * @param  b Conjunto a ser interseccionado
	 * @return   Intersecção dos conjuntos
	 */
	public Conjunto interseccao(Conjunto b) {
		Conjunto temp = new Conjunto();
		Iterator<Integer> iteratorA = elementos.iterator();

		while(iteratorA.hasNext()) {
			int atual = iteratorA.next();
			if(b.contains(atual)) {
				temp.add(atual);
			}
		}

		return temp;
	}
}