(Resolvido) É possível declara um vetor e definir o tipo dele depois em Java?

Programação
#1

É possível declara um vetor e definir o tipo dele em um método, ou converter o tipo dele ou criar um método que retorna mais de um tipo de dado em Java?

Eu estou fazendo um programa para comparar o desempenho de algoritmos de ordenação, esses algoritmos são genéricos e aceitam os tipos da classe Wrapper.

No programa é possível definir o tamanho e o tipo do vetor a ser ordenado, porem estou com problemas para passar o vetor gerado para os métodos de ordenação, para gerar o vetor um método recebe o tipo e o tamanho, analisa o tipo e gera o vetor em um Switch case, porem só esta dando certo fazendo chamadas para cada ordenador dentro de cada opção desse Switch case, assim deixando o método poluído e repetindo código.

public void calculateTime(String dataType, int size) {
		switch (dataType) {
		case "Character": {
			Character[] baseVector = VectorFactory.characterVectorFactory(size);

			Character[] vector = baseVector;
			startTime = System.nanoTime();
			BubbleSort.sort(vector);
			finalTime = System.nanoTime();
			bubbleSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			CycleSort.sort(vector);
			finalTime = System.nanoTime();
			cycleSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			HeapSort.sort(vector);
			finalTime = System.nanoTime();
			heapSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			InsertionSort.sort(vector);
			finalTime = System.nanoTime();
			insertionSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			MergeSort.sort(vector);
			finalTime = System.nanoTime();
			mergeSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			QuickSort.sort(vector);
			finalTime = System.nanoTime();
			quickSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			SelectionSort.sort(vector);
			finalTime = System.nanoTime();
			selectionSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			ShellSort.sort(vector);
			finalTime = System.nanoTime();
			shellSortTime = finalTime - startTime;
			break;
		}
		case "Double":{
			Double[] baseVector = VectorFactory.doubleVectorFactory(size);

			Double[] vector = baseVector;
			startTime = System.nanoTime();
			BubbleSort.sort(vector);
			finalTime = System.nanoTime();
			bubbleSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			CycleSort.sort(vector);
			finalTime = System.nanoTime();
			cycleSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			HeapSort.sort(vector);
			finalTime = System.nanoTime();
			heapSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			InsertionSort.sort(vector);
			finalTime = System.nanoTime();
			insertionSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			MergeSort.sort(vector);
			finalTime = System.nanoTime();
			mergeSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			QuickSort.sort(vector);
			finalTime = System.nanoTime();
			quickSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			SelectionSort.sort(vector);
			finalTime = System.nanoTime();
			selectionSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			ShellSort.sort(vector);
			finalTime = System.nanoTime();
			shellSortTime = finalTime - startTime;
			break;
		}
		case "Integer":{
			Integer[] baseVector = VectorFactory.integerVectorFactory(size);

			Integer[] vector = baseVector;
			startTime = System.nanoTime();
			BubbleSort.sort(vector);
			finalTime = System.nanoTime();
			bubbleSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			CycleSort.sort(vector);
			finalTime = System.nanoTime();
			cycleSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			HeapSort.sort(vector);
			finalTime = System.nanoTime();
			heapSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			InsertionSort.sort(vector);
			finalTime = System.nanoTime();
			insertionSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			MergeSort.sort(vector);
			finalTime = System.nanoTime();
			mergeSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			QuickSort.sort(vector);
			finalTime = System.nanoTime();
			quickSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			SelectionSort.sort(vector);
			finalTime = System.nanoTime();
			selectionSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			ShellSort.sort(vector);
			finalTime = System.nanoTime();
			shellSortTime = finalTime - startTime;
			break;
		}
		case "String":{
			String[] baseVector = VectorFactory.stringVectorFactory(size);

			String[] vector = baseVector;
			startTime = System.nanoTime();
			BubbleSort.sort(vector);
			finalTime = System.nanoTime();
			bubbleSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			CycleSort.sort(vector);
			finalTime = System.nanoTime();
			cycleSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			HeapSort.sort(vector);
			finalTime = System.nanoTime();
			heapSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			InsertionSort.sort(vector);
			finalTime = System.nanoTime();
			insertionSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			MergeSort.sort(vector);
			finalTime = System.nanoTime();
			mergeSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			QuickSort.sort(vector);
			finalTime = System.nanoTime();
			quickSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			SelectionSort.sort(vector);
			finalTime = System.nanoTime();
			selectionSortTime = finalTime - startTime;

			vector = baseVector;
			startTime = System.nanoTime();
			ShellSort.sort(vector);
			finalTime = System.nanoTime();
			shellSortTime = finalTime - startTime;
			break;
		}
		}
	}
