Preciso algoritmo e montar um vetor de fila circular que mostre de 0 a 49

Programação Java
#1

Preciso montar um vetor de fila circular que mostre de 0 a 49 onde mostre que todas as posicoes ocupadas e se estourar a mostre alguma msg , alguém consegue me ajudar?

OBRIGADO!

#2

Ajudo… Com o que exatamente?
Posta o que você fez até agora.

#4

Uma fila circular não estoura, por isso ela se chama circular, pois quando chega no último elemento, o próximo será o primeiro.
Se a fila itera para o outro lado então quando chega no primeiro elemento, o próximo será o último.

Abaixo tem um exemplo de implementação de fila circular, talvez você precise adequar o código para a sua necessidade:

public class ExemploCircular {

	public static void main(String[] args) {
		try {
			ExemploCircular programa = new ExemploCircular();
			programa.executar();
		} catch (Throwable t) {
			t.printStackTrace();
		} finally {
			System.exit(0);
		}
	}

	private void executar() {
		CircularQueue<Integer> fila = new CircularQueue<>(50);
		System.out.println(fila);

		for (int numero = 1; numero <= 100; numero++) {
			fila.add(numero);
			System.out.println(fila);
		}
	}
}

Classe da fila circular em si:

// implementação de uma fila circular genérica
public class CircularQueue<T> {

	// constante para avançar uma posição
	private static final int NEXT = +1;

	// constante para retroceder uma posição
	private static final int PREVIOUS = -1;

	// capacidade da fila
	private final int size;

	// elementos da fila
	private final Object[] elements;

	// índice atual da fila
	private int index;

	// cria uma fila circular com a capacidade especificada pelo parâmetro size
	public CircularQueue(int size) {
		this.size = size;
		this.elements = new Object[size];
	}

	// adiciona o elemento no índice atual e incrementa o índice
	public T add(T element) {
		elements[index] = element;
		next();
		return element;
	}

	// move o índice para a primeira posição e retorna o elemento daquele índice
	public T first() {
		index = 0;
		return get(0);
	}

	// move o índice para a última posição e retorna o elemento daquele índice
	public T last() {
		index = size - 1;
		return get(index);
	}

	// move o índice para a próxima posição e retorna o elemento daquele índice
	public T next() {
		changeIndex(NEXT);
		return get(index);
	}

	// move o índice para a posição anterior e retorna o elemento daquele índice
	public T previous() {
		changeIndex(PREVIOUS);
		return get(index);
	}

	// remove o elemento do índice atual e retorna o elemento sem alterar o índice
	public T remove() {
		T element = get(index);
		elements[index] = null;
		return element;
	}

	// obtém uma representação textual da fila no seguinte formato
	// [elemento 1][elemento 2][elemento 3][elemento N]
	@Override
	public String toString() {
		StringBuilder text = new StringBuilder();
		for (Object element : elements) {
			text.append("[").append(element == null ? "" : element).append("]");
		}
		return text.toString();
	}

	// aqui acontece a magia da fila circular
	// perceba que não há if para verificar se chegou ao final
	// o operador % faz a mágica acontecer
	// se o parâmetro step for +1, a fila avança
	// se o parâmetro step for -1, a fila retrocede
	private void changeIndex(int step) {
		index = (index + size + step) % size;
	}

	// obtém o elemento da posição informada
	@SuppressWarnings("unchecked")
	private T get(int index) {
		return (T) elements[index];
	}
}
2 curtidas
#5

Muitoo obrigado pela orientacao.