[Resolvido]Ordenação lista em java

18 de março de 2020 5 respostas Resolvido

jhonvirtuoso 18 de março de 2020

Boa tarde,

Preciso fazer uma ordenação em java de uma lista, nessa ordem:

Prioridade, entrada, tamanho.

Problema é que quando a prioridade for a mesma, o próximo a verificar seria a entrada, segue abaixo meu o programa, não consigo fazer mais nada.

Obs: Preciso que a saida esteja em ordem.

package filadeprocessos;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class FilaDeProcessos {
	
	public static void main(String[] args) {
		Scanner escreva = new Scanner(System.in);
		
		int N, entrada;
		ArrayList entrada1, tamanho, prioridade, processo;
		
		System.out.println("Quantos processos deseja armazenar? ");
		N = escreva.nextInt();
		
		entrada1 = new ArrayList();
		tamanho = new ArrayList();
		prioridade = new ArrayList();
		processo = new ArrayList();
		
		for(int i = 0; i < N; i++){
			processo.add(i+1);
			
			System.out.println("Qual a entrada do processo " + (i+1) +"?");
			entrada = escreva.nextInt();
			entrada1.add(entrada);
			
			System.out.println("Qual a prioridade do processo " + (i+1) +"?");
			entrada = escreva.nextInt();
			prioridade.add(entrada);
			
			System.out.println("Qual o tamanho do processo " + (i+1) +"?");
			entrada = escreva.nextInt();
			tamanho.add(entrada);
		}
	}
}

5 Respostas

Lucas_Camara 18 de mar. de 2020

Nesse caso, o ideal seria vc criar uma classe para representar um Processo, e essa classe ter os atributos do processo:

numero (número do processo)
prioridade
tamanho
entrada (não entendi o que é essa entrada. Entrada pode ser qualquer coisa)

Com isso, vc irá montar (com base nos valores obtidos do scanner) uma lista de Processos:

List<Processo> processos = new ArrayList<>();

Com essa lista montada com os dados corretamente atribuídos, você consegue utilizar o sort. Mas antes de tudo, preciso saber se vc sabe como fazer os passos que citei acima.

jhonvirtuoso 18 de mar. de 2020

A parte da classe é tranquilo, problema é implementar isso dentro de uma lista, sabes algum site como exemplo para que eu possa ver?

Lucas_Camara 18 de mar. de 2020 1 like

Para implementar uma lista de objetos (um objeto é criado a partir de uma classe). Você faz assim:

List<Processo> processos = new ArrayList<>();

Processo será sua classe que representa um processo.

Solucao aceita

staroski 18 de mar. de 2020 1 like

Primeiro crie uma classe para representar cada Processo e seus atributos:

package filadeprocessos;

public final class Processo {

    public final int entrada;
    public final int prioridade;
    public final int tamanho;

    public Processo(int entrada, int prioridade, int tamanho) {
        this.entrada = entrada;
        this.prioridade = prioridade;
        this.tamanho = tamanho;
    }

    @Override
    public String toString() {
        return String.format("Processo [prioridade=%s, entrada=%s, tamanho=%s]", prioridade, entrada, tamanho);
    }
}

Agora que você tem uma classe Processo, basta implementar um Comparator que respeite essa ordem de prioridades:

Comparator<Processo> comparador = new Comparator<Processo>() {

    @Override
    public int compare(Processo p1, Processo p2) {
        int diferenca = p1.prioridade - p2.prioridade; // compara a prioridade
        if (diferenca == 0) { // se prioridades forem iguais
            diferenca = p1.entrada - p2.entrada; // compara a entrada
        }
        if (diferenca == 0) { // se entradas forem iguais
            diferenca = p1.tamanho - p2.tamanho; // compara o tamanho
        }
        return diferenca;
    }
};

Abaixo o seu programa reescrito:

package filadeprocessos;

import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class FilaDeProcessos {

    public static void main(String[] args) {
        FilaDeProcessos programa = new FilaDeProcessos();
        programa.executar();
    }

    private final Scanner entradaDados = new Scanner(System.in);
    private final PrintStream saidaDados = System.out;

    public void executar() {
        List<Processo> processos = cadastrar();
        apresentar("Antes de ordenar:", processos);
        ordenar(processos);
        apresentar("Depois de ordenar:", processos);
    }

    private void apresentar(String mensagem, List<Processo> processos) {
        saidaDados.println(mensagem);
        for (Processo processo : processos) {
            saidaDados.println("    " + processo);
        }
    }

    private List<Processo> cadastrar() {
        saidaDados.println("Quantos processos deseja armazenar? ");
        int quantidadeProcessos = Integer.parseInt(entradaDados.nextLine());

        List<Processo> processos = new ArrayList<>();
        for (int i = 0; i < quantidadeProcessos; i++) {
            int numero = i + 1;

            saidaDados.println("Qual a entrada do processo " + numero + "?");
            int entrada = Integer.parseInt(entradaDados.nextLine());

            saidaDados.println("Qual a prioridade do processo " + numero + "?");
            int prioridade = Integer.parseInt(entradaDados.nextLine());

            saidaDados.println("Qual o tamanho do processo " + numero + "?");
            int tamanho = Integer.parseInt(entradaDados.nextLine());

            Processo processo = new Processo(entrada, prioridade, tamanho);
            processos.add(processo);
        }
        return processos;
    }

    private void ordenar(List<Processo> processos) {
        // Comparador utilizado para ordenar os processos em ordem de prioridade, entrada e tamanho
        Comparator<Processo> comparador = new Comparator<Processo>() {

            @Override
            public int compare(Processo p1, Processo p2) {
                int diferenca = p1.prioridade - p2.prioridade; // compara a prioridade
                if (diferenca == 0) { // se prioridades forem iguais
                    diferenca = p1.entrada - p2.entrada; // compara a entrada
                }
                if (diferenca == 0) { // se entradas forem iguais
                    diferenca = p1.tamanho - p2.tamanho; // compara o tamanho
                }
                return diferenca;
            }
        };
        // Executa a ordenação com o comparador especificado
        Collections.sort(processos, comparador);
    }
}

jhonvirtuoso 18 de mar. de 2020 1 like

Era isso que eu queria, muito obrigado pela ajuda! Vou fechar e colocar como resolvido, salvasse meu dia kkkk vlw

Criado 18 de março de 2020

Ultima resposta 18 de mar. de 2020

Respostas 5

Participantes 3

5 Respostas

Topicos relacionados