#2

É possível, você pode usar generics para isso. Aliás, você já está usando.
Se você reparar, seus métodos BubbleSort.sort, CycleSort.sort, etc, aceitam qualquer tipo de array que você passa.

Você pode fazer o mesmo assim:


<T> void calculateTimes(T[] baseVector) {
    T[] vector = Arrays.copyOf(baseVector, data.length);
    startTime = System.nanoTime();
    BubbleSort.sort(vector);
    finalTime = System.nanoTime();
    bubbleSortTime = finalTime - startTime;

    // e todos os outros
}

e para chamar isso, você usa seu switch case normalmente:

switch (dataType) {
case "Character": {
  Character[] baseVector = VectorFactory.characterVectorFactory(size);
  calculateTimes(baseVector);
case "Double":{
  Double[] baseVector = VectorFactory.doubleVectorFactory(size);
  calculateTimes(baseVector);
// continua

Duas observações:

  • Tem um bug no seu código atual, você não faz uma cópia do array. Ou seja, tirando o BubbleSort, todos os outros métodos já recebem o array ordenado. Por isso no meu código estou usando Arrays.copyOf para copiar o array antes de modificá-lo.

  • Você pode extrair a parte de contar o tempo em si também em um método para não repetir esses blocos também. A única diferença de cada bloco é o método chamado (BubbleSort, CycleSort, etc). Nesse novo método você passaria esse comando como parâmetro também.
    Porém isso já pode ser mais avançado para você por enquanto.

Ah, uma última observação. O jeito que você está medindo o tempo de cada algoritmo, não é uma boa maneira de fazer em java. A JVM aplica uma série de otimizações quando seu código roda em produção, então seu código acima acaba não sendo um retrato fiel disso.
Tem frameworks que te ajuda a fazer um benchmark correto para java. Dá uma olhada nesse artigo: https://www.baeldung.com/java-microbenchmark-harness

2 curtidas
#3

Muito obrigado, me esclareceu algumas coisas, porem ainda não deu certo.

Esta acusando erro “The method sort(T[ ]) in the type BubbleSort is not applicable for the arguments (T[ ])” nas linhas de chamada dos métodos.

Os métodos de ordenação estão todos declarados dessa forma.

public class BubbleSort {
	public static <T extends Comparable<T>> void sort(T[] vector) {
		T temp;
		for (int i = vector.length -1; i > 0; i--) {
			for(int j = 0; j < i; j++) {
				if(vector[j].compareTo(vector[j+1]) > 0) {
					temp = vector[j];
					vector[j] = vector[j+1];
					vector[j+1] = temp;
				}
			}
		}
	}
}
#4 
    var vector = new Long[] {1L, 3L, 2L, 4L};
    BubbleSort.sort(vector);

    for (Long l : vector) {
        System.out.println(l);
    }

Aqui funcionou, tem certeza que o que você passou estende Comparable?

1 curtida
#5

Ah sim, a resposta está no seu próprio método BubbleSort.sort.

Mude essa linha:

<T> void calculateTimes(T[] baseVector) {

Para:

<T extends Comparable<T>> void calculateTimes(T[] baseVector) {
1 curtida
#6

Deu certinho, e sobre contar o tempo a partir de uma método a parte, como eu chamaria os ordenadores de forma otimizada?

#7

Obrigado pela a sua resposta